@mark1russell7/highways 0.5.0 → 0.5.1

package/src/portfolio/sets.ts

@@ -0,0 +1,28 @@
+// This file is generated by `scripts/portfolio-sets.ts` (`pnpm portfolio:sets`). Do not edit it. The test `sets.test.ts` checks that it is current.
+// The records come from the CI runs 40631516113, 40644555345, 40644557536, 40644560237, 40644562652, 40644565132, 40644567956, 40644570455, 40644572910, 40644575649, 40644578541, 40644580965, 40644583603.
+import type { PortfolioCap, PortfolioRule } from "./bands.ts";
+
+/**
+ * The greedy set of each rule, cap and size band, by the key `<rule>|<cap>|<band>`. The set of k strategies is the first k names.
+ * Each set comes from the train seeds (0 to 4) of its band. The base `shared` is not in a set: the portfolio always runs it first.
+ */
+export const PORTFOLIO_SETS: Readonly<Record<`${PortfolioRule}|${PortfolioCap}|${string}`, readonly string[]>> = {
+  "collection|1.1|n1-12": ["corners-side", "w2c:select+stretch", "trunks-gilbert-a05", "w3a:spiral-a15", "trunks-tree-bf08", "hw:zipper", "w2c:level-links+stretch-b1.1", "hw:stubs"],
+  "collection|1.1|n13-24": ["w3e:crossbars+stretch", "corners-side", "shared-p2", "w2c:zipper+stretch-b1.1", "trunks-tree-bf08", "hw:weiszfeld", "trunks-gilbert-a07", "hw:stubs"],
+  "collection|1.1|n25-40": ["w2a:shared-ways+breakeven", "w2b:weiszfeld-a1", "w2c:level-links+stretch-b1.1"],
+  "collection|1.25|n1-12": ["corners-side", "trunks-tree-bf06", "w3f:p-hub-a0.2", "hw:stubs", "hw:p-hub", "hw:spiral", "w2c:level-links+stretch", "w3f:spectral-c0.3"],
+  "collection|1.25|n13-24": ["w2a:shared-ways+stretch", "shared-p3", "trunks-gilbert-a07", "w3e:crossbars+stretch", "trunks-tree-bf06", "w3c:hdbscan+stretch", "shared-wind-p2-r1-e2", "hw:stubs"],
+  "collection|1.25|n25-40": ["w2a:shared-ways+stretch", "shared-p3", "shared-order-shortest", "w2b:weiszfeld-a1", "w3e:crossbars+stretch", "trunks-tree-bf08", "w2a:shared-ways+ambiguity", "w2b:weiszfeld-a0"],
+  "collection|1.5|n1-12": ["trunks-gilbert-a03", "w3e:areas-keys", "trunks-tree-bf02", "w3f:p-hub-a0.2", "w2b:zipper-a1", "w3a:spiral-a35", "w3f:spectral-c0.3", "w2c:level-links+stretch"],
+  "collection|1.5|n13-24": ["shared-wind-p2-r0.5", "trunks-gilbert-a03", "w3e:crossbars+stretch", "shared-wind-p2-r1-e2", "trunks-tree-bf06", "shared-flow-a06-p3", "shared-wind-p3-r1", "trunks-gilbert-a07"],
+  "collection|1.5|n25-40": ["shared-p3", "hw:lanes", "shared-wind-p2-r1-e2", "hw:crossbars", "shared-flow-a06-p3", "trunks-tree-bf06", "shared-wind-p2-r1", "shared-wind-p2-r2"],
+  "all|1.1|n1-12": ["w2b:zipper-p2", "hw:cubu", "w3d:kdeeb+stretch", "w3c:hough-wide", "w3d:kdeeb-routes", "hw:stubs", "hw:spiral", "w3b:growth-s0.7"],
+  "all|1.1|n13-24": ["w3e:frechet-e0.5", "w3a:diffusion-wide", "w2c:zipper+stretch-b1.1", "w3d:cubu+stretch", "w3a:spiral-a15", "w3d:kdeeb-routes", "hw:diffusion", "hw:mesh"],
+  "all|1.1|n25-40": ["w2c:zipper+stretch-b1.1", "w3a:spiral-a15", "w3d:mesh+stretch", "w3a:diffusion+stretch", "w3a:diffusion-wide", "w2c:road-classes-d0.3", "w3d:kdeeb-routes"],
+  "all|1.25|n1-12": ["w3d:kdeeb-routes", "w3e:mlseb+stretch", "hw:growth", "hw:level-links", "w3b:growth-input", "w3e:confluent+stretch", "w3d:kdeeb-nomask", "w3a:diffusion-g2"],
+  "all|1.25|n13-24": ["w3d:kdeeb-routes", "w3e:mlseb+stretch", "w3f:p-hub-a0.2", "w3a:spiral-n3", "w3a:diffusion-l3", "trunks-tree-bf06", "hw:cubu", "w3a:spiral-a35"],
+  "all|1.25|n25-40": ["w3d:kdeeb-routes", "hw:spiral", "hw:shared-ways-all", "w3a:diffusion-g2", "w3e:frechet+stretch", "hw:cubu"],
+  "all|1.5|n1-12": ["w3b:growth-s0.3", "w3e:mlseb-a0", "w3e:mlseb-routes", "w3c:edge-paths-k1.5", "w3f:territories-r2", "hw:mlseb", "hw:growth", "w3e:mlseb-parabola"],
+  "all|1.5|n13-24": ["hw:growth", "w3b:growth-input", "hw:mlseb", "w3e:mlseb+stretch", "w3b:growth-s0.3"],
+  "all|1.5|n25-40": ["hw:growth", "w3b:growth-s0.7", "w3b:growth-s0.3", "w3b:growth-t1.2", "w3b:growth-input"],
+};

