@mark1russell7/highways 0.4.2 → 0.5.0

package/src/routers/shared.ts

@@ -1,5 +1,6 @@
 import { center, dist, type Point } from "../geom.ts";
 import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { channelWidth } from "../channels.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { buildSections, type Section } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -44,6 +45,20 @@ export interface SharedOptions extends WayOptions {
    * With `snell`, the route meets the run at the angle `acos(d)`, with `d` the cost share of the run for the route (NAT-035).
    */
   readonly merge?: ShareMerge;
+  /**
+   * The pull of the busy links of the pass before (HWY-005, Winding Roads). With a value above 0 and two passes or more, each later pass routes each edge again from no ways.
+   * A link then costs `len / (1 + reuse * u)^reuseExponent`, with `u` the edges of the key on it in the pass before. The default is 0: the later passes are rip-up passes.
+   */
+  readonly reuse?: number;
+  /** The exponent of the pull of `reuse`. The default is 1. */
+  readonly reuseExponent?: number;
+  /**
+   * The cost of a lane that does not fit in its channel (HWY-016). One more edge on a link with `f` edges of the key costs `capacity * max(0, (f + 1) * laneWidth - width)` more.
+   * `width` is the free space across the link (`channelWidth`). The default is 0: the router does not read the channels.
+   */
+  readonly capacity?: number;
+  /** The width of one lane, for `capacity`. The default is 4. */
+  readonly laneWidth?: number;
   /** The benchmark skips a fixture with more nodes. */
   readonly maxNodes?: number;
 }
