@mark1russell7/highways 0.4.1 → 0.5.0

package/src/strategies/schemas.ts

@@ -1,7 +1,34 @@
 import type { CutOptions } from "../groups/cut/index.ts";
 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";
 import type { CornersOptions } from "../routers/corners.ts";
 import type { SectionsOptions } from "../routers/sections.ts";
 import type { SharedOptions } from "../routers/shared.ts";
@@ -108,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"],
@@ -283,3 +328,258 @@ export const CUT_SCHEMA: OptionSchema<CutOptions> = {
   pull: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 0.5, 1, 2, 4], default: 0.5, describe: "The cost of a line grows with its distance from the middle of the cell, by this factor." },
   guard: { type: "boolean", default: true, describe: "With `true`, each section also tests the quadtree split, and keeps the split that cuts fewer edges." },
 };
+
+/** The declaration of the plan that a post step of the step `highway` changes (BUILD-W2B). */
+const HIGHWAY_BASE: EnumOption<HighwayBase> = {
+  type: "enum",
+  values: ["none", "shared-ways", "corridors"],
+  default: "shared-ways",
+  describe: "The plan that the strategy changes: no highway, the highways of `shared-ways`, or the highways of `corridors`.",
+};
+
+/** The declarations of the options of the highway strategy `meet` (HWY-050). */
+export const MEET_SCHEMA: OptionSchema<MeetOptions> = {
+  from: HIGHWAY_BASE,
+  near: { type: "number", min: 2, max: 40, step: 2, default: 8, describe: "A first route meets the spine where it is this distance from the spine, or nearer." },
+  maxTurn: { type: "number", min: 10, max: 90, step: 5, default: 45, describe: "A first route meets the spine only where it runs at this angle to the spine, or less, in degrees." },
+  minRun: { type: "number", min: 0, max: 80, step: 5, default: 10, describe: "A member keeps its places when the stretch where its first route meets the spine is shorter than this length." },
+};
+
+/** The declarations of the options of the highway strategy `weiszfeld` (HWY-043). */
+export const WEISZFELD_SCHEMA: OptionSchema<WeiszfeldOptions> = {
+  from: HIGHWAY_BASE,
+  alpha: { type: "number", min: 0, max: 1, step: 0.1, default: 0.5, describe: "The weight of the trunk is `k^alpha` for `k` members." },
+  steps: { type: "integer", min: 1, max: 50, step: 1, marks: [10, 20, 50], default: 20, describe: "The number of steps of Weiszfeld." },
+};
+
+/** The declarations of the options of the highway strategy `stubs` (HWY-015 with WILD-005). */
+export const STUB_SCHEMA: OptionSchema<StubOptions> = {
+  from: HIGHWAY_BASE,
+  omega: { type: "number", min: 10, max: 60, step: 5, default: 30, describe: "The ends of one side of a box whose directions are in a window of this angle share a stub, in degrees." },
+  sigma: { type: "number", min: 0.1, max: 0.4, step: 0.05, default: 0.25, describe: "The length of a stub is this share of the distance to the nearest other end." },
+  ends: { type: "enum", values: ["source", "target", "both"], default: "both", describe: "The ends that get stubs." },
+  minSize: { type: "integer", min: 2, max: 8, step: 1, default: 2, describe: "A stub has this number of edges or more." },
+};
+
+/** The declarations of the options of the highway strategy `zipper` (NAT-022 with WILD-037). */
+export const ZIPPER_SCHEMA: OptionSchema<ZipperOptions> = {
+  from: HIGHWAY_BASE,
+  near: { type: "number", min: 0.5, max: 3, step: 0.25, default: 1, describe: "Two legs zip when they are this distance apart or nearer, in units of the board." },
+  maxAngle: { type: "number", min: 5, max: 30, step: 5, default: 15, describe: "Two legs zip when the angle between them is this value or less, in degrees." },
+  adhesion: { type: "number", min: 0, max: 1, step: 0.1, default: 0.3, describe: "Two legs zip when this value times their overlap is more than the length that the zip adds." },
+  minOverlap: { type: "number", min: 1, max: 5, step: 0.5, default: 1, describe: "Two legs zip when they overlap along this length or more, in units of the board." },
+  passes: { type: "integer", min: 1, max: 5, step: 1, default: 1, describe: "The number of passes. Each pass routes the plan and zips the legs again." },
+};
+
+/** The declarations of the options of the highway strategy `level-links` (HWY-056 with WILD-034). */
+export const LEVEL_HIGHWAY_SCHEMA: OptionSchema<LevelHighwayOptions> = {
+  from: HIGHWAY_BASE,
+  depth: { type: "integer", min: 1, max: 3, step: 1, default: 1, describe: "The depth of the level in the tree of sections." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A level link becomes a highway when this number of edges or more ride it." },
+  stretch: { type: "number", min: 1.2, max: 2, step: 0.1, default: 1.5, describe: "An edge rides the link only when its way along the link is this many times its first route, or shorter." },
+};
+
+/** The declaration of the spine of a group of edges: the shared ways of the group, or one trunk between two terminals. */
+const GROUP_SPINE: EnumOption<GroupSpine> = {
+  type: "enum",
+  values: ["shared", "trunk"],
+  default: "shared",
+  describe: "With `shared`, the edges of a group share their ways through the corner graph. With `trunk`, a group gets one trunk between two terminals.",
+};
+
+/** The declarations of the options of the highway strategy `quickbundles` (HWY-026). */
+export const QUICKBUNDLES_SCHEMA: OptionSchema<QuickBundlesOptions> = {
+  theta: { type: "number", min: 1, max: 10, step: 0.5, marks: [1.5, 3, 6], default: 3, describe: "An edge joins a cluster when its distance to the centroid is this value or less, in units of the board." },
+  points: { type: "integer", min: 6, max: 24, step: 2, default: 12, describe: "The number of points of each line after the resampling." },
+  line: { type: "enum", values: ["routes", "lines"], default: "routes", describe: "The line of each edge: its first route, or the straight line between its plugs." },
+  order: { type: "enum", values: ["input", "length"], default: "input", describe: "The order of the edges in the pass: the order of the graph, or the longest line first." },
+  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,
+};
+
+/** The declarations of the options of the highway strategy `road-classes` (HWY-034 with EDA-050). */
+export const ROAD_CLASS_SCHEMA: OptionSchema<RoadClassOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  quantile: { type: "number", min: 0.5, max: 0.99, step: 0.05, marks: [0.8, 0.9, 0.95], default: 0.9, describe: "A link is a highway link when its use is at this quantile of the use of the links, or higher." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway link and a highway have this number of edges or more." },
+  discount: { type: "number", min: 0.1, max: 0.8, step: 0.1, default: 0.5, describe: "The second pass gives each highway link this discount, as a share of its length." },
+};
+
+/** The declarations of the options of the highway strategy `flow-field` (EDA-046 with HWY-037). */
+export const FLOW_FIELD_SCHEMA: OptionSchema<FlowFieldOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  minFanIn: { type: "integer", min: 2, max: 10, step: 1, default: 2, describe: "An end with this number of edges or more on one side of its box gets a field." },
+  end: { type: "enum", values: ["target", "source"], default: "target", describe: "The end that gets a field: the target of a fan-in, or the source of a fan-out." },
+};
+
+/** The declarations of the options of the highway strategy `wspd` (HWY-018). */
+export const WSPD_SCHEMA: OptionSchema<WspdOptions> = {
+  separation: { type: "number", min: 1, max: 8, step: 0.5, marks: [1, 2, 4], default: 2, describe: "The gap between the two sets of a pair is at least this value times the radius of the larger set." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 3, describe: "A pair with this number of edges or more gets a highway." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `od-cells` (EDA-033 with WILD-032). */
+export const OD_CELL_SCHEMA: OptionSchema<OdCellOptions> = {
+  level: { type: "integer", min: 1, max: 4, step: 1, default: 2, describe: "The depth of the cells in the tree of sections." },
+  minGroup: { type: "integer", min: 2, max: 8, step: 1, default: 3, describe: "A pair of cells with this number of edges or more gets a trunk." },
+  legMax: { type: "number", min: 0.1, max: 1, step: 0.05, marks: [0.2, 0.3, 0.4], default: 0.3, describe: "An edge rides the trunk only when each of its legs is this share of the span or shorter." },
+  spine: { ...GROUP_SPINE, default: "trunk" },
+};
+
+/** The declarations of the options of the highway strategy `select` (HWY-045). */
+export const SELECT_SCHEMA: OptionSchema<SelectOptions> = {
+  generators: { type: "list", default: ["corridors", "quickbundles", "wspd", "road-classes"], describe: "The highway strategies that propose the candidates." },
+  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) {