package/src/strategies/builtins.ts

@@ -24,6 +24,26 @@ import { EDGE_PATH_DEFAULTS, edgePathPlan, type EdgePathOptions } from "../highw
 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 { DIVIDED_DEFAULTS, dividedPlan, type DividedOptions } from "../highways/divided/index.ts";
+import { HIERARCHY_DEFAULTS, hierarchyPlan, type HierarchyOptions } from "../highways/hierarchy/index.ts";
+import { FDEB_DEFAULTS, fdebPlan, type FdebOptions } from "../highways/fdeb/index.ts";
+import { MESH_DEFAULTS, meshPlan, type MeshOptions } from "../highways/mesh/index.ts";
+import { KDEEB_DEFAULTS, kdeebPlan, type KdeebOptions } from "../highways/kdeeb/index.ts";
+import { CUBU_DEFAULTS, cubuPlan, type CubuOptions } from "../highways/cubu/index.ts";
+import { MLSEB_DEFAULTS, mlsebPlan, type MlsebOptions } from "../highways/mlseb/index.ts";
+import { SBEB_DEFAULTS, sbebPlan, type SbebOptions } from "../highways/sbeb/index.ts";
+import { AREA_DEFAULTS, areaPlan, type AreaOptions } from "../highways/areas/index.ts";
+import { CONFLUENT_DEFAULTS, confluentPlan, type ConfluentOptions } from "../highways/confluent/index.ts";
+import { POWER_DEFAULTS, powerPlan, type PowerOptions } from "../highways/power/index.ts";
+import { CROSSBAR_DEFAULTS, crossbarPlan, type CrossbarOptions } from "../highways/crossbars/index.ts";
+import { FRECHET_DEFAULTS, frechetPlan, type FrechetOptions } from "../highways/frechet/index.ts";
+import { SPECTRAL_DEFAULTS, spectralPlan, type SpectralOptions } from "../highways/spectral/index.ts";
+import { RESISTANCE_DEFAULTS, resistancePlan, type ResistanceOptions } from "../highways/resistance/index.ts";
+import { LINK_COMMUNITY_DEFAULTS, linkCommunityPlan, type LinkCommunityOptions } from "../highways/link-communities/index.ts";
+import { TERRITORY_DEFAULTS, territoryPlan, type TerritoryOptions } from "../highways/territories/index.ts";
+import { CONSENSUS_DEFAULTS, consensusPlan, type ConsensusOptions } from "../highways/consensus/index.ts";
+import { P_HUB_DEFAULTS, pHubPlan, type PHubOptions } from "../highways/p-hub/index.ts";
+import { SCALE_SPACE_DEFAULTS, scaleSpacePlan, type ScaleSpaceOptions } from "../highways/scale-space/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";
@@ -58,7 +78,8 @@ 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, 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";
+import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
+import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_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">;
@@ -417,6 +438,26 @@ export const highwayStrategies: {
   readonly ridges: Strategy<"highway", RidgeOptions>;
   readonly hdbscan: Strategy<"highway", HdbscanOptions>;
   readonly "hub-arcs": Strategy<"highway", HubArcOptions>;
+  readonly divided: Strategy<"highway", DividedOptions>;
+  readonly hierarchy: Strategy<"highway", HierarchyOptions>;
+  readonly fdeb: Strategy<"highway", FdebOptions>;
+  readonly mesh: Strategy<"highway", MeshOptions>;
+  readonly kdeeb: Strategy<"highway", KdeebOptions>;
+  readonly cubu: Strategy<"highway", CubuOptions>;
+  readonly mlseb: Strategy<"highway", MlsebOptions>;
+  readonly sbeb: Strategy<"highway", SbebOptions>;
+  readonly areas: Strategy<"highway", AreaOptions>;
+  readonly confluent: Strategy<"highway", ConfluentOptions>;
+  readonly power: Strategy<"highway", PowerOptions>;
+  readonly crossbars: Strategy<"highway", CrossbarOptions>;
+  readonly frechet: Strategy<"highway", FrechetOptions>;
+  readonly spectral: Strategy<"highway", SpectralOptions>;
+  readonly resistance: Strategy<"highway", ResistanceOptions>;
+  readonly "link-communities": Strategy<"highway", LinkCommunityOptions>;
+  readonly territories: Strategy<"highway", TerritoryOptions>;
+  readonly consensus: Strategy<"highway", ConsensusOptions>;
+  readonly "p-hub": Strategy<"highway", PHubOptions>;
+  readonly "scale-space": Strategy<"highway", ScaleSpaceOptions>;
   readonly "corridors+breakeven": Strategy<"highway", CorridorOptions & BreakEvenOptions>;
   readonly "corridors+stretch": Strategy<"highway", CorridorOptions & StretchOptions>;
   readonly "corridors+ambiguity": Strategy<"highway", CorridorOptions & AmbiguityGuardOptions>;
@@ -667,6 +708,186 @@ export const highwayStrategies: {
     maxNodes: 10_000,
     run: (input: HighwayInput, o: Readonly<HubArcOptions>) => hubArcPlan(input, o),
   }),
