@mark1russell7/highways 0.4.2 → 0.5.1

package/src/strategies/schemas.ts

@@ -1,17 +1,51 @@
+import type { AreaOptions } from "../highways/areas/index.ts";
+import type { ConfluentOptions, GroupScope } from "../highways/confluent/index.ts";
+import type { CrossbarOptions } from "../highways/crossbars/index.ts";
+import type { FrechetOptions } from "../highways/frechet/index.ts";
+import type { MlsebOptions } from "../highways/mlseb/index.ts";
+import type { PowerOptions } from "../highways/power/index.ts";
+import type { SbebOptions } from "../highways/sbeb/index.ts";
 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 { ConsensusOptions } from "../highways/consensus/index.ts";
+import type { CubuOptions } from "../highways/cubu/index.ts";
+import type { DiffusionOptions } from "../highways/diffusion/index.ts";
+import type { DividedOptions } from "../highways/divided/index.ts";
+import type { EdgePathOptions } from "../highways/edge-paths/index.ts";
+import type { FdebOptions } from "../highways/fdeb/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 { HierarchyOptions } from "../highways/hierarchy/index.ts";
+import type { HoughOptions } from "../highways/hough/index.ts";
+import type { HubArcOptions } from "../highways/hub-arcs/index.ts";
+import type { KdeebOptions } from "../highways/kdeeb/index.ts";
+import type { LanesOptions } from "../highways/lanes/index.ts";
 import type { LevelHighwayOptions } from "../highways/level-links/index.ts";
+import type { LinkCommunityOptions } from "../highways/link-communities/index.ts";
 import type { MeetOptions } from "../highways/meet/index.ts";
+import type { MeshOptions } from "../highways/mesh/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 { PHubOptions } from "../highways/p-hub/index.ts";
 import type { QuickBundlesOptions } from "../highways/quickbundles/index.ts";
+import type { ResistanceOptions } from "../highways/resistance/index.ts";
+import type { RidgeOptions } from "../highways/ridges/index.ts";
 import type { RoadClassOptions } from "../highways/road-classes/index.ts";
+import type { ScaleSpaceOptions } from "../highways/scale-space/index.ts";
 import type { SelectOptions } from "../highways/select/index.ts";
+import type { SoftKeyOptions } from "../highways/soft-keys/index.ts";
+import type { SpectralOptions } from "../highways/spectral/index.ts";
+import type { SpiralOptions } from "../highways/spiral/index.ts";
 import type { StubOptions } from "../highways/stubs/index.ts";
+import type { TerritoryOptions } from "../highways/territories/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";
@@ -23,7 +57,7 @@ import type { SectionOptions } from "../sections.ts";
 import type { WayOptions } from "../ways.ts";
 import type { RunOrder } from "../segments.ts";
 import type { ClothoidStrategyOptions, HighwayStrategyOptions, LevelRoomPreset, RadiusOptions, RoomPreset, RouterPreset, SmoothStrategyOptions, TensionOptions } from "./builtins.ts";
-import type { EnumOption, OptionSchema } from "./options.ts";
+import type { EnumOption, NumberOption, OptionSchema } from "./options.ts";
 
 // The declarations of the options of the built-in strategies. Each `default` is the value that the function uses without the option.
 // The test of the defaults runs each strategy with `optionDefaults` and with no option, and compares the output.