@@ -94,6 +109,10 @@ export function sharedRouter(options: SharedOptions): Router {
   // The cost share of a link for one more edge, when `f` edges of the key use it already. The share falls when `f` grows.
   const share = (f: number): number => (f <= 0 ? 1 : flow ? (f + 1) ** alpha - f ** alpha : discount);
   const passes = Math.max(1, Math.floor(options.passes ?? 1));
+  const reuse = Math.max(0, options.reuse ?? 0);
+  const reuseExponent = Math.max(0, options.reuseExponent ?? 1);
+  const capacity = Math.max(0, options.capacity ?? 0);
+  const laneWidth = Math.max(0, options.laneWidth ?? 4);
   const keyOf = (e: Edge): string => {
     if (!options.rule) return "*";
     return options.rule(e) ?? `\u0000${e.id}`;
@@ -131,14 +150,34 @@ export function sharedRouter(options: SharedOptions): Router {
       const order = orderWays(all, options.order ?? "span", graph);
       // The largest number of edges on one link of each key. The cost share of that number is the floor of the search.
       const top = new Map<string, number>();
-      const route = (w: Way): void => {
+      // The width of the channel of each link, for the option `capacity`. Each link gets its width at its first use.
+      const widths = new Map<number, number>();
+      const widthOf = (i: number, j: number): number => {
+        const k = link(i, j);
+        let wd = widths.get(k);
+        if (wd === undefined) widths.set(k, (wd = channelWidth(ways.obstacles, corners.points[i]!, corners.points[j]!)));
+        return wd;
+      };
+      /** This function routes one way. `before` holds the edges of the key on each link in the pass before, for the option `reuse`. */
+      const route = (w: Way, before?: ReadonlyMap<number, number>): void => {
         let used = discounted.get(w.key);
         if (!used) discounted.set(w.key, (used = new Map()));
         const mine = used;
-        const floor = flow ? share(top.get(w.key) ?? 0) : discount;
-        const cost = flow
+        let floor = flow ? share(top.get(w.key) ?? 0) : discount;
+        let cost = flow
           ? (i: number, j: number, d: number): number => d * share(mine.get(link(i, j))?.length ?? 0)
           : (i: number, j: number, d: number): number => (mine.has(link(i, j)) ? d * discount : d);
+        if (capacity > 0) {
+          const plain = cost;
+          cost = (i, j, d) => plain(i, j, d) + capacity * Math.max(0, ((mine.get(link(i, j))?.length ?? 0) + 1) * laneWidth - widthOf(i, j));
+        }
+        if (before !== undefined) {
+          const plain = cost;
+          let most = 0;
+          for (const u of before.values()) most = Math.max(most, u);
+          cost = (i, j, d) => plain(i, j, d) / (1 + reuse * (before.get(link(i, j)) ?? 0)) ** reuseExponent;
+          floor /= (1 + reuse * most) ** reuseExponent;
+        }
         const way = corners.path(ways.out(w.ps), ways.out(w.pt), cost, floor);
         if (!way) return;
         w.found = true;
@@ -157,6 +196,20 @@ export function sharedRouter(options: SharedOptions): Router {
       for (const w of order) route(w);
       // Each later pass takes each edge off its links and finds its way again, with the ways of the other edges fixed.
       for (let pass = 1; pass < passes; pass++) {
+        if (reuse > 0) {
+          // Winding Roads (HWY-005): each edge finds its way again from no ways, and the busy links of the pass before pull it.
+          const before = new Map<string, Map<number, number>>();
+          for (const [key, links] of discounted) before.set(key, new Map([...links].map(([k, list]) => [k, list.length])));
+          discounted.clear();
+          top.clear();
+          for (const w of order) {
+            w.found = false;
+            w.seq = [];
+            w.ids = [];
+          }
+          for (const w of order) route(w, before.get(w.key) ?? new Map());
+          continue;
+        }
         for (const w of order) {
           if (!w.found) continue;
           const mine = discounted.get(w.key)!;

package/src/strategies/builtins.ts

@@ -18,17 +18,31 @@ import { hysteresisGate, type HysteresisOptions } from "../highways/gates/hyster
 import { stableIdGate, type StableIdOptions } from "../highways/gates/ids/index.ts";
 import { gateStrategy } from "../highways/gates/model.ts";
 import { stretchGate, type StretchOptions } from "../highways/gates/stretch/index.ts";
+import { DIFFUSION_DEFAULTS, diffusionPlan, type DiffusionOptions } from "../highways/diffusion/index.ts";
+import { FLOW_CLUSTER_DEFAULTS, flowClusterPlan, type FlowClusterOptions } from "../highways/flow-clusters/index.ts";
+import { EDGE_PATH_DEFAULTS, edgePathPlan, type EdgePathOptions } from "../highways/edge-paths/index.ts";
+import { HDBSCAN_DEFAULTS, hdbscanPlan, type HdbscanOptions } from "../highways/hdbscan/index.ts";
+import { HOUGH_DEFAULTS, houghPlan, type HoughOptions } from "../highways/hough/index.ts";
+import { HUB_ARC_DEFAULTS, hubArcPlan, type HubArcOptions } from "../highways/hub-arcs/index.ts";
+import { RIDGE_DEFAULTS, ridgePlan, type RidgeOptions } from "../highways/ridges/index.ts";
+import { SOFT_KEY_DEFAULTS, softKeyPlan, type SoftKeyOptions } from "../highways/soft-keys/index.ts";
 import { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FlowFieldOptions } from "../highways/flow-field/index.ts";
 import { keysPlan, type KeysOptions } from "../highways/keys/index.ts";
 import { LEVEL_HIGHWAY_DEFAULTS, levelHighwayPlan, type LevelHighwayOptions } from "../highways/level-links/index.ts";
 import { MEET_DEFAULTS, meetPlan, type MeetOptions } from "../highways/meet/index.ts";
+import { MINGLE_DEFAULTS, minglePlan, type MingleOptions } from "../highways/mingle/index.ts";
 import type { HighwayInput } from "../highways/model.ts";
 import { OD_CELL_DEFAULTS, odCellPlan, type OdCellOptions } from "../highways/od-cells/index.ts";
 import { QUICKBUNDLES_DEFAULTS, quickBundlesPlan, type QuickBundlesOptions } from "../highways/quickbundles/index.ts";
+import { NESTED_DEFAULTS, nestedPlan, type NestedOptions } from "../highways/nested/index.ts";
+import { LANES_DEFAULTS, lanesPlan, type LanesOptions } from "../highways/lanes/index.ts";
+import { GROWTH_DEFAULTS, growthPlan, type GrowthOptions } from "../highways/growth/index.ts";
 import { ROAD_CLASS_DEFAULTS, roadClassPlan, type RoadClassOptions } from "../highways/road-classes/index.ts";
 import { SELECT_DEFAULTS, selectPlan, type SelectOptions } from "../highways/select/index.ts";
 import { sharedWaysPlan, type SharedWaysOptions } from "../highways/shared-ways/index.ts";
+import { SPIRAL_DEFAULTS, spiralPlan, type SpiralOptions } from "../highways/spiral/index.ts";
 import { STUB_DEFAULTS, stubPlan, type StubOptions } from "../highways/stubs/index.ts";
+import { TRACLUS_DEFAULTS, traclusPlan, type TraclusOptions } from "../highways/traclus/index.ts";
 import { WEISZFELD_DEFAULTS, weiszfeldPlan, type WeiszfeldOptions } from "../highways/weiszfeld/index.ts";
 import { WSPD_DEFAULTS, wspdPlan, type WspdOptions } from "../highways/wspd/index.ts";
 import { ZIPPER_DEFAULTS, zipperPlan, type ZipperOptions } from "../highways/zipper/index.ts";
@@ -44,7 +58,7 @@ import { byCollection, trunksRouter, type TrunksOptions } from "../routers/trunk
 import { buildSections, SECTION_DEFAULTS, type SectionOptions } from "../sections.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 import type { OptionSchema } from "./options.ts";
-import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CUT_SCHEMA, FLOW_FIELD_SCHEMA, HIGHWAY_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, EDGE_PATH_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, MEET_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA } from "./schemas.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">;
@@ -389,6 +403,20 @@ export const highwayStrategies: {
   readonly wspd: Strategy<"highway", WspdOptions>;
   readonly "od-cells": Strategy<"highway", OdCellOptions>;
   readonly select: Strategy<"highway", SelectOptions>;
+  readonly mingle: Strategy<"highway", MingleOptions>;
+  readonly spiral: Strategy<"highway", SpiralOptions>;
+  readonly "flow-clusters": Strategy<"highway", FlowClusterOptions>;
+  readonly traclus: Strategy<"highway", TraclusOptions>;
+  readonly diffusion: Strategy<"highway", DiffusionOptions>;
+  readonly nested: Strategy<"highway", NestedOptions>;
+  readonly lanes: Strategy<"highway", LanesOptions>;
+  readonly growth: Strategy<"highway", GrowthOptions>;
+  readonly "edge-paths": Strategy<"highway", EdgePathOptions>;
+  readonly "soft-keys": Strategy<"highway", SoftKeyOptions>;
+  readonly hough: Strategy<"highway", HoughOptions>;
+  readonly ridges: Strategy<"highway", RidgeOptions>;
+  readonly hdbscan: Strategy<"highway", HdbscanOptions>;
+  readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -513,6 +541,132 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<SelectOptions>) => selectPlan(input, o),
   }),
+  mingle: defineStrategy({
+    step: "highway",
+    name: "mingle",
+    describe: "MINGLE (HWY-003). Edges are points in 4D. Near bundles merge level by level while the merge saves ink, and each bundle gets one trunk.",
+    defaults: { ...MINGLE_DEFAULTS } as MingleOptions,
+    schema: MINGLE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MingleOptions>) => minglePlan(input, o),
+  }),
+  spiral: defineStrategy({
+    step: "highway",
+    name: "spiral",
+    describe: "Spiral trees (HWY-017, EDA-035). The edges of a node with many edges branch on arcs of spirals, and each branch with two edges is a highway.",
+    defaults: { ...SPIRAL_DEFAULTS } as SpiralOptions,
+    schema: SPIRAL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SpiralOptions>) => spiralPlan(input, o),
+  }),
+  "flow-clusters": defineStrategy({
+    step: "highway",
+    name: "flow-clusters",
+    describe: "Flow clusters (HWY-023). A hierarchical clustering puts the edges with near sources and near targets together, and each cluster gets highways.",
+    defaults: { ...FLOW_CLUSTER_DEFAULTS } as FlowClusterOptions,
+    schema: FLOW_CLUSTER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FlowClusterOptions>) => flowClusterPlan(input, o),
+  }),
+  traclus: defineStrategy({
+    step: "highway",
+    name: "traclus",
+    describe: "TRACLUS (HWY-025). The first routes break into segments, and the dense clusters of near segments become highways.",
+    defaults: { ...TRACLUS_DEFAULTS } as TraclusOptions,
+    schema: TRACLUS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<TraclusOptions>) => traclusPlan(input, o),
+  }),
+  diffusion: defineStrategy({
+    step: "highway",
+    name: "diffusion",
+    describe: "Route-aware bundling (HWY-020). The density of the first ways diffuses on the corner graph, and dense links cost less in a second pass.",
+    defaults: { ...DIFFUSION_DEFAULTS } as DiffusionOptions,
+    schema: DIFFUSION_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<DiffusionOptions>) => diffusionPlan(input, o),
+  }),
+  nested: defineStrategy({
+    step: "highway",
+    name: "nested",
+    describe: "Highways for each zoom level that nest (HWY-052). Each level puts the edges of each cluster of the level above in finer clusters.",
+    defaults: { ...NESTED_DEFAULTS } as NestedOptions,
+    schema: NESTED_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<NestedOptions>) => nestedPlan(input, o),
+  }),
+  lanes: defineStrategy({
+    step: "highway",
+    name: "lanes",
+    describe: "Width, lanes and capacity (HWY-051). A highway that does not fit in its channels splits into two highways by lane order.",
+    defaults: { ...LANES_DEFAULTS } as LanesOptions,
+    schema: LANES_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<LanesOptions>) => lanesPlan(input, o),
+  }),
+  growth: defineStrategy({
+    step: "highway",
+    name: "growth",
+    describe: "Local growth (HWY-055). Each edge, the longest first, joins the highway with the largest saving, or starts a highway.",
+    defaults: { ...GROWTH_DEFAULTS } as GrowthOptions,
+    schema: GROWTH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<GrowthOptions>) => growthPlan(input, o),
+  }),
+  "edge-paths": defineStrategy({
+    step: "highway",
+    name: "edge-paths",
+    describe: "Edge-path bundling (HWY-012). An edge with a short path of other edges follows their ways, and the shared stretches become highways.",
+    defaults: { ...EDGE_PATH_DEFAULTS } as EdgePathOptions,
+    schema: EDGE_PATH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<EdgePathOptions>) => edgePathPlan(input, o),
+  }),
+  "soft-keys": defineStrategy({
+    step: "highway",
+    name: "soft-keys",
+    describe: "Soft keys (HWY-019). The key of an edge adds a distance to the flow distance, and a hierarchical clustering makes the highways.",
+    defaults: { ...SOFT_KEY_DEFAULTS } as SoftKeyOptions,
+    schema: SOFT_KEY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SoftKeyOptions>) => softKeyPlan(input, o),
+  }),
+  hough: defineStrategy({
+    step: "highway",
+    name: "hough",
+    describe: "Hough votes (HWY-024). The straight lines of the edges vote for corridors, and each peak of the votes becomes a highway.",
+    defaults: { ...HOUGH_DEFAULTS } as HoughOptions,
+    schema: HOUGH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HoughOptions>) => houghPlan(input, o),
+  }),
+  ridges: defineStrategy({
+    step: "highway",
+    name: "ridges",
+    describe: "Ridges of the line density (HWY-032). The ridges of the blurred density of the edges become highways, and near edges snap to them.",
+    defaults: { ...RIDGE_DEFAULTS } as RidgeOptions,
+    schema: RIDGE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<RidgeOptions>) => ridgePlan(input, o),
+  }),
+  hdbscan: defineStrategy({
+    step: "highway",
+    name: "hdbscan",
+    describe: "HDBSCAN on edges (HWY-028). The density clusters of the edges that live over a long range become highways.",
+    defaults: { ...HDBSCAN_DEFAULTS } as HdbscanOptions,
+    schema: HDBSCAN_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HdbscanOptions>) => hdbscanPlan(input, o),
+  }),
+  "hub-arcs": defineStrategy({
+    step: "highway",
+    name: "hub-arcs",
+    describe: "Hub arc location (HWY-042). A greedy pass with swaps chooses at most q arcs from the candidates, and each edge rides its best arc.",
+    defaults: { ...HUB_ARC_DEFAULTS } as HubArcOptions,
+    schema: HUB_ARC_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HubArcOptions>) => hubArcPlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),

