@mark1russell7/highways 0.4.1 → 0.5.0

package/src/bench/measures/levels.ts

@@ -1,5 +1,5 @@
-import { center, dist } from "../../geom.ts";
-import type { Graph, Level } from "../../model.ts";
+import { center, dist, pointBoxDistance, polylineLength, type Box, type Point } from "../../geom.ts";
+import type { Graph, Level, Route } from "../../model.ts";
 import { kendallTau } from "./stats.ts";
 
 /** This function gives the levels in the order of their depth, from the far view to the near view. */
@@ -101,3 +101,87 @@ export function orderStability(graph: Graph, levels: readonly Level[]): number {
   }
   return n ? sum / n : 1;
 }
+
+/** This function gives the points of a polyline at most `step` apart: each vertex, and evenly spaced points on each longer segment. */
+function samplePolyline(p: readonly Point[], step: number): Point[] {
+  const out: Point[] = [];
+  for (let i = 0; i < p.length; i++) {
+    const b = p[i]!;
+    if (i > 0) {
+      const a = p[i - 1]!;
+      const n = Math.ceil(dist(a, b) / step);
+      for (let k = 1; k < n; k++) out.push({ x: a.x + ((b.x - a.x) * k) / n, y: a.y + ((b.y - a.y) * k) / n });
+    }
+    out.push(b);
+  }
+  return out;
+}
+
+/** This function gives the Hausdorff distance between two sets of points. Both sets have one point or more. */
+function hausdorff(a: readonly Point[], b: readonly Point[]): number {
+  const directed = (p: readonly Point[], q: readonly Point[]): number => {
+    let worst = 0;
+    for (const x of p) {
+      let best = Number.POSITIVE_INFINITY;
+      for (const y of q) best = Math.min(best, dist(x, y));
+      worst = Math.max(worst, best);
+    }
+    return worst;
+  };
+  return Math.max(directed(a, b), directed(b, a));
+}
+
+/** The number of points of the sample of one polyline for the link agreement, at most. */
+const AGREEMENT_SAMPLES = 64;
+
+/**
+ * This function gives the link agreement of the levels with groups (Z9 of MEAS0).
+ * `la = mean over links of hausdorff(link, routes of its edges outside the two items) / u`, with `u` the argument `unit`.
+ * The edges of a link are the edges between a node of one item and a node of the other item, in either direction.
+ *
+ * The function samples each polyline at points `u / 4` apart, with at most 64 points for each polyline. It keeps the points outside the boxes of the two items.
+ * A link without such points on both sides does not count. It gives `undefined` when no link counts.
+ * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
+ */
+export function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined {
+  const u = unit > 0 ? unit : 1;
+  const endsOf = new Map(graph.edges.map((e) => [e.id, [e.source.node, e.target.node] as const]));
+  const sample = (p: readonly Point[], boxes: readonly Box[]): Point[] => {
+    const step = Math.max(u / 4, polylineLength(p) / AGREEMENT_SAMPLES);
+    return samplePolyline(p, step).filter((q) => boxes.every((b) => pointBoxDistance(q, b) > 0));
+  };
+  let sum = 0;
+  let n = 0;
+  for (const level of levels) {
+    if (!level.items.some((i) => i.nodes.length > 1)) continue;
+    const itemOf = itemIndex(level);
+    const indexOf = new Map(level.items.map((it, i) => [it.id, i] as const));
+    // The edges between each pair of items, by the key of the pair.
+    const between = new Map<string, Route[]>();
+    for (const r of routes) {
+      const ends = endsOf.get(r.edge);
+      if (!ends) continue;
+      const i = itemOf.get(ends[0]);
+      const j = itemOf.get(ends[1]);
+      if (i === undefined || j === undefined || i === j) continue;
+      const key = i < j ? `${i},${j}` : `${j},${i}`;
+      const list = between.get(key);
+      if (list) list.push(r);
+      else between.set(key, [r]);
+    }
+    for (const link of level.links) {
+      const i = indexOf.get(link.source);
+      const j = indexOf.get(link.target);
+      if (i === undefined || j === undefined || i === j) continue;
+      const mine = between.get(i < j ? `${i},${j}` : `${j},${i}`);
+      if (!mine) continue;
+      const boxes = [level.items[i]!.box, level.items[j]!.box];
+      const a = sample(link.points, boxes);
+      const b = mine.flatMap((r) => sample(r.points, boxes));
+      if (a.length === 0 || b.length === 0) continue;
+      sum += hausdorff(a, b) / u;
+      n++;
+    }
+  }
+  return n > 0 ? sum / n : undefined;
+}