@@ -121,6 +155,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 +455,410 @@ 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." },
+};
+
+/** The declarations of the options of the highway strategy `divided` (HWY-011). */
+export const DIVIDED_SCHEMA: OptionSchema<DividedOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  from: HIGHWAY_BASE,
+  rule: { type: "enum", values: ["right", "left"], default: "right", describe: "The side of the road of the traffic of each direction." },
+  gap: { type: "number", min: 0, max: 4, step: 0.5, marks: [1, 2], default: 1, describe: "The gap between the two carriageways, in lanes." },
+  laneWidth: { type: "number", min: 1, max: 12, step: 1, marks: [4], default: 4, describe: "The width of one lane, in units of the board." },
+  minSize: { type: "integer", min: 1, max: 16, step: 1, default: 2, describe: "A highway divides only when each direction has this number of edges or more." },
+};
+
+/** The declarations of the options of the highway strategy `hierarchy` (HWY-001). */
+export const HIERARCHY_SCHEMA: OptionSchema<HierarchyOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  group: { type: "enum", values: ["quadtree", "kd", "cut"], default: "quadtree", describe: "The tree of sections that gives the hubs." },
+  cap: { type: "integer", min: 1, max: 32, step: 1, marks: [4, 8, 16], default: 8, describe: "A section with more nodes splits." },
+  beta: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.5, 0.85], default: 0.85, describe: "The pull of the hubs. The value 0 gives the straight line, and 1 goes through each hub." },
+  hubs: {
+    type: "integer",
+    min: 0,
+    max: 8,
+    step: 1,
+    special: [Infinity],
+    default: Infinity,
+    describe: "The largest number of hubs on each side of the lowest common section. `Infinity` uses each hub.",
+  },
+  snap: { type: "number", min: 0, max: 32, step: 2, marks: [8, 16], default: 8, describe: "The side of the grid that the hubs snap to, in units of the board." },
+  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 `fdeb` (HWY-002 with RULE-002). */
+export const FDEB_SCHEMA: OptionSchema<FdebOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  compatibility: { type: "number", min: 0.05, max: 1, step: 0.05, marks: [0.4, 0.6, 0.8], default: 0.6, describe: "Two edges attract each other when their compatibility is this value or more." },
+  spring: { type: "number", min: 0, max: 0.5, step: 0.05, default: 0.1, describe: "The spring constant that keeps each edge smooth." },
+  cycles: { type: "integer", min: 0, max: 7, step: 1, default: 5, describe: "The number of cycles. Each cycle doubles the points of each edge." },
+  iterations: { type: "integer", min: 0, max: 200, step: 10, marks: [50], default: 50, describe: "The number of steps of the first cycle." },
+  repulsion: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1], default: 1, describe: "The weight of the push of the boxes. The value 0 turns it off." },
+  pullLimit: {
+    type: "number",
+    min: 1,
+    max: 3,
+    step: 0.05,
+    special: [Infinity],
+    marks: [1.25, 1.5, Infinity],
+    default: 1.25,
+    describe: "An edge longer than this value times its straight line gets no pull. `Infinity` sets no budget.",
+  },
+  snap: { type: "number", min: 0, max: 32, step: 2, marks: [8, 16], default: 8, describe: "The side of the grid that the points of the edges snap to, in units of the board." },
+  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 `mesh` (HWY-004). */
+export const MESH_SCHEMA: OptionSchema<MeshOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  cell: { type: "number", min: 1, max: 16, step: 0.5, marks: [2, 4, 8], default: 4, describe: "The side of a cell of the mesh, in units of the boxes." },
+  capacity: { type: "integer", min: 1, max: 32, step: 1, marks: [4, 8, 16], default: 8, describe: "A cluster of crossings has at most about this number of edges." },
+  merge: { type: "number", min: 0, max: 4, step: 0.25, marks: [1], default: 1, describe: "Two clusters nearer than this value, in units of the boxes, become one." },
+  angle: { type: "number", min: 0, max: 90, step: 5, marks: [30, 45], default: 45, describe: "A line crosses a segment of the mesh only within this angle in degrees to the main direction." },
+  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 `kdeeb` (RULE-028 with HWY-006). */
+export const KDEEB_SCHEMA: OptionSchema<KdeebOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  source: { type: "enum", values: ["lines", "routes"], default: "lines", describe: "The lines of the first 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: [12, 24, 48], default: 24, describe: "The width of the kernel at the first step, in units of the board." },
+  decay: { type: "number", min: 0.3, max: 1, step: 0.05, marks: [0.7], default: 0.7, describe: "Each step multiplies the width of the kernel by this value." },
+  steps: { type: "integer", min: 0, max: 30, step: 1, marks: [10], default: 10, describe: "The number of steps." },
+  smoothing: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.5], default: 0.5, describe: "The share of the smoothing of each polyline after each step." },
+  mask: { type: "boolean", default: true, describe: "With `true`, the density is 0 in the boxes, so no ridge forms over a box." },
+  snap: { type: "number", min: 0, max: 32, step: 2, marks: [8, 16], default: 8, describe: "The side of the grid that the points of the edges snap to, in units of the board." },
+  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 `cubu` (HWY-007). */
+export const CUBU_SCHEMA: OptionSchema<CubuOptions> = {
+  ...KDEEB_SCHEMA,
+  kernel: { type: "enum", values: ["separable", "fft"], default: "separable", describe: "The blur of the counts of the cells: a separable kernel (CUBu) or a Fourier transform (FFTEB)." },
+  resample: { type: "number", min: 0, max: 32, step: 2, marks: [0, 8], default: 8, describe: "The spacing of the sample points after each step, in units of the board. The value 0 keeps the points." },
+};
+
+/** The declarations of the options of the highway strategy `mlseb` (HWY-008). */
+export const MLSEB_SCHEMA: OptionSchema<MlsebOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  source: { type: "enum", values: ["lines", "routes"], default: "lines", describe: "The first lines of the edges: their straight lines, or their first routes." },
+  radius: { type: "number", min: 0.25, max: 8, step: 0.25, marks: [1, 2, 4], default: 2, describe: "The radius of the fit at the first step, as a multiple of the median short side of the boxes." },
+  decay: { type: "number", min: 0.3, max: 1, step: 0.05, marks: [0.8], default: 0.8, describe: "Each step multiplies the radius by this value." },
+  steps: { type: "integer", min: 0, max: 20, step: 1, marks: [6], default: 6, describe: "The number of steps." },
+  fit: { type: "enum", values: ["line", "parabola"], default: "line", describe: "The local fit of the moving least squares: a line, or a parabola along the line." },
+  angleWeight: { type: "number", min: 0, max: 4, step: 0.25, marks: [0, 1], default: 1, describe: "The weight of the angle in the weight of a near point. The value 0 uses only the distance." },
+  spacing: { type: "number", min: 2, max: 32, step: 1, marks: [8, 16], default: 8, describe: "The distance between two sample points of a line, in units of the board." },
+  snap: { type: "number", min: 0, max: 32, step: 2, marks: [8, 16], default: 8, describe: "The side of the grid that the points of the edges snap to, in units of the board." },
+  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 `sbeb` (HWY-009). */
+export const SBEB_SCHEMA: OptionSchema<SbebOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  group: { type: "enum", values: ["quickbundles", "keys"], default: "quickbundles", describe: "The clusterer of the groups: `quickbundles`, or the key of each edge." },
+  source: { type: "enum", values: ["lines", "routes"], default: "lines", describe: "The lines of the edges that make the shape: their straight lines, or their first routes." },
+  radius: { type: "number", min: 0.25, max: 8, step: 0.25, marks: [1, 1.5, 3], default: 1.5, describe: "The radius of the shape of a group, as a multiple of the median short side of the boxes." },
+  attraction: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.5], default: 0.5, describe: "The share of the move of each point to its target at each step." },
+  steps: { type: "integer", min: 0, max: 20, step: 1, marks: [4], default: 4, describe: "The number of steps." },
+  smoothing: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.5], default: 0.5, describe: "The share of the smoothing of each polyline after each step." },
+  target: { type: "enum", values: ["skeleton", "mean"], default: "skeleton", describe: "The target of the points: the skeleton of the shape, or the mean line of the group." },
+  cell: { type: "number", min: 1, max: 16, step: 1, marks: [4, 8], default: 4, describe: "The side of a cell of the image of the shape, in units of the board." },
+  snap: { type: "number", min: 0, max: 32, step: 2, marks: [8, 16], default: 8, describe: "The side of the grid that the points of the edges snap to, in units of the board." },
+  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 `areas` (HWY-010). */
+export const AREA_SCHEMA: OptionSchema<AreaOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  group: SBEB_SCHEMA.group,
+  source: SBEB_SCHEMA.source,
+  radius: SBEB_SCHEMA.radius,
+  width: { type: "enum", values: ["spread", "count"], default: "spread", describe: "The half width of an area: the spread of the edges of the group, or the number of its lanes." },
+  laneWidth: { type: "number", min: 1, max: 12, step: 1, marks: [4], default: 4, describe: "The width of one lane for the rule `count`, in units of the board." },
+  cell: SBEB_SCHEMA.cell,
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A highway has this number of edges or more." },
+};
+
+/** The declaration of the limit of the legs of a trunk for the strategies `confluent` and `power`. */
+const LEG_MAX: NumberOption = {
+  type: "number",
+  min: 0.1,
+  max: 1,
+  step: 0.05,
+  special: [Infinity],
+  marks: [0.3, 1, Infinity],
+  default: 1,
+  describe: "An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit.",
+};
+
+/** The declaration of the edges that one group holds for the strategies `confluent` and `power`. */
+const GROUP_SCOPE: EnumOption<GroupScope> = {
+  type: "enum",
+  values: ["collection", "all"],
+  default: "all",
+  describe: "The edges of one group: the edges of one collection, or each edge.",
+};
+
+/** The declarations of the options of the highway strategy `confluent` (HWY-013). */
+export const CONFLUENT_SCHEMA: OptionSchema<ConfluentOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  minBiclique: { type: "integer", min: 2, max: 32, step: 1, marks: [4, 6, 9], default: 4, describe: "A biclique becomes a track when the product of the sizes of its two sets is this value or more." },
+  scope: GROUP_SCOPE,
+  spine: { ...GROUP_SPINE, default: "trunk" },
+  legMax: LEG_MAX,
+};
+
+/** The declarations of the options of the highway strategy `power` (HWY-014). */
+export const POWER_SCHEMA: OptionSchema<PowerOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  modules: { type: "enum", values: ["exact", "near"], default: "exact", describe: "The rule of a module: the same neighbours, or near neighbours by the Jaccard index." },
+  jaccard: { type: "number", min: 0.3, max: 1, step: 0.05, marks: [0.6, 0.8], default: 0.8, describe: "With the rule `near`, a node joins a module at this Jaccard index or more." },
+  minSaved: { type: "integer", min: 1, max: 16, step: 1, marks: [1, 2, 4], default: 2, describe: "A power edge becomes a highway when it saves this number of edges or more." },
+  scope: GROUP_SCOPE,
+  spine: { ...GROUP_SPINE, default: "trunk" },
+  legMax: LEG_MAX,
+};
+
+/** The declarations of the options of the highway strategy `crossbars` (HWY-022). */
+export const CROSSBAR_SCHEMA: OptionSchema<CrossbarOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  from: HIGHWAY_BASE,
+  tolerance: { type: "number", min: 0, max: 45, step: 1, marks: [5, 15, 30], default: 15, describe: "Two segments are parallel when the angle between them is this value or less, in degrees." },
+  minBar: { type: "integer", min: 1, max: 8, step: 1, marks: [2, 3], default: 2, describe: "Each side of a crossbar has this number of edges or more." },
+  reach: { type: "number", min: 0.5, max: 8, step: 0.5, marks: [2, 3, 4], default: 3, describe: "The crossings of one crossbar are this distance or nearer to its first crossing, as a multiple of the median short side of the boxes." },
+};
+
+/** The declarations of the options of the highway strategy `frechet` (HWY-027). */
+export const FRECHET_SCHEMA: OptionSchema<FrechetOptions> = {
+  margin: WAY_SCHEMA.margin,
+  k: WAY_SCHEMA.k,
+  eps: { type: "number", min: 0.1, max: 4, step: 0.1, marks: [0.5, 1, 2], default: 1, describe: "The largest discrete Fréchet distance in a bundle, as a multiple of the median short side of the boxes." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A bundle has this number of edges or more." },
+  minLength: { type: "number", min: 0.5, max: 16, step: 0.5, marks: [2, 4], default: 2, describe: "The reference part of a bundle is this length or longer, as a multiple of the median short side of the boxes." },
+  step: { type: "number", min: 0.1, max: 2, step: 0.1, marks: [0.5], default: 0.5, describe: "The distance between two samples of a route, as a multiple of the median short side of the boxes." },
+  stride: { type: "integer", min: 1, max: 8, step: 1, marks: [1, 2, 4], default: 2, describe: "A search starts at each sample of this number along each route." },
+};
+
+/** The declarations of the options of the highway strategy `spectral` (HWY-029). */
+export const SPECTRAL_SCHEMA: OptionSchema<SpectralOptions> = {
+  c0: { type: "number", min: 0.05, max: 0.95, step: 0.05, marks: [0.3, 0.5, 0.7], default: 0.5, describe: "Two edges are a pair of the graph only when their compatibility is this value or more." },
+  clusters: { type: "integer", min: 0, max: 32, step: 1, default: 0, describe: "The number of clusters of each part of the graph. The value 0 lets the largest eigengap choose it." },
+  kMax: { type: "integer", min: 2, max: 32, step: 1, marks: [8, 16], default: 16, describe: "The eigengap chooses at most this number of clusters in each part of the graph." },
+  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 `resistance` (HWY-021). */
+export const RESISTANCE_SCHEMA: OptionSchema<ResistanceOptions> = {
+  ...SPECTRAL_SCHEMA,
+  projections: { type: "integer", min: 1, max: 64, step: 1, marks: [8, 16, 32], default: 16, describe: "The number of random projections of the estimate of the resistance." },
+  weight: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.5, 1], default: 0.5, describe: "The weight of the resistance. A pair gets the weight `C (1 - weight R_e R_f)`." },
+  sparsify: { type: "boolean", default: false, describe: "With `true`, an edge with a resistance of 0.99 or more (a bridge) gets no pair." },
+};
+
+/** The declarations of the options of the highway strategy `link-communities` (HWY-030). */
+export const LINK_COMMUNITY_SCHEMA: OptionSchema<LinkCommunityOptions> = {
+  threshold: { type: "number", min: 0, max: 1, step: 0.05, marks: [0, 0.3, 0.5], default: 0, describe: "The cut of the tree of the edges. The value 0 cuts at the best partition density." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A community with this number of edges or more gets highways, after the check of the geometry." },
+  spread: { type: "number", min: 1, max: 20, step: 1, marks: [3, 6, 12], default: 6, describe: "The largest distance of an end of an edge to the Weber point of its end of the community, in units of the board." },
+  spine: GROUP_SPINE,
+};
+
+/** The declarations of the options of the highway strategy `territories` (HWY-033). */
+export const TERRITORY_SCHEMA: OptionSchema<TerritoryOptions> = {
+  radius: { type: "number", min: 1, max: 20, step: 0.5, marks: [2, 4, 8], default: 4, describe: "The radius of a group of points, in units of the board." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A flow between two cells becomes a highway when this number of edges or more cross it." },
+  points: { type: "enum", values: ["plugs", "bends", "both"], default: "both", describe: "The characteristic points: the plugs, the bends of the first routes, or both." },
+};
+
+/** The declarations of the options of the highway strategy `consensus` (HWY-035). */
+export const CONSENSUS_SCHEMA: OptionSchema<ConsensusOptions> = {
+  members: { type: "list", default: ["corridors", "quickbundles", "wspd", "road-classes"], describe: "The finders that vote." },
+  cut: { type: "number", min: 0.1, max: 0.9, step: 0.05, marks: [0.3, 0.5, 0.7], default: 0.5, describe: "Two clusters join while their distance `1 - A` is below this value." },
+  linkage: { type: "enum", values: ["average", "single"], default: "average", describe: "The linkage of the clusters: the mean distance of the pairs, or the nearest pair." },
+  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 `p-hub` (HWY-041). */
+export const P_HUB_SCHEMA: OptionSchema<PHubOptions> = {
+  p: { type: "integer", min: 0, max: 32, step: 1, marks: [0, 4, 8], default: 0, describe: "The number of hubs. The value 0 gives the root of the number of nodes, rounded." },
+  alpha: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.2, 0.5, 0.8], default: 0.5, describe: "The cost of a length on a link between two hubs against a length off the links." },
+  allocation: { type: "enum", values: ["single", "multiple"], default: "single", describe: "The allocation: each node to its nearest hub, or each edge to its best pair of hubs." },
+  candidates: { type: "enum", values: ["corners", "sections"], default: "corners", describe: "The candidate points of the hubs: the corners of the corner graph, or the centres of the sections." },
+  detour: { type: "number", min: 1, max: 3, step: 0.05, marks: [1.25, 1.5], default: 1.25, describe: "An edge rides a link only when its way through the two hubs is this many times its first route or less." },
+  swaps: { type: "integer", min: 0, max: 4, step: 1, default: 1, describe: "The number of passes of the local search with one swap of a hub." },
+  minSize: { type: "integer", min: 2, max: 16, step: 1, default: 2, describe: "A link with fewer edges than this number is not a highway." },
+};
+
+/** The declarations of the options of the highway strategy `scale-space` (HWY-053). */
+export const SCALE_SPACE_SCHEMA: OptionSchema<ScaleSpaceOptions> = {
+  theta: { type: "number", min: 0.5, max: 6, step: 0.5, marks: [1.5, 3], default: 1.5, describe: "The first scale, in units of the board." },
+  ratio: { type: "number", min: 1.1, max: 3, step: 0.1, marks: [1.5, 2], default: Math.SQRT2, describe: "The scale of each next scale is this value times the scale before it." },
+  scales: { type: "integer", min: 2, max: 16, step: 1, marks: [4, 8], default: 8, describe: "The number of scales." },
+  level: { type: "integer", min: 0, max: 15, step: 1, marks: [2, 4, 6], default: 2, describe: "The scale of the plan, from 0 (the first scale)." },
+  p0: { type: "number", min: 0, max: 3, step: 0.1, marks: [0.3, 0.6, 1.2], default: 0.6, describe: "A cluster gets highways only when its persistence (the log of the ratio of its last scale to its first scale) is this value or more." },
+  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." },
+  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,
+};

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) {