package/src/strategies/schemas.ts

@@ -3,15 +3,29 @@ import type { KdOptions } from "../groups/kd/index.ts";
 import type { KeyOptions } from "../groups/keys/index.ts";
 import type { HighwayBase } from "../highways/base.ts";
 import type { CorridorOptions } from "../highways/corridors/index.ts";
+import type { DiffusionOptions } from "../highways/diffusion/index.ts";
+import type { EdgePathOptions } from "../highways/edge-paths/index.ts";
+import type { FlowClusterOptions } from "../highways/flow-clusters/index.ts";
 import type { FlowFieldOptions } from "../highways/flow-field/index.ts";
+import type { GrowthOptions } from "../highways/growth/index.ts";
 import type { GroupSpine } from "../highways/grouped.ts";
+import type { HdbscanOptions } from "../highways/hdbscan/index.ts";
+import type { HoughOptions } from "../highways/hough/index.ts";
+import type { HubArcOptions } from "../highways/hub-arcs/index.ts";
+import type { LanesOptions } from "../highways/lanes/index.ts";
 import type { LevelHighwayOptions } from "../highways/level-links/index.ts";
 import type { MeetOptions } from "../highways/meet/index.ts";
+import type { MingleOptions } from "../highways/mingle/index.ts";
+import type { NestedOptions } from "../highways/nested/index.ts";
 import type { OdCellOptions } from "../highways/od-cells/index.ts";
 import type { QuickBundlesOptions } from "../highways/quickbundles/index.ts";