package/src/bench/screen/forms.ts

@@ -47,8 +47,8 @@ export interface LayoutBox {
   readonly parent?: string;
   /** The group of the box. */
   readonly group?: string;
-  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
-  readonly locked?: true;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. `false` is the same as no value. The router ignores it. */
+  readonly locked?: boolean;
   /** The reading order that the caller wants. The router ignores it. */
   readonly rank?: number;
   readonly ports?: readonly LayoutPort[];
@@ -87,7 +87,7 @@ export interface LayoutGenerator {
  * The packer reads the first six dimensions. The router reads the last four.
  */
 export interface LayoutCell {
-  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
   readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
   readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
   readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
@@ -291,19 +291,25 @@ export function regionBounds(region: Region): { x: number; y: number; w: number;
   return { x, y, w: Math.max(...xs) - x, h: Math.max(...ys) - y };
 }
 
+/**
+ * The fields of an input that `inputGraph` reads. A contract input, for example the result of `applyPack`, has these fields.
+ * Without `edges`, the input has no edges.
+ */
+export type RouteInput = Pick<LayoutInput, "id" | "boxes" | "obstacles"> & { readonly edges?: LayoutInput["edges"] };
+
 /**
  * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
  * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
  * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
  * A box without `x` and `y` is an error.
  */
-export function inputGraph(input: LayoutInput): Graph {
+export function inputGraph(input: RouteInput): Graph {
   const nodes = input.boxes.map((b): Node => {
     if (b.x === undefined || b.y === undefined) throw new Error(`The box "${b.id}" of the input "${input.id}" has no position. The router needs a placed input.`);
     return { id: b.id, box: { x: b.x, y: b.y, w: b.w, h: b.h }, ...(b.ports ? { ports: b.ports.map(portToModel) } : {}), ...(b.data ? { data: b.data } : {}) };
   });
   for (const o of input.obstacles ?? []) nodes.push({ id: o.id, box: regionBounds(o.region) });
-  const edges = input.edges.map(
+  const edges = (input.edges ?? []).map(
     (e): Edge => ({
       id: e.id,
       source: { node: e.source, ...(e.sourcePort !== undefined ? { port: e.sourcePort } : {}) },

package/src/bench/screen/measures.ts

@@ -45,6 +45,9 @@ const ROWS: readonly Row[] = [
   ["R11.q05", "R11", "route.plug-spacing.q05", "0 to 1", "higher", true],
   ["R13.outside", "R13", "route.outside", "count", "lower", false],
   ["R15.inflections", "R15", "route.inflections", "count for each route", "lower", false],
+  // MEAS3A, for the steps `router` and `highway`. R12 is the share of the ink near a parallel leg of other edges. A narrow channel between boxes moves it.
+  ["R12.share", "R12", "route.lane.separation", "0 to 1", "lower", true],
+  ["R14.share", "R14", "route.orthogonality", "0 to 1", "higher", false],
   ["ink", "R1", "route.ink", "units", "lower", true],
   // The bundles.
   ["B1.inkSaved", "B1", "route.bundle.ink-saved", "0 to 1", "higher", false],
@@ -54,6 +57,18 @@ const ROWS: readonly Row[] = [
   ["B3.median", "B3", "route.bundle.stretch.median", "ratio", "lower", false],
   ["B3.q95", "B3", "route.bundle.stretch.q95", "ratio", "lower", false],
   ["B6.max", "B6", "route.bundle.merge-angle.max", "degrees", "lower", false],
+  // MEAS3A, for the steps `router` and `highway`. B5, B8 and B9 read the runs and the trunks of the result. B8 is good or bad only in context, as B2.
+  ["B5.crossings", "B5", "route.bundle.lane-crossings", "count", "lower", false],
+  ["B7.ratio", "B7", "route.bundle.occupied-area", "ratio", "lower", false],
+  ["B8.runs", "B8", "route.bundle.runs", "count", "lower", false],
+  ["B8.median", "B8", "route.bundle.run-edges.median", "count", "higher", false],
+  ["B8.max", "B8", "route.bundle.run-edges.max", "count", "higher", false],
+  ["B9.median", "B9", "route.bundle.lane-fidelity.median", "ratio", "lower", false],
+  ["B9.max", "B9", "route.bundle.lane-fidelity.max", "ratio", "lower", false],
+  // M1 and M4 of the room, for the steps `router` and `highway`: the lanes of each shared segment open at `MEASURE_LANE_WIDTH`.
+  // The step `room` of `runSuite` gives the same keys for the boards that a room strategy opens.
+  ["M1.area", "M1", "route.lane.area", "ratio", "lower", false],
+  ["M4.laneThrough", "M4", "route.lane.through", "count", "lower", true],
   // The order fragility (W3 of MEAS3, from WILD-056): the spread of a measure over random orders of the edges. The placement can move it.
   ["W3.crossings", "W3", "route.order.crossings", "IQR over the median", "lower", true],
   ["W3.detour", "W3", "route.order.detour", "IQR over the median", "lower", true],
@@ -68,8 +83,16 @@ const ROWS: readonly Row[] = [
   ["Z10.base.mean", "Z10", "route.stability.base.mean", "units of the board", "lower", false],
   ["Z10.base.max", "Z10", "route.stability.base.max", "units of the board", "lower", false],
   ["Z10.base.moved", "Z10", "route.stability.base.moved", "0 to 1", "lower", false],
+  // The stability of a highway strategy over a sequence of seeded edits, with its plan before each edit (the screen option `edits`).
+  ["Z10.edits.mean", "Z10", "route.stability.edits.mean", "units of the board", "lower", false],
+  ["Z10.edits.moved", "Z10", "route.stability.edits.moved", "0 to 1", "lower", false],
+  ["Z10.churn", "Z10", "route.stability.highway-churn", "0 to 1", "lower", false],
+  ["Z10.ids", "Z10", "route.stability.highway-ids", "0 to 1", "higher", false],
   // The zoom levels and the groups. The default grouping rule reads the positions, so most of these measures depend on the placement.
   ["level-nesting", "Z6", "route.level.nesting", "count", "lower", false],
+  // MEAS3A, for the steps `router`, `highway` and `group`. Z2 is the count of the hard rule `link-ends`. Z9 needs a result with zoom levels.
+  ["Z2.linkEnds", "Z2", "route.level.link-ends", "count", "lower", false],
+  ["Z9.mean", "Z9", "route.level.link-agreement", "no unit", "lower", true],
   ["Z3.through", "Z3", "route.level.through", "count", "lower", true],
   ["Z3.length", "Z3", "route.level.link-length", "units", "lower", true],
   ["Z4.farItems", "Z4", "route.level.far-items", "count", "lower", true],

package/src/bench/screen/screen.ts

@@ -6,8 +6,12 @@ import { STRATEGIES } from "../../strategies/builtins.ts";
 import { asRouter, createRegistry, getStrategy, listStrategies, register, STEPS, type AnyStrategy, type Registry, type Strategy } from "../../strategies/model.ts";
 import { compareStep, type CompareRow, type CompareStep, type StepComparison } from "../compare.ts";
 import { bundledShare, bundleStretch, mergeAngle } from "../measures/bundles.ts";
+import { highwayEdits } from "../measures/highways.ts";
+import { laneArea, laneCrossings, laneFidelity, lanesThrough, occupiedArea, openLanes, orthogonality, routeSeparation, runProfile } from "../measures/lanes.ts";
+import { linkAgreement } from "../measures/levels.ts";
 import { orderFragility } from "../measures/order.ts";
 import { paretoFront, type Objective } from "../measures/pareto.ts";
+import { boardUnit } from "../measures/routes.ts";
 import { routeStability } from "../measures/stability.ts";
 import { quantile } from "../measures/stats.ts";
 import { checkLevels, checkProperties, TOLERANCE } from "../properties.ts";
@@ -84,6 +88,12 @@ export interface ScreenOptions {
    * The default is 0: no measure of the order fragility. The steps `group` and `curve` do not read it.
    */
   readonly shuffles?: number;
+  /**
+   * The number of seeded edits of the step `highway` (BUILD-W2A). Each highway strategy runs again after each edit of `highwayEdits`, with its plan before the edit.
+   * The records then get `Z10.edits.*`, the churn of the highways and the share of the highways that keep their id.
+   * The default is 0: no edits. The other steps and the base routers do not read it.
+   */
+  readonly edits?: number;
   /** The commit of the code, for the records. */
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
@@ -201,6 +211,8 @@ const givesRoutes = (step: ScreenStep): step is "router" | "highway" => step ===
 /**
  * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
  * A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
+ * It also gets the measures of MEAS3A: R12, R14, B5, B7, B8, B9, M1 and M4. The lane measures open each shared segment at `MEASURE_LANE_WIDTH`.
+ * A result with zoom levels also gets the link agreement (Z9), for a router and for a grouping rule.
  */
 function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () => readonly Route[]): Record<string, number> {
   const values: Record<string, number> = { ...row.values };
@@ -217,6 +229,27 @@ function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () =>
     values["B3.median"] = st.median;
     values["B3.q95"] = st.q95;
     values["B6.max"] = mergeAngle(row.result.routes);
+    const routes = row.result.routes;
+    const open = openLanes(row.result);
+    values["R12.share"] = routeSeparation(routes);
+    values["R14.share"] = orthogonality(routes);
+    values["B5.crossings"] = laneCrossings(open.graph);
+    values["B7.ratio"] = occupiedArea(routes, boardUnit(graph));
+    const runs = runProfile(open.graph);
+    values["B8.runs"] = runs.runs;
+    values["B8.median"] = runs.median;
+    values["B8.max"] = runs.max;
+    const lf = laneFidelity(routes, open);
+    if (lf) {
+      values["B9.median"] = lf.median;
+      values["B9.max"] = lf.max;
+    }
+    values["M1.area"] = laneArea(graph, open);
+    values["M4.laneThrough"] = lanesThrough(graph, open);
+  }
+  if ((givesRoutes(step) || step === "group") && row.result?.levels) {
+    const la = linkAgreement(graph, row.result.levels, row.result.routes, boardUnit(graph));
+    if (la !== undefined) values["Z9.mean"] = la;
   }
   return values;
 }
@@ -295,6 +328,8 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
   }
   const shuffles = givesRoutes(step) ? Math.max(0, Math.floor(options.shuffles ?? 0)) : 0;
   const seed = options.seed ?? 1;
+  const edits = step === "highway" ? Math.max(0, Math.floor(options.edits ?? 0)) : 0;
+  const plans = new Map(listStrategies(screened.registry, "highway").map((s) => [s.name, s]));
   const log = options.log ?? ((): void => {});
   const families = options.families;
   const inputs = (options.inputs ?? screenInputs(set)).filter((i) => families?.includes(i.family) ?? true);
@@ -341,11 +376,18 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
       }
       const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
       const values = rowValues(step, graph, row, cornersBase);
+      // Z2 is the count of the hard rule `link-ends`, as a measure. The steps `router`, `highway` and `group` check the rule.
+      if (hard["link-ends"] !== undefined) values["Z2.linkEnds"] = hard["link-ends"];
       if (shuffles > 0 && row.result) {
         const router = asRouter(strategy as Strategy<"router">, own[row.strategy]);
         const f = orderFragility(graph, (g) => router.route(g), { orders: shuffles, seed, base: row.result });
         Object.assign(values, { "W3.crossings": f.crossings, "W3.detour": f.detour, "W3.inkSaved": f.inkSaved, "W3.ink": f.ink, "W3.changed": f.changed, "W3.poa": f.poa });
       }
+      const plan = edits > 0 && row.result ? plans.get(row.strategy) : undefined;
+      if (plan) {
+        const z = highwayEdits(graph, plan, own[row.strategy], edits, seed);
+        Object.assign(values, { "Z10.edits.mean": z.mean, "Z10.edits.moved": z.moved, "Z10.churn": z.churn, "Z10.ids": z.ids });
+      }
       const record = { ...head, measures: named(values), hard, tolerance: { through: TOLERANCE }, deterministic, ms: row.ms, ...tail };
       records.push(record);
       if (givesRoutes(step) && input.base !== undefined && row.result) variants.push({ record, base: input.base, result: row.result });

package/src/channels.ts

@@ -0,0 +1,56 @@
+import { dist, type Box, type Point } from "./geom.ts";
+import type { Obstacles } from "./visibility.ts";
+
+/** The largest distance that `channelWidth` looks on each side of a link. A wider channel counts as this width on that side. */
+export const CHANNEL_REACH = 64;
+
+/**
+ * This function gives the distance from `p` along the unit direction `d` to the box, or `Infinity` when the ray does not meet the box.
+ * A point inside the box gives 0. The function uses the slab test.
+ */
+export function rayToBox(p: Point, d: Point, box: Box): number {
+  let lo = 0;
+  let hi = Infinity;
+  for (const [o, v, min, max] of [
+    [p.x, d.x, box.x, box.x + box.w],
+    [p.y, d.y, box.y, box.y + box.h],
+  ] as const) {
+    if (Math.abs(v) < 1e-12) {
+      if (o < min || o > max) return Infinity;
+      continue;
+    }
+    const t1 = (min - o) / v;
+    const t2 = (max - o) / v;
+    lo = Math.max(lo, Math.min(t1, t2));
+    hi = Math.min(hi, Math.max(t1, t2));
+    if (lo > hi) return Infinity;
+  }
+  return lo;
+}
+
+/** This function gives the free distance from `p` along the unit direction `d` to the nearest box, up to `reach`. */
+function freeRay(obstacles: Obstacles, p: Point, d: Point, reach: number): number {
+  const q = { x: p.x + d.x * reach, y: p.y + d.y * reach };
+  let best = reach;
+  obstacles.query({ x: Math.min(p.x, q.x), y: Math.min(p.y, q.y), w: Math.abs(q.x - p.x), h: Math.abs(q.y - p.y) }, (n) => {
+    best = Math.min(best, rayToBox(p, d, n.box));
+  });
+  return best;
+}
+
+/**
+ * This function gives the width of the channel of the link from `a` to `b`. The width is the free space between the nearest boxes on the two sides.
+ * It measures the width at five points of the link, and gives the smallest. Each side counts up to `reach`.
+ * A link of length 0 gives the free space across the x axis at its point.
+ */
+export function channelWidth(obstacles: Obstacles, a: Point, b: Point, reach: number = CHANNEL_REACH): number {
+  const len = dist(a, b);
+  const n = len > 1e-9 ? { x: -(b.y - a.y) / len, y: (b.x - a.x) / len } : { x: 0, y: 1 };
+  const back = { x: -n.x, y: -n.y };
+  let width = Infinity;
+  for (const u of [0.1, 0.3, 0.5, 0.7, 0.9]) {
+    const p = { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u };
+    width = Math.min(width, freeRay(obstacles, p, n, reach) + freeRay(obstacles, p, back, reach));
+  }
+  return width;
+}

package/src/highways/base.ts

@@ -0,0 +1,126 @@
+import { dist, type Point } from "../geom.ts";
+import type { Graph, Result, Route } from "../model.ts";
+import { byCollection } from "../routers/trunks.ts";
+import { CORRIDOR_DEFAULTS, corridorPlan } from "./corridors/index.ts";
+import { follow } from "./follow.ts";
+import type { Highway, HighwayInput, HighwayMember, HighwayPlan } from "./model.ts";
+import { sharedWaysPlan } from "./shared-ways/index.ts";
+
+/**
+ * The plan that a post step changes. `none` is the empty plan: `follow` then routes each edge as the router `corners` does.
+ * `shared-ways` and `corridors` are the plans of those highway strategies, with their defaults.
+ */
+export type HighwayBase = "none" | "shared-ways" | "corridors";
+
+/** The values of `HighwayBase`. */
+export const HIGHWAY_BASES: readonly HighwayBase[] = Object.freeze(["none", "shared-ways", "corridors"]);
+
+/** This function gives the plan of a base. */
+export function basePlan(input: HighwayInput, base: HighwayBase): HighwayPlan {
+  if (base === "shared-ways") return sharedWaysPlan(input, { rule: byCollection });
+  if (base === "corridors") return corridorPlan(input, CORRIDOR_DEFAULTS);
+  return { highways: [] };
+}
+
+/** This function gives the routes of a plan after `follow`, with the default way finder. The plan `none` gives the first routes of the edges. */
+export function planRoutes(graph: Graph, plan: HighwayPlan): Result {
+  return follow(graph, plan);
+}
+
+/** This function gives the first route of each edge: the route of `input.routes`, or the route of the empty plan after `follow`. */
+export function firstRoutes(input: HighwayInput): Map<string, readonly Point[]> {
+  const given = routeIndex(input.routes?.routes ?? []);
+  const known = new Set(input.graph.edges.map((e) => e.id));
+  if (input.graph.edges.every((e) => given.has(e.id))) return given;
+  const made = routeIndex(planRoutes(input.graph, { highways: [] }).routes);
+  for (const [edge, points] of given) if (known.has(edge)) made.set(edge, points);
+  return made;
+}
+
+/** One stop of the trip of an edge: the index of the highway in the plan, and the member. */
+export interface TripStop {
+  readonly h: number;
+  readonly m: HighwayMember;
+}
+
+/** This function gives the trip of each edge of a plan. The trip is its highways in the order of `seq`, then in the order of the plan. */
+export function tripsOf(plan: HighwayPlan): Map<string, TripStop[]> {
+  const trips = new Map<string, TripStop[]>();
+  plan.highways.forEach((h, hi) => {
+    for (const m of h.members) {
+      const list = trips.get(m.edge);
+      if (list) list.push({ h: hi, m });
+      else trips.set(m.edge, [{ h: hi, m }]);
+    }
+  });
+  for (const list of trips.values()) list.sort((a, b) => a.m.seq - b.m.seq || a.h - b.h);
+  return trips;
+}
+
+/**
+ * This function gives a plan with the same trips, and with `seq` from 0 to the number of highways of the edge less 1.
+ * A post step can give `seq` values with gaps or below 0, and this function makes them whole again.
+ * It also drops each highway with fewer than two members, and gives the highways new ids in order.
+ */
+export function tidyPlan(plan: HighwayPlan): HighwayPlan {
+  const kept = plan.highways.filter((h) => h.members.length >= 2);
+  const seq = new Map<string, number>();
+  for (const list of tripsOf({ highways: kept }).values()) list.forEach((stop, i) => seq.set(`${stop.h}\u0000${stop.m.edge}`, i));
+  const highways: Highway[] = kept.map((h, hi) => ({
+    ...h,
+    id: `h${hi}`,
+    lanes: h.lanes.filter((e) => h.members.some((m) => m.edge === e)),
+    members: h.members.map((m) => ({ ...m, seq: seq.get(`${hi}\u0000${m.edge}`) ?? 0 })),
+  }));
+  return { highways };
+}
+
+/** This function gives the place along a polyline (as a length from its first point) of the point of the polyline nearest to `p`. */
+export function arcPlace(line: readonly Point[], p: Point): number {
+  let best = Infinity;
+  let at = 0;
+  let walked = 0;
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const len = dist(a, b);
+    const u = len > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / (len * len))) : 0;
+    const d = dist(p, { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+    if (d < best) [best, at] = [d, walked + u * len];
+    walked += len;
+  }
+  return at;
+}
+
+/** This function gives the place on a spine (the index of a point plus the share of the next leg) of the point of the spine nearest to `p`. */
+export function nearestPlace(spine: readonly Point[], p: Point): number {
+  let best = Infinity;
+  let at = 0;
+  for (let i = 1; i < spine.length; i++) {
+    const a = spine[i - 1]!;
+    const b = spine[i]!;
+    const len2 = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
+    const u = len2 > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / len2)) : 0;
+    const d = dist(p, { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+    if (d < best) [best, at] = [d, i - 1 + u];
+  }
+  return at;
+}
+
+/**
+ * This function gives a plan where the `seq` of each member follows the place of its merge point along the route of its edge.
+ * A post step that adds highways to the trips of edges uses it. Equal places keep the order of `seq`.
+ */
+export function orderAlongRoutes(plan: HighwayPlan, routes: ReadonlyMap<string, readonly Point[]>): HighwayPlan {
+  const rank = new Map<string, number>();
+  for (const [edge, list] of tripsOf(plan)) {
+    const route = routes.get(edge);
+    const placed = list.map((stop, i) => ({ stop, i, at: route ? arcPlace(route, stop.m.merge) : i }));
+    placed.sort((a, b) => a.at - b.at || a.i - b.i);
+    placed.forEach((p, k) => rank.set(`${p.stop.h}\u0000${edge}`, k));
+  }
+  return { highways: plan.highways.map((h, hi) => ({ ...h, members: h.members.map((m) => ({ ...m, seq: rank.get(`${hi}\u0000${m.edge}`) ?? m.seq })) })) };
+}
+
+/** This function gives the route of each edge by its id. */
+export const routeIndex = (routes: readonly Route[]): Map<string, readonly Point[]> => new Map(routes.map((r) => [r.edge, r.points]));

package/src/highways/diffusion/index.ts

@@ -0,0 +1,103 @@
+import type { Point } from "../../geom.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+
+/** The options of the highway strategy `diffusion` (HWY-020 of the note on highways). */
+export interface DiffusionOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The share of the density that each step of the diffusion takes from the links next to a link. The default is 0.25. */
+  readonly a: number;
+  /** The number of steps of the diffusion. The default is 3. */
+  readonly steps: number;
+  /** The weight of the density in the cost of a link. The default is 1. */
+  readonly lambda: number;
+  /** The power of the discount of a dense link. The default is 1. */
+  readonly gamma: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `diffusion`. */
+export const DIFFUSION_DEFAULTS: Readonly<Required<Omit<DiffusionOptions, "margin" | "k">>> = Object.freeze({ a: 0.25, steps: 3, lambda: 1, gamma: 1, minSize: 2 });
+
+/**
+ * This function gives the density of the edges on the links of the corner graph after the diffusion, as a share of the largest density.
+ * The density of a link starts as the number of first ways on it. Each step mixes it with the mean density of the links that share a corner with it:
+ * `rho_{k+1}(l) = (1 - a) rho_k(l) + a mean(rho_k(l'))`. The key of a link is `i * M + j` for the corners `i < j` of a graph of `M` corners.
+ */
+export function linkDensity(neighbours: (i: number) => readonly number[], corners: number, use: ReadonlyMap<number, number>, a: number, steps: number): Map<number, number> {
+  const M = corners;
+  const links: number[] = [];
+  for (let i = 0; i < M; i++) for (const j of neighbours(i)) if (j > i) links.push(i * M + j);
+  let rho = new Map<number, number>(links.map((l) => [l, use.get(l) ?? 0]));
+  const share = Math.max(0, Math.min(1, a));
+  for (let s = 0; s < Math.round(steps); s++) {
+    // The sum of the densities and the number of the links at each corner.
+    const sum = new Float64Array(M);
+    const deg = new Int32Array(M);
+    for (const [l, v] of rho) {
+      const i = Math.floor(l / M);
+      const j = l % M;
+      sum[i] = sum[i]! + v;
+      sum[j] = sum[j]! + v;
+      deg[i] = deg[i]! + 1;
+      deg[j] = deg[j]! + 1;
+    }
+    const next = new Map<number, number>();
+    for (const [l, v] of rho) {
+      const i = Math.floor(l / M);
+      const j = l % M;
+      const n = deg[i]! + deg[j]! - 2;
+      const mean = n > 0 ? (sum[i]! + sum[j]! - 2 * v) / n : v;
+      next.set(l, (1 - share) * v + share * mean);
+    }
+    rho = next;
+  }
+  let max = 0;
+  for (const v of rho.values()) max = Math.max(max, v);
+  if (max > 0) for (const [l, v] of rho) rho.set(l, v / max);
+  return rho;
+}
+
+/**
+ * This function gives the highways of the route-aware bundling on the corner graph (HWY-020).
+ * The first ways of the edges give the density of each link. A diffusion along the graph smooths it.
+ * Then each edge takes a shortest way where a dense link costs less: `cost(l) = len(l) / (1 + lambda rho(l))^gamma`, with `rho` from 0 to 1.
+ * Each stretch that `minSize` ways or more share after the second pass is one highway. The highways stay on the links of the corner graph.
+ */
+export function diffusionPlan(input: HighwayInput, o: Readonly<DiffusionOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const corners = finder.corners;
+  const id = new Map<Point, number>();
+  corners.points.forEach((p, i) => id.set(p, i));
+  const M = corners.points.length;
+  const link = (i: number, j: number): number => (i < j ? i * M + j : j * M + i);
+  const plugs = edgePlugs(input.graph);
+  const ends = plugs.map(({ ps, pt }) => [finder.out(ps), finder.out(pt)] as const);
+  // The first pass: the number of first ways on each link.
+  const use = new Map<number, number>();
+  for (const [a, b] of ends) {
+    const way = corners.path(a, b);
+    if (!way) continue;
+    const own = new Set<number>();
+    for (let i = 1; i < way.length; i++) {
+      const p = id.get(way[i - 1]!);
+      const q = id.get(way[i]!);
+      if (p !== undefined && q !== undefined) own.add(link(p, q));
+    }
+    for (const l of own) use.set(l, (use.get(l) ?? 0) + 1);
+  }
+  const rho = linkDensity((i) => corners.neighbours(i), M, use, o.a, o.steps);
+  const lambda = Math.max(0, o.lambda);
+  const gamma = Math.max(0, o.gamma);
+  const floor = 1 / Math.pow(1 + lambda, gamma);
+  const cost = (i: number, j: number, d: number): number => d / Math.pow(1 + lambda * (rho.get(link(i, j)) ?? 0), gamma);
+  // The second pass: the dense links cost less, so the ways come together on them.
+  const ways: KeyedWay[] = [];
+  plugs.forEach(({ edge }, n) => {
+    const [a, b] = ends[n]!;
+    const way = corners.path(a, b, cost, floor);
+    if (way) ways.push({ edge: edge.id, key: "diffusion", points: way });
+  });
+  return sharedStretches(ways, { minSize: o.minSize, pull: (p) => corners.pull(p) });
+}