+  divided: defineStrategy({
+    step: "highway",
+    name: "divided",
+    describe: "Divided edge bundling (HWY-011). Each highway of two-way traffic splits into two carriageways at an offset, one for each direction.",
+    defaults: { ...DIVIDED_DEFAULTS } as DividedOptions,
+    schema: DIVIDED_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<DividedOptions>) => dividedPlan(input, o),
+  }),
+  hierarchy: defineStrategy({
+    step: "highway",
+    name: "hierarchy",
+    describe: "Hierarchical edge bundling (HWY-001). Each edge goes near the hubs of the sections between its two leaves, and the shared stretches become highways.",
+    defaults: { ...HIERARCHY_DEFAULTS } as HierarchyOptions,
+    schema: HIERARCHY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<HierarchyOptions>) => hierarchyPlan(input, o),
+  }),
+  fdeb: defineStrategy({
+    step: "highway",
+    name: "fdeb",
+    describe: "Force-directed edge bundling with a field of the boxes (HWY-002 with RULE-002). The bundled points snap back to legal ways.",
+    defaults: { ...FDEB_DEFAULTS } as FdebOptions,
+    schema: FDEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FdebOptions>) => fdebPlan(input, o),
+  }),
+  mesh: defineStrategy({
+    step: "highway",
+    name: "mesh",
+    describe: "A control mesh (HWY-004). The crossings of the edges with the mesh form clusters, and the edges of a cluster share its point.",
+    defaults: { ...MESH_DEFAULTS } as MeshOptions,
+    schema: MESH_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MeshOptions>) => meshPlan(input, o),
+  }),
+  kdeeb: defineStrategy({
+    step: "highway",
+    name: "kdeeb",
+    describe: "Density bundling with a mask of the free space (RULE-028 with HWY-006). The edges move up the density, and the ridges become highways.",
+    defaults: { ...KDEEB_DEFAULTS } as KdeebOptions,
+    schema: KDEEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<KdeebOptions>) => kdeebPlan(input, o),
+  }),
+  cubu: defineStrategy({
+    step: "highway",
+    name: "cubu",
+    describe: "Fast density bundling (HWY-007). The steps of `kdeeb` with a separable blur or a Fourier transform of the counts of the cells.",
+    defaults: { ...CUBU_DEFAULTS } as CubuOptions,
+    schema: CUBU_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<CubuOptions>) => cubuPlan(input, o),
+  }),
+  mlseb: defineStrategy({
+    step: "highway",
+    name: "mlseb",
+    describe: "Moving least squares bundling (HWY-008). Each point of an edge moves to a local fit of the near edges, and the bundled points snap back to legal ways.",
+    defaults: { ...MLSEB_DEFAULTS } as MlsebOptions,
+    schema: MLSEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<MlsebOptions>) => mlsebPlan(input, o),
+  }),
+  sbeb: defineStrategy({
+    step: "highway",
+    name: "sbeb",
+    describe: "Skeleton-based edge bundling (HWY-009). The edges of a group move toward the skeleton of their shape, and the bundled points snap back to legal ways.",
+    defaults: { ...SBEB_DEFAULTS } as SbebOptions,
+    schema: SBEB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SbebOptions>) => sbebPlan(input, o),
+  }),
+  areas: defineStrategy({
+    step: "highway",
+    name: "areas",
+    describe: "Image-based edge bundles (HWY-010). Each group of edges is one shaded area around the longest path of the skeleton of its shape.",
+    defaults: { ...AREA_DEFAULTS } as AreaOptions,
+    schema: AREA_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<AreaOptions>) => areaPlan(input, o),
+  }),
+  confluent: defineStrategy({
+    step: "highway",
+    name: "confluent",
+    describe: "Confluent drawings (HWY-013). Each biclique of a greedy search is one track, with a merge junction and a split junction.",
+    defaults: { ...CONFLUENT_DEFAULTS } as ConfluentOptions,
+    schema: CONFLUENT_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ConfluentOptions>) => confluentPlan(input, o),
+  }),
+  power: defineStrategy({
+    step: "highway",
+    name: "power",
+    describe: "Edge compression with modules and power graphs (HWY-014). The edges between two modules are one power edge, and a large power edge is a highway.",
+    defaults: { ...POWER_DEFAULTS } as PowerOptions,
+    schema: POWER_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<PowerOptions>) => powerPlan(input, o),
+  }),
+  crossbars: defineStrategy({
+    step: "highway",
+    name: "crossbars",
+    describe: "Bundled crossings (HWY-022). Two sets of edges that cross near one place cross as two bundles, at one place.",
+    defaults: { ...CROSSBAR_DEFAULTS } as CrossbarOptions,
+    schema: CROSSBAR_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<CrossbarOptions>) => crossbarPlan(input, o),
+  }),
+  frechet: defineStrategy({
+    step: "highway",
+    name: "frechet",
+    describe: "Subtrajectory clusters by the discrete Fréchet distance (HWY-027). The parts of the first routes that stay near one reference part become highways.",
+    defaults: { ...FRECHET_DEFAULTS } as FrechetOptions,
+    schema: FRECHET_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<FrechetOptions>) => frechetPlan(input, o),
+  }),
+  spectral: defineStrategy({
+    step: "highway",
+    name: "spectral",
+    describe: "Spectral clustering of the compatibility graph of the edges (HWY-029). The largest eigengap gives the number of clusters, and each cluster gets highways.",
+    defaults: { ...SPECTRAL_DEFAULTS } as SpectralOptions,
+    schema: SPECTRAL_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<SpectralOptions>) => spectralPlan(input, o),
+  }),
+  resistance: defineStrategy({
+    step: "highway",
+    name: "resistance",
+    describe: "Spectral bundling with the effective resistance (HWY-021). A pair of two bridges of the graph gets a lower weight, then the clusters of `spectral` apply.",
+    defaults: { ...RESISTANCE_DEFAULTS } as ResistanceOptions,
+    schema: RESISTANCE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ResistanceOptions>) => resistancePlan(input, o),
+  }),
+  "link-communities": defineStrategy({
+    step: "highway",
+    name: "link-communities",
+    describe: "Link communities on the line graph (HWY-030). The edges with a common node and similar neighbours form communities, and each community gets highways.",
+    defaults: { ...LINK_COMMUNITY_DEFAULTS } as LinkCommunityOptions,
+    schema: LINK_COMMUNITY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<LinkCommunityOptions>) => linkCommunityPlan(input, o),
+  }),
+  territories: defineStrategy({
+    step: "highway",
+    name: "territories",
+    describe: "Territory aggregation of flows (HWY-033). The plugs and bends form cells, and the strong flows between two neighbour cells become highways.",
+    defaults: { ...TERRITORY_DEFAULTS } as TerritoryOptions,
+    schema: TERRITORY_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<TerritoryOptions>) => territoryPlan(input, o),
+  }),
+  consensus: defineStrategy({
+    step: "highway",
+    name: "consensus",
+    describe: "A consensus of clusterings (HWY-035). The finders vote on the pairs of edges, and the pairs that most finders agree on form the highways.",
+    defaults: { ...CONSENSUS_DEFAULTS } as ConsensusOptions,
+    schema: CONSENSUS_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ConsensusOptions>) => consensusPlan(input, o),
+  }),
+  "p-hub": defineStrategy({
+    step: "highway",
+    name: "p-hub",
+    describe: "Hub location with the p-hub median (HWY-041). The p-median of the plugs gives the hubs, and the links between two hubs become highways.",
+    defaults: { ...P_HUB_DEFAULTS } as PHubOptions,
+    schema: P_HUB_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<PHubOptions>) => pHubPlan(input, o),
+  }),
+  "scale-space": defineStrategy({
+    step: "highway",
+    name: "scale-space",
+    describe: "A scale space with persistence (HWY-053). The clusters of edges that live over a long range of scales get highways at the scale of the plan.",
+    defaults: { ...SCALE_SPACE_DEFAULTS } as ScaleSpaceOptions,
+    schema: SCALE_SPACE_SCHEMA,
+    maxNodes: 10_000,
+    run: (input: HighwayInput, o: Readonly<ScaleSpaceOptions>) => scaleSpacePlan(input, o),
+  }),
   "corridors+breakeven": gateStrategy(corridors, breakEvenGate),
   "corridors+stretch": gateStrategy(corridors, stretchGate),
   "corridors+ambiguity": gateStrategy(corridors, ambiguityGate),

package/src/strategies/schemas.ts

@@ -1,30 +1,50 @@
+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";
@@ -37,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.
@@ -583,3 +603,262 @@ export const HUB_ARC_SCHEMA: OptionSchema<HubArcOptions> = {
   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,
+};