+import type { RidgeOptions } from "../highways/ridges/index.ts";
 import type { RoadClassOptions } from "../highways/road-classes/index.ts";
 import type { SelectOptions } from "../highways/select/index.ts";
+import type { SoftKeyOptions } from "../highways/soft-keys/index.ts";
+import type { SpiralOptions } from "../highways/spiral/index.ts";
 import type { StubOptions } from "../highways/stubs/index.ts";
+import type { TraclusOptions } from "../highways/traclus/index.ts";
 import type { WeiszfeldOptions } from "../highways/weiszfeld/index.ts";
 import type { WspdOptions } from "../highways/wspd/index.ts";
 import type { ZipperOptions } from "../highways/zipper/index.ts";
@@ -121,6 +135,24 @@ export const SHARED_SCHEMA: OptionSchema<RouterPreset<SharedOptions>> = {
     default: "span",
     describe: "The order of the edges of a key: the longest first, the shortest first, the most edges between two sections first, or the input order (NAT-024).",
   },
+  reuse: {
+    type: "number",
+    min: 0,
+    max: 2,
+    step: 0.25,
+    default: 0,
+    describe: "With a value above 0, each later pass routes the edges again, and the busy links of the pass before cost less (HWY-005).",
+  },
+  reuseExponent: { type: "number", min: 0.5, max: 2, step: 0.25, default: 1, describe: "The exponent of the pull of the busy links of the option `reuse`." },
+  capacity: {
+    type: "number",
+    min: 0,
+    max: 10,
+    step: 0.5,
+    default: 0,
+    describe: "With a value above 0, a link costs more for each lane that does not fit in the free space across it (HWY-016).",
+  },
+  laneWidth: { type: "number", min: 2, max: 8, step: 1, default: 4, describe: "The width of one lane, for the option `capacity`." },
   merge: {
     type: "enum",
     values: ["corner", "snell"],
@@ -403,3 +435,151 @@ export const SELECT_SCHEMA: OptionSchema<SelectOptions> = {
   lambda: { type: "number", min: 0, max: 4, step: 0.25, marks: [0.5, 1, 2], default: 1, describe: "The weight of the added length of the edges against the ink that a highway saves." },
   swaps: { type: "integer", min: 0, max: 5, step: 1, default: 2, describe: "The number of passes of the local search with one swap." },
 };
+
+/** The declarations of the options of the highway strategy `mingle` (HWY-003). */
+export const MINGLE_SCHEMA: OptionSchema<MingleOptions> = {
+  k: { type: "integer", min: 4, max: 16, step: 1, default: 8, describe: "Each bundle looks for a merge among this number of nearest bundles in 4D." },
+  maxTurn: { type: "number", min: 20, max: 60, step: 5, marks: [20, 40, 60], default: 40, describe: "The largest turn of an edge at a meeting point, in degrees." },
+  levels: { type: "integer", min: 1, max: 10, step: 1, default: 6, describe: "The number of levels of merges." },
+  weight: { type: "number", min: 0.5, max: 1, step: 0.05, default: 1, describe: "The weight of the trunk in the ink. With 1, the trunk costs its length one time." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A bundle with this number of edges or more gets highways." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `spiral` (HWY-017 with EDA-035). */
+export const SPIRAL_SCHEMA: OptionSchema<SpiralOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  alpha: { type: "number", min: 10, max: 40, step: 5, marks: [15, 25, 35], default: 25, describe: "The spiral angle, in degrees: the largest angle between a branch and the line to the root." },
+  minTargets: { type: "integer", min: 3, max: 20, step: 1, default: 4, describe: "A node with this number of edges or more gets a spiral tree." },
+  arc: { type: "integer", min: 2, max: 8, step: 1, default: 4, describe: "The number of points of the arc of each branch." },
+};
+
+/** The declarations of the options of the highway strategy `flow-clusters` (HWY-023). */
+export const FLOW_CLUSTER_SCHEMA: OptionSchema<FlowClusterOptions> = {
+  tau: { type: "number", min: 0.1, max: 0.6, step: 0.05, marks: [0.2, 0.3, 0.45], default: 0.3, describe: "Two clusters join while their distance is this share of the length of the shorter edge, or less." },
+  linkage: { type: "enum", values: ["average", "complete", "single"], default: "average", describe: "The distance of two clusters: the mean, the largest or the smallest distance of their edges." },
+  directed: { type: "boolean", default: false, describe: "With this option, the source of one edge only compares with the source of the other edge." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A cluster with this number of edges or more gets highways." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `traclus` (HWY-025). */
+export const TRACLUS_SCHEMA: OptionSchema<TraclusOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  eps: { type: "number", min: 1, max: 6, step: 0.5, marks: [1, 2, 4], default: 2, describe: "Two segments are neighbours when their distance is this value or less, in units of the board." },
+  minLns: { type: "integer", min: 2, max: 16, step: 1, default: 3, describe: "A cluster has segments of this number of edges or more." },
+  wPerp: { type: "number", min: 0, max: 2, step: 0.25, default: 1, describe: "The weight of the perpendicular distance." },
+  wPar: { type: "number", min: 0, max: 2, step: 0.25, default: 1, describe: "The weight of the parallel distance." },
+  wTheta: { type: "number", min: 0, max: 2, step: 0.25, default: 1, describe: "The weight of the angle distance." },
+  mdl: { type: "number", min: 0.5, max: 2, step: 0.25, default: 1, describe: "A route keeps a corner when the cost without it is more than this value times the cost with it." },
+};
+
+/** The declarations of the options of the highway strategy `diffusion` (HWY-020). */
+export const DIFFUSION_SCHEMA: OptionSchema<DiffusionOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  a: { type: "number", min: 0, max: 0.5, step: 0.05, default: 0.25, describe: "The share of the density that each step takes from the links next to a link." },
+  steps: { type: "integer", min: 0, max: 10, step: 1, default: 3, describe: "The number of steps of the diffusion." },
+  lambda: { type: "number", min: 0, max: 2, step: 0.25, marks: [0.5, 1, 2], default: 1, describe: "The weight of the density in the cost of a link." },
+  gamma: { type: "number", min: 0.5, max: 2, step: 0.25, default: 1, describe: "The power of the discount of a dense link." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway has this number of edges or more." },
+};
+
+/** The declarations of the options of the highway strategy `nested` (HWY-052). */
+export const NESTED_SCHEMA: OptionSchema<NestedOptions> = {
+  theta: QUICKBUNDLES_SCHEMA.theta,
+  ratio: { type: "number", min: 1.5, max: 4, step: 0.5, default: 2, describe: "The scale of each level is this value times the scale of the next closer level." },
+  levels: { type: "integer", min: 1, max: 6, step: 1, default: 3, describe: "The number of levels." },
+  level: { type: "integer", min: 0, max: 5, step: 1, default: 0, describe: "The level of the plan. Level 0 is the closest level." },
+  points: QUICKBUNDLES_SCHEMA.points,
+  line: QUICKBUNDLES_SCHEMA.line,
+  order: QUICKBUNDLES_SCHEMA.order,
+  minSize: QUICKBUNDLES_SCHEMA.minSize,
+  spine: GROUP_SPINE,
+};
+
+/** The declarations of the options of the highway strategy `lanes` (HWY-051). */
+export const LANES_SCHEMA: OptionSchema<LanesOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  from: HIGHWAY_BASE,
+  laneGap: { type: "number", min: 2, max: 8, step: 1, default: 4, describe: "The gap between two lanes." },
+  maxWidth: { type: "number", min: 8, max: 64, step: 4, default: 32, describe: "The largest width of a highway." },
+  depth: { type: "integer", min: 0, max: 5, step: 1, default: 3, describe: "The number of times that a highway can split, one half after the other." },
+};
+
+/** The declarations of the options of the highway strategy `growth` (HWY-055). */
+export const GROWTH_SCHEMA: OptionSchema<GrowthOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  order: { type: "enum", values: ["length", "input"], default: "length", describe: "The order of the edges: the longest first route first, or the order of the graph." },
+  share: { type: "number", min: 0.1, max: 1, step: 0.05, marks: [0.5], default: 0.5, describe: "The cost of the part on a spine, as a share of its length." },
+  stretch: { type: "number", min: 1, max: 2, step: 0.05, marks: [1.3], default: 1.3, describe: "An edge joins a highway only when its way along it is this value times its first route or shorter." },
+  extendLanes: { type: "integer", min: 2, max: 8, step: 1, default: 3, describe: "A spine end extends when this number of its lanes or more go on together." },
+  extendRadius: { type: "number", min: 0.5, max: 6, step: 0.5, default: 2, describe: "The lanes go on together when their ends are this distance from their center or nearer, in units of the board." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway with this number of edges or more stays in the plan." },
+};
+
+/** The declarations of the options of the highway strategy `edge-paths` (HWY-012). */
+export const EDGE_PATH_SCHEMA: OptionSchema<EdgePathOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  distortion: { type: "number", min: 1.1, max: 4, step: 0.1, marks: [1.5, 2, 3], default: 2, describe: "An edge takes a path of other edges only when the path is this many times its own length or less." },
+  power: { type: "number", min: 1, max: 4, step: 0.5, default: 2, describe: "The weight of a link in the search is its length to this power." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway has this number of edges or more." },
+};
+
+/** The declarations of the options of the highway strategy `soft-keys` (HWY-019). */
+export const SOFT_KEY_SCHEMA: OptionSchema<SoftKeyOptions> = {
+  rule: { type: "function", describe: "The rule that gives the key of each edge. Two different keys add the distance `lambda`." },
+  lambda: { type: "number", min: 0, max: 2, step: 0.05, marks: [0, 0.25, 1], default: 0.25, describe: "The distance that two different keys add. A very large value keeps the keys apart." },
+  tau: { type: "number", min: 0.1, max: 1.5, step: 0.05, marks: [0.3, 0.5, 1], default: 0.5, describe: "Two clusters join while their distance is this value or less." },
+  attributes: { type: "list", default: [], describe: "The names of number fields of `data` that add a distance." },
+  weight: { type: "number", min: 0, max: 2, step: 0.25, default: 1, describe: "The weight of each field of `attributes`." },
+  linkage: { type: "enum", values: ["average", "complete", "single"], default: "average", describe: "The distance of two clusters: the mean, the largest or the smallest distance of their edges." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A cluster with this number of edges or more gets highways." },
+  spine: { ...GROUP_SPINE, default: "shared" },
+};
+
+/** The declarations of the options of the highway strategy `hough` (HWY-024). */
+export const HOUGH_SCHEMA: OptionSchema<HoughOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  dTheta: { type: "number", min: 2, max: 20, step: 1, marks: [4, 8, 12], default: 8, describe: "The width of the votes in the angle, in degrees." },
+  dRho: { type: "number", min: 4, max: 40, step: 2, marks: [8, 12, 24], default: 12, describe: "The width of the votes in the offset, in units of the board." },
+  minVotes: { type: "integer", min: 2, max: 16, step: 1, default: 3, describe: "A peak with fewer edges than this number is not a corridor." },
+  orthogonal: { type: "boolean", default: false, describe: "With this option, the peaks are only horizontal or vertical lines." },
+};
+
+/** The declarations of the options of the highway strategy `ridges` (HWY-032). */
+export const RIDGE_SCHEMA: OptionSchema<RidgeOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  source: { type: "enum", values: ["lines", "routes"], default: "lines", describe: "The lines of the density: the straight lines of the edges, or their first routes." },
+  cell: { type: "number", min: 2, max: 32, step: 1, marks: [4, 8, 16], default: 8, describe: "The size of a cell of the density image, in units of the board." },
+  bandwidth: { type: "number", min: 4, max: 64, step: 2, marks: [8, 16, 32], default: 16, describe: "The width of the blur of the density, in units of the board." },
+  strength: { type: "number", min: 0, max: 1, step: 0.05, default: 0.15, describe: "A cell is part of a ridge only when its strength is this share of the largest strength or more." },
+  minLength: { type: "number", min: 10, max: 300, step: 10, marks: [30, 60, 120], default: 60, describe: "A ridge has this length or more, in units of the board." },
+  snap: { type: "number", min: 2, max: 64, step: 2, marks: [8, 16, 32], default: 16, describe: "An edge snaps to a ridge where it is this distance from the ridge or nearer." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A ridge with this number of edges or more gets a highway." },
+};
+
+/** The declarations of the options of the highway strategy `hdbscan` (HWY-028). */
+export const HDBSCAN_SCHEMA: OptionSchema<HdbscanOptions> = {
+  minClusterSize: { type: "integer", min: 2, max: 16, step: 1, default: 3, describe: "A cluster has this number of edges or more." },
+  minSamples: { type: "integer", min: 1, max: 16, step: 1, default: 3, describe: "The core distance of an edge is the distance to its neighbour of this rank." },
+  distance: { type: "enum", values: ["compatibility", "flow"], default: "compatibility", describe: "The distance of two edges: 1 less their compatibility, or the flow distance of the ends." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `hub-arcs` (HWY-042). */
+export const HUB_ARC_SCHEMA: OptionSchema<HubArcOptions> = {
+  q: { type: "integer", min: 0, max: 64, step: 1, marks: [4, 12, 32], default: 12, describe: "The largest number of arcs." },
+  alpha: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.3, 0.5, 0.8], default: 0.5, describe: "The cost of a length on an arc against a length off the arcs." },
+  stretch: { type: "number", min: 1, max: 2, step: 0.05, marks: [1.25], default: 1.25, describe: "An edge rides an arc only when its way is this many times its first route or less." },
+  swaps: { type: "integer", min: 0, max: 5, step: 1, default: 1, describe: "The number of passes of the local search with one swap." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "An arc with fewer edges than this number is not a highway." },
+  generators: { type: "list", default: ["runs", "corridors", "road-classes"], describe: "The generators of the candidate arcs." },
+};

package/src/visibility.ts

@@ -211,6 +211,11 @@ export class CornerGraph {
     return n / 2;
   }
 
+  /** This method gives the corners that link to the corner `i`, in the order of their indexes. A corner that is not in the graph gives an empty list. */
+  neighbours(i: number): readonly number[] {
+    return this.#adj[i] ?? [];
+  }
+
   /** This method gives the index of the corner nearest to `p`, seen or not, or -1 when the graph has no corner near it. */
   nearest(p: Point): number {
     for (let r = this.#cell; r <= this.#cell * 64; r *= 2) {