@mark1russell7/highways 0.9.0 → 0.9.1

package/src/highways/search/index.ts

@@ -0,0 +1,170 @@
+import { ambiguity, bundleStretch, inkSaved, mergeAngle } from "../../bench/measures/bundles.ts";
+import type { Point } from "../../geom.ts";
+import type { Graph, Route } from "../../model.ts";
+import { WayFinder } from "../../ways.ts";
+import { nearestPlace, orderAlongRoutes, tidyPlan, firstRoutes } from "../base.ts";
+import { follow } from "../follow.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayPlan } from "../model.ts";
+import { candidatePlan, type CandidateSource } from "../select/index.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `search` (HWY-059 of the note on highways). */
+export interface SearchOptions {
+  /** The plan where the search starts. The default is `corridors`. */
+  readonly from: CandidateSource;
+  /** The generators of the highways that the move `add` takes. The default is `quickbundles` and `road-classes`. */
+  readonly pool: readonly CandidateSource[];
+  /** The number of plans that the search measures, from 0 to 400. The value 0 gives the start plan. The default is 16. */
+  readonly evaluations: number;
+  /** The first temperature of the annealing, on the scale of the score. Each sweep of 4 moves multiplies it by 0.95. The default is 0.02. */
+  readonly temperature: number;
+  /** The weight of the ink that the routes save (B1). The default is 1. */
+  readonly inkWeight: number;
+  /** The weight of the 0.95 quantile of the stretch against the first routes (B3). The default is 0.5. */
+  readonly stretchWeight: number;
+  /** The weight of the ambiguity (B4). The default is 0.5. */
+  readonly ambiguityWeight: number;
+  /** The weight of the largest merge angle (B6), divided by 180 degrees. The default is 0.25. */
+  readonly angleWeight: number;
+  /** The seed of the moves. The default is 1. */
+  readonly seed: number;
+}
+
+/** The default options of the strategy `search`. */
+export const SEARCH_DEFAULTS: Readonly<SearchOptions> = Object.freeze({
+  from: "corridors",
+  pool: Object.freeze(["quickbundles", "road-classes"] as CandidateSource[]),
+  evaluations: 16,
+  temperature: 0.02,
+  inkWeight: 1,
+  stretchWeight: 0.5,
+  ambiguityWeight: 0.5,
+  angleWeight: 0.25,
+  seed: 1,
+});
+
+/** The moves of the search. */
+export type SearchMove = "add" | "drop" | "edge" | "point";
+
+/** The values of `SearchMove`, in the order of the draw. */
+export const SEARCH_MOVES: readonly SearchMove[] = Object.freeze(["add", "drop", "edge", "point"]);
+
+/** The number of moves of one sweep of the annealing. */
+const SWEEP = 4;
+
+/** This function gives a seeded random source with values from 0 to 1 (mulberry32). */
+function random(seed: number): () => number {
+  let a = Math.floor(seed) >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * This function gives the score of the routes of a plan: `w1 B1 - w3 B3 - w4 B4 - w6 B6 / 180`. Higher is better.
+ * B3 is the 0.95 quantile of the stretch against the first routes. The score reads only the graph and the routes of the plan.
+ */
+export function searchScore(graph: Graph, routes: readonly Route[], first: readonly Route[], o: Readonly<SearchOptions>): number {
+  const ink = inkSaved(routes);
+  const stretch = bundleStretch(routes, first).q95;
+  const amb = o.ambiguityWeight > 0 ? ambiguity(graph, routes).value : 0;
+  const angle = o.angleWeight > 0 ? mergeAngle(routes) / 180 : 0;
+  return o.inkWeight * ink - o.stretchWeight * stretch - o.ambiguityWeight * amb - o.angleWeight * angle;
+}
+
+/**
+ * The function `acceptance` gives the chance to keep a worse plan, for a loss `y` of 0 or more on the scale of the temperature.
+ * It is `1 / (1 + y + y² / 2)`, near `exp(-y)` for a small loss.
+ * It uses only exact arithmetic, so each platform keeps the same plans.
+ */
+function acceptance(y: number): number {
+  return 1 / (1 + y + (y * y) / 2);
+}
+
+/**
+ * This function gives the highways of a local search over the set of highways (HWY-059). The search starts at the plan of `from`.
+ * Each move adds a highway of the pool, drops a highway, moves one edge to another highway, or moves one point of a spine.
+ * The annealing keeps a worse plan with the chance `acceptance(-delta / T)`. The best plan that the search measures is the result.
+ *
+ * The score reads only this graph and its routes. Thus the search does not fit to the inputs of a screen.
+ */
+export function searchPlan(input: HighwayInput, o: Readonly<SearchOptions>): HighwayPlan {
+  const graph = input.graph;
+  const start = tidyPlan(candidatePlan(input, o.from));
+  const budget = Math.max(0, Math.floor(o.evaluations));
+  if (budget === 0 || graph.edges.length === 0) return start;
+  const pool: Highway[] = [];
+  for (const source of o.pool) if (source !== o.from) pool.push(...candidatePlan(input, source).highways);
+  const finder = new WayFinder(graph.nodes);
+  const pad = finder.margin / 2;
+  const plugs = new Map(edgePlugs(graph).map((p) => [p.edge.id, p] as const));
+  const routes = firstRoutes(input);
+  const first = follow(graph, { highways: [] }).routes;
+  const scoreOf = (plan: HighwayPlan): number => searchScore(graph, follow(graph, plan).routes, first, o);
+  const next = random(o.seed);
+  const pick = <T>(list: readonly T[]): T => list[Math.floor(next() * list.length) % list.length]!;
+  const tidy = (highways: Highway[]): HighwayPlan => tidyPlan(orderAlongRoutes({ highways }, routes));
+
+  /** This function gives the plan after one move, or `undefined` when the move does not apply. */
+  const moved = (plan: HighwayPlan, move: SearchMove): HighwayPlan | undefined => {
+    const list = [...plan.highways];
+    if (move === "add") {
+      const known = new Set(list.map((h) => h.spine.map((p) => `${p.x},${p.y}`).join(";")));
+      const fresh = pool.filter((h) => !known.has(h.spine.map((p) => `${p.x},${p.y}`).join(";")));
+      if (fresh.length === 0) return undefined;
+      return tidy([...list, pick(fresh)]);
+    }
+    if (list.length === 0) return undefined;
+    const i = Math.floor(next() * list.length) % list.length;
+    const h = list[i]!;
+    if (move === "drop") return tidy(list.filter((_, j) => j !== i));
+    if (move === "edge") {
+      // One member leaves its highway and rides the nearest other highway that does not carry it.
+      if (list.length < 2 || h.members.length < 3) return undefined;
+      const m = pick(h.members);
+      const plug = plugs.get(m.edge);
+      if (!plug) return undefined;
+      const others = list.map((g, j) => ({ g, j })).filter((x) => x.j !== i && !x.g.members.some((y) => y.edge === m.edge));
+      if (others.length === 0) return undefined;
+      const s = plug.ps.point;
+      const t = plug.pt.point;
+      const to = pick(others);
+      const on = nearestPlace(to.g.spine, s);
+      const off = nearestPlace(to.g.spine, t);
+      if (Math.abs(on - off) < 1e-6) return undefined;
+      list[i] = { ...h, members: h.members.filter((y) => y.edge !== m.edge), lanes: h.lanes.filter((e) => e !== m.edge) };
+      list[to.j] = { ...to.g, members: [...to.g.members, memberAt(to.g.spine, m.edge, on, off, m.seq)], lanes: [...to.g.lanes, m.edge] };
+      return tidy(list);
+    }
+    // The move `point`: one point of the spine moves by two margins on one axis, when the spine stays in clear view.
+    const k = Math.floor(next() * h.spine.length) % h.spine.length;
+    const step = 2 * finder.margin * (next() < 0.5 ? -1 : 1);
+    const p = h.spine[k]!;
+    const q: Point = next() < 0.5 ? { x: p.x + step, y: p.y } : { x: p.x, y: p.y + step };
+    const spine = h.spine.map((x, j) => (j === k ? q : x));
+    if (!finder.obstacles.clearPath(spine, pad)) return undefined;
+    list[i] = { ...h, spine, members: h.members.map((m) => memberAt(spine, m.edge, m.on, m.off, m.seq)) };
+    return tidy(list);
+  };
+
+  let current = start;
+  let currentScore = scoreOf(start);
+  let best = start;
+  let bestScore = currentScore;
+  let temperature = Math.max(0, o.temperature);
+  for (let n = 1, tries = 0; n < budget && tries < 4 * budget; tries++) {
+    const plan = moved(current, pick(SEARCH_MOVES));
+    if (!plan) continue;
+    n++;
+    const score = scoreOf(plan);
+    const delta = score - currentScore;
+    if (delta >= 0 || (temperature > 0 && next() < acceptance(-delta / temperature))) [current, currentScore] = [plan, score];
+    if (score > bestScore + 1e-12) [best, bestScore] = [plan, score];
+    if (n % SWEEP === 0) temperature *= 0.95;
+  }
+  return best;
+}

package/src/highways/snap.ts

@@ -28,6 +28,8 @@ export interface SnapLine {
 export interface SnapOptions extends Pick<WayOptions, "margin" | "k"> {
   /** A highway has this number of edges or more. The value is 2 or more. */
   readonly minSize: number;
+  /** With `true`, a line in clear view is its own spine, with no path through the corner graph. The default is `false`. */
+  readonly direct?: boolean;
 }
 
 /** This function gives the line `u d + rho n` of the direction angle `theta`, with `d = (cos, sin)` and the normal `n = (-sin, cos)`. */
@@ -61,9 +63,9 @@ export function snapPlan(input: HighwayInput, lines: readonly SnapLine[], o: Rea
     const a = free(line.a);
     const b = free(line.b);
     if (dist(a, b) <= finder.margin) continue;
-    const raw = corners.path(a, b);
+    const raw = o.direct === true && finder.obstacles.clear(a, b, pad) ? [a, b] : corners.path(a, b);
     if (!raw) continue;
-    const spine = corners.pull(raw);
+    const spine = o.direct === true && raw.length === 2 ? raw : corners.pull(raw);
     if (spine.length < 2 || polylineLength(spine) <= 1e-6) continue;
     const riders: { edge: string; on: number; off: number; points: Point[] }[] = [];
     for (const m of line.members) {

package/src/highways/steiner/index.ts

@@ -0,0 +1,215 @@
+import { polylineLength, type Point } from "../../geom.ts";
+import { byCollection } from "../../routers/trunks.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+
+/** The groups of the trees: the edges from one source node, or the edges of one collection. */
+export type SteinerGroup = "source" | "key";
+
+/** The values of `SteinerGroup`. */
+export const STEINER_GROUPS: readonly SteinerGroup[] = Object.freeze(["source", "key"]);
+
+/** The method of the tree: the iterated 1-Steiner method on the Hanan grid, or the spanning tree of the terminals alone. */
+export type SteinerMethod = "one-steiner" | "spanning";
+
+/** The values of `SteinerMethod`. */
+export const STEINER_METHODS: readonly SteinerMethod[] = Object.freeze(["one-steiner", "spanning"]);
+
+/** The metric of the tree: rectilinear (two directions) or octilinear (four directions). */
+export type SteinerMetric = "rectilinear" | "octilinear";
+
+/** The values of `SteinerMetric`. */
+export const STEINER_METRICS: readonly SteinerMetric[] = Object.freeze(["rectilinear", "octilinear"]);
+
+/** The options of the highway strategy `steiner` (HWY-036 of the note on highways, with EDA-015). */
+export interface SteinerOptions {
+  /** The groups of the trees. The default is `source`. */
+  readonly group: SteinerGroup;
+  /** The method of the tree. The default is `one-steiner`. */
+  readonly method: SteinerMethod;
+  /** A group with more terminals than this number gets the spanning tree alone. The default is 12. */
+  readonly maxGroup: number;
+  /** The metric of the tree. The default is `rectilinear`. */
+  readonly metric: SteinerMetric;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `steiner`. */
+export const STEINER_DEFAULTS: Readonly<SteinerOptions> = Object.freeze({ group: "source", method: "one-steiner", maxGroup: 12, metric: "rectilinear", detour: 1.5, minSize: 2 });
+
+/** This function gives the distance of two points in the metric. */
+function metricDistance(a: Point, b: Point, metric: SteinerMetric): number {
+  const dx = Math.abs(a.x - b.x);
+  const dy = Math.abs(a.y - b.y);
+  return metric === "rectilinear" ? dx + dy : Math.max(dx, dy) + (Math.SQRT2 - 1) * Math.min(dx, dy);
+}
+
+/** This function gives the links of the spanning tree of the points (Prim), as pairs of indices, and the sum of their lengths. */
+export function spanningTree(points: readonly Point[], metric: SteinerMetric): { links: [number, number][]; cost: number } {
+  const n = points.length;
+  if (n < 2) return { links: [], cost: 0 };
+  const inTree = new Uint8Array(n);
+  const best = new Float64Array(n).fill(Infinity);
+  const from = new Int32Array(n).fill(-1);
+  best[0] = 0;
+  const links: [number, number][] = [];
+  let cost = 0;
+  for (let k = 0; k < n; k++) {
+    let u = -1;
+    for (let i = 0; i < n; i++) if (!inTree[i] && (u < 0 || best[i]! < best[u]!)) u = i;
+    inTree[u] = 1;
+    if (from[u]! >= 0) {
+      links.push([from[u]!, u]);
+      cost += best[u]!;
+    }
+    for (let i = 0; i < n; i++) {
+      if (inTree[i]) continue;
+      const d = metricDistance(points[u]!, points[i]!, metric);
+      if (d < best[i]!) {
+        best[i] = d;
+        from[i] = u;
+      }
+    }
+  }
+  return { links, cost };
+}
+
+/**
+ * This function gives a Steiner tree of the terminals by the iterated 1-Steiner method (Kahng and Robins). The candidates are the points of the Hanan grid.
+ * Each round adds the candidate that makes the spanning tree shortest, and drops each added point with two links or fewer.
+ * The test `free` removes the candidates in the boxes. The result has the terminals first, then the added points.
+ */
+export function oneSteiner(terminals: readonly Point[], metric: SteinerMetric, free: (p: Point) => boolean): { points: Point[]; links: [number, number][] } {
+  const points = [...terminals];
+  const xs = [...new Set(terminals.map((p) => p.x))].sort((a, b) => a - b);
+  const ys = [...new Set(terminals.map((p) => p.y))].sort((a, b) => a - b);
+  const taken = new Set(terminals.map((p) => `${p.x},${p.y}`));
+  const candidates: Point[] = [];
+  for (const x of xs) for (const y of ys) if (!taken.has(`${x},${y}`) && free({ x, y })) candidates.push({ x, y });
+  let tree = spanningTree(points, metric);
+  for (let round = 0; round < terminals.length; round++) {
+    let best = -1;
+    let bestCost = tree.cost - 1e-9 * Math.max(1, tree.cost);
+    candidates.forEach((c, i) => {
+      const cost = spanningTree([...points, c], metric).cost;
+      if (cost < bestCost) [best, bestCost] = [i, cost];
+    });
+    if (best < 0) break;
+    points.push(candidates[best]!);
+    candidates.splice(best, 1);
+    tree = spanningTree(points, metric);
+    // An added point with two links or fewer saves nothing, so it leaves the tree.
+    for (;;) {
+      const degree = new Array<number>(points.length).fill(0);
+      for (const [a, b] of tree.links) {
+        degree[a] = degree[a]! + 1;
+        degree[b] = degree[b]! + 1;
+      }
+      let drop = -1;
+      for (let i = terminals.length; i < points.length; i++) if (degree[i]! <= 2) drop = i;
+      if (drop < 0) break;
+      points.splice(drop, 1);
+      tree = spanningTree(points, metric);
+    }
+  }
+  return { points, links: tree.links };
+}
+
+/**
+ * This function gives the polyline of one link of the tree. A rectilinear link is an L in clear view, else a path through the corner graph.
+ * An octilinear link is a straight piece and a diagonal piece. The same link gives the same points each time.
+ */
+function linkPath(a: Point, b: Point, metric: SteinerMetric, finder: WayFinder): Point[] {
+  const pad = finder.margin / 2;
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const tries: Point[][] = [];
+  if (Math.abs(dx) < 1e-9 || Math.abs(dy) < 1e-9) tries.push([a, b]);
+  else if (metric === "rectilinear") tries.push([a, { x: b.x, y: a.y }, b], [a, { x: a.x, y: b.y }, b]);
+  else {
+    const d = Math.min(Math.abs(dx), Math.abs(dy));
+    const diag = { x: a.x + Math.sign(dx) * d, y: a.y + Math.sign(dy) * d };
+    const late = { x: b.x - Math.sign(dx) * d, y: b.y - Math.sign(dy) * d };
+    tries.push([a, diag, b], [a, late, b]);
+  }
+  for (const t of tries) if (finder.obstacles.clearPath(t, pad)) return t.filter((p, i) => i === 0 || p.x !== t[i - 1]!.x || p.y !== t[i - 1]!.y);
+  const way = finder.corners.path(a, b);
+  return way ? finder.corners.pull(way) : [a, b];
+}
+
+/**
+ * This function gives the highways of obstacle-avoiding Steiner trees (HWY-036 with EDA-015). Each group of edges gets one tree over the points out of its plugs.
+ * The links of the tree are rectilinear or octilinear, and they go around the boxes. Each edge takes its path in the tree, when that path is short enough.
+ * The stretches of the tree that two edges or more share become highways.
+ */
+export function steinerPlan(input: HighwayInput, o: Readonly<SteinerOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const pad = finder.margin / 2;
+  const first = firstRoutes(input);
+  const groups = new Map<string, { edge: string; s: Point; t: Point; base: number }[]>();
+  for (const p of edgePlugs(input.graph)) {
+    const key = o.group === "key" ? (byCollection(p.edge) ?? `\u0000${p.edge.source.node}`) : p.edge.source.node;
+    const s = finder.out(p.ps);
+    const t = finder.out(p.pt);
+    const route = first.get(p.edge.id);
+    const list = groups.get(key) ?? [];
+    list.push({ edge: p.edge.id, s, t, base: route ? polylineLength(route) : metricDistance(s, t, "rectilinear") });
+    groups.set(key, list);
+  }
+  const ways: KeyedWay[] = [];
+  for (const key of [...groups.keys()].sort()) {
+    const list = groups.get(key)!;
+    if (list.length < 2) continue;
+    const index = new Map<string, number>();
+    const terminals: Point[] = [];
+    const at = (p: Point): number => {
+      const k = `${p.x},${p.y}`;
+      let i = index.get(k);
+      if (i === undefined) {
+        index.set(k, (i = terminals.length));
+        terminals.push(p);
+      }
+      return i;
+    };
+    const ends = list.map((e) => [at(e.s), at(e.t)] as const);
+    const tree = o.method === "one-steiner" && terminals.length <= o.maxGroup ? oneSteiner(terminals, o.metric, (p) => !finder.obstacles.inside(p, pad)) : { points: terminals, ...spanningTree(terminals, o.metric) };
+    const n = tree.points.length;
+    const next: { to: number; path: Point[] }[][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of tree.links) {
+      const path = linkPath(tree.points[a]!, tree.points[b]!, o.metric, finder);
+      next[a]!.push({ to: b, path });
+      next[b]!.push({ to: a, path: [...path].reverse() });
+    }
+    list.forEach((e, k) => {
+      const [s, t] = ends[k]!;
+      // The path in the tree from `s` to `t`, by a search from `s`.
+      const back = new Int32Array(n).fill(-2);
+      const via: (Point[] | undefined)[] = new Array(n);
+      back[s] = -1;
+      const queue = [s];
+      while (queue.length > 0) {
+        const u = queue.shift()!;
+        if (u === t) break;
+        for (const x of next[u]!) {
+          if (back[x.to] !== -2) continue;
+          back[x.to] = u;
+          via[x.to] = x.path;
+          queue.push(x.to);
+        }
+      }
+      if (back[t] === -2 || s === t) return;
+      const pieces: Point[][] = [];
+      for (let v = t; v !== s; v = back[v]!) pieces.push(via[v]!);
+      const points: Point[] = [];
+      for (const piece of pieces.reverse()) for (const p of piece) if (points.length === 0 || p.x !== points[points.length - 1]!.x || p.y !== points[points.length - 1]!.y) points.push(p);
+      if (polylineLength(points) > o.detour * e.base) return;
+      ways.push({ edge: e.edge, key, points });
+    });
+  }
+  return sharedStretches(ways, { minSize: o.minSize });
+}

package/src/highways/streets/index.ts

@@ -0,0 +1,78 @@
+import { dist } from "../../geom.ts";
+import { WayFinder } from "../../ways.ts";
+import { freeLines, streetEdges, streetRide, type StreetRide, type StreetSource } from "../free-lines.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { snapPlan, type SnapLine } from "../snap.ts";
+
+/** The options of the highway strategy `streets` (HWY-058 of the note on highways). */
+export interface StreetOptions {
+  /** A street covers an edge when the way of the edge along the street is this many times its first route or less (the limit `s`). The default is 1.2. */
+  readonly detour: number;
+  /** The greedy cover stops when the best street gives less than this gain: the length that its edges ride over the length of the street. The default is 2. */
+  readonly minGain: number;
+  /** The largest number of streets. The default is 32. */
+  readonly maxStreets: number;
+  /** A street with fewer new edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The source of the streets: the gaps of the room step, or the lines through the corners. The default is `corners`. */
+  readonly source: StreetSource;
+}
+
+/** The default options of the strategy `streets`. */
+export const STREET_DEFAULTS: Readonly<StreetOptions> = Object.freeze({ detour: 1.2, minGain: 2, maxStreets: 32, minSize: 2, source: "corners" });
+
+/**
+ * This function gives orthogonal streets by a greedy set cover (HWY-058). A street covers each edge whose way along it is at most `detour` times its first route.
+ * Each step takes the street with the largest gain: the length that its new edges ride, over the length of the street that they use.
+ * The cover stops at `maxStreets` streets, or when the best gain is below `minGain`. Each edge rides one street at most.
+ */
+export function streetPlan(input: HighwayInput, o: Readonly<StreetOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const lines = freeLines(input.graph, finder, o.source);
+  const edges = streetEdges(input, finder);
+  const min = 2 * finder.margin;
+  const size = Math.max(2, Math.round(o.minSize));
+  // The cover of each street: each edge that it covers, with its ride.
+  const covers: { edge: string; ride: StreetRide }[][] = lines.map((line) => {
+    const out: { edge: string; ride: StreetRide }[] = [];
+    for (const e of edges) {
+      const r = streetRide(line, e);
+      if (r.ride >= min && r.ramps + r.ride <= o.detour * e.base) out.push({ edge: e.edge, ride: r });
+    }
+    return out;
+  });
+  const done = new Set<string>();
+  const chosen: SnapLine[] = [];
+  const used = new Set<number>();
+  while (chosen.length < Math.max(0, Math.floor(o.maxStreets))) {
+    let best = -1;
+    let bestGain = -Infinity;
+    let bestPart: { edge: string; ride: StreetRide }[] = [];
+    covers.forEach((cover, i) => {
+      if (used.has(i)) return;
+      const part = cover.filter((c) => !done.has(c.edge));
+      if (part.length < size) return;
+      const vertical = lines[i]!.a.x === lines[i]!.b.x;
+      const us = part.flatMap((c) => (vertical ? [c.ride.on.y, c.ride.off.y] : [c.ride.on.x, c.ride.off.x]));
+      const span = Math.max(...us) - Math.min(...us);
+      if (span <= 0) return;
+      let ride = 0;
+      for (const c of part) ride += c.ride.ride;
+      const gain = ride / span;
+      if (gain > bestGain) [best, bestGain, bestPart] = [i, gain, part];
+    });
+    if (best < 0 || bestGain < o.minGain) break;
+    used.add(best);
+    for (const c of bestPart) done.add(c.edge);
+    const line = lines[best]!;
+    const vertical = line.a.x === line.b.x;
+    const us = bestPart.flatMap((c) => (vertical ? [c.ride.on.y, c.ride.off.y] : [c.ride.on.x, c.ride.off.x]));
+    const lo = Math.min(...us);
+    const hi = Math.max(...us);
+    const a = vertical ? { x: line.a.x, y: lo } : { x: lo, y: line.a.y };
+    const b = vertical ? { x: line.a.x, y: hi } : { x: hi, y: line.a.y };
+    if (dist(a, b) <= 0) continue;
+    chosen.push({ key: `street${chosen.length}`, a, b, members: bestPart.map((c) => ({ edge: c.edge, from: c.ride.on, to: c.ride.off, at: 0 })) });
+  }
+  return snapPlan(input, chosen, { minSize: size, direct: true });
+}

package/src/model.ts

@@ -1,3 +1,4 @@
+import { portPoint } from "@mark1russell7/layout-contract";
 import type { Box, Point } from "./geom.ts";
 
 /** A side of a node box. */
@@ -5,7 +6,8 @@ export type Side = "north" | "east" | "south" | "west";
 
 /**
  * A plug of a node: a place where edges go into the node.
- * A plug with `at` is fixed. The router does not move it. A plug without `at` is free: the router places it.
+ * A plug with `at` is fixed. The router does not move it. A plug with `side` and `along` is fixed too.
+ * Another plug is free: the router places it.
  */
 export interface Port {
   readonly id: string;
@@ -13,6 +15,12 @@ export interface Port {
   readonly at?: Point;
   /** This side is where a free plug goes. Without it, the router picks the side. */
   readonly side?: Side;
+  /**
+   * This fraction from 0 to 1 fixes the plug on its `side`. The plug is at the side start plus `along` times the side length.
+   * The start of `north` and `south` is the left end. The start of `east` and `west` is the top end.
+   * A plug with `along` needs a `side` and has no `at`. `resolvePorts` throws a `RangeError` for a bad value.
+   */
+  readonly along?: number;
 }
 
 /** A node: a box that routes must not go through. */
@@ -131,10 +139,58 @@ export function nodeIndex(g: Graph): Map<string, Node> {
   return m;
 }
 
-/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+/** The names of the sides in `@mark1russell7/layout-contract`. */
+const CONTRACT_SIDE = { north: "top", east: "right", south: "bottom", west: "left" } as const;
+
+/**
+ * This function gives the place of a fixed plug, relative to the top-left corner of the node box, or `undefined` for a free plug.
+ * A plug with `at` gives `at`. A plug with `side` and `along` gives the point of `portPoint` of `@mark1russell7/layout-contract`.
+ */
+export function portOffset(box: Box, port: Port): Point | undefined {
+  if (port.at !== undefined) return port.at;
+  if (port.side === undefined || port.along === undefined) return undefined;
+  return portPoint(box, { id: port.id, side: CONTRACT_SIDE[port.side], along: port.along });
+}
+
+/** This function throws a `RangeError` when the `along` of a plug is bad: not finite, outside 0 to 1, without `side` or with `at`. */
+export function checkPort(node: Node, port: Port): void {
+  if (port.along === undefined) return;
+  const at = `The plug "${port.id}" of the node "${node.id}"`;
+  if (typeof port.along !== "number" || !Number.isFinite(port.along) || port.along < 0 || port.along > 1)
+    throw new RangeError(`${at} has the along value ${String(port.along)}. It must be a finite number from 0 to 1.`);
+  if (port.side === undefined) throw new RangeError(`${at} has an along value and no side. A plug with along needs a side.`);
+  if (port.at !== undefined) throw new RangeError(`${at} has an along value and an at point. Give one of the two.`);
+}
+
+/**
+ * This function checks the plugs of a graph, and gives each plug with `side` and `along` a fixed `at`. The plug keeps its `side`.
+ * Each router calls it at the start of `route`, so all routers agree. A graph without `along` comes back as the same object.
+ * It throws a `RangeError` for a bad `along` (`checkPort`).
+ */
+export function resolvePorts(graph: Graph): Graph {
+  let found = false;
+  for (const n of graph.nodes)
+    for (const p of n.ports ?? []) {
+      checkPort(n, p);
+      if (p.along !== undefined) found = true;
+    }
+  if (!found) return graph;
+  const nodes = graph.nodes.map((n): Node => {
+    if (!n.ports?.some((p) => p.along !== undefined)) return n;
+    const ports = n.ports.map((p): Port => {
+      if (p.along === undefined) return p;
+      return { id: p.id, side: p.side!, at: portOffset(n.box, p)! };
+    });
+    return { ...n, ports };
+  });
+  return { ...graph, nodes };
+}
+
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. A plug with `side` and `along` is fixed. */
 export function fixedPortPoint(node: Node, end: End): Point | undefined {
   if (end.port === undefined) return undefined;
   const p = node.ports?.find((q) => q.id === end.port);
-  if (p?.at === undefined) return undefined;
-  return { x: node.box.x + p.at.x, y: node.box.y + p.at.y };
+  const at = p === undefined ? undefined : portOffset(node.box, p);
+  if (at === undefined) return undefined;
+  return { x: node.box.x + at.x, y: node.box.y + at.y };
 }

package/src/routers/attraction/index.ts

@@ -0,0 +1,61 @@
+import type { Graph, GroupRule, Result, Router } from "../../model.ts";
+import { defineStrategy, type Strategy } from "../../strategies/model.ts";
+import type { OptionSchema } from "../../strategies/options.ts";
+import { sharedRouter } from "../shared.ts";
+import { byCollection } from "../trunks.ts";
+
+/** The options of the router `attraction` (HWY-044 of the note on highways: negotiated attraction, PathFinder turned around). */
+export interface AttractionOptions {
+  /** The number of passes, from 1 to 10. Each pass after the first routes each edge again from no ways. The default is 3. */
+  readonly passes: number;
+  /** The pull `a` of the history of a link, from 0 to 1. A link then costs `1 - a h` times more. The default is 0.5. */
+  readonly attraction: number;
+  /** The cost weight `b` of each edge over the capacity of a link, from 0 to 10. The default is 1. */
+  readonly capacityWeight: number;
+  /** The width of one lane. The capacity of a link is its free width divided by this width. The default is 4. */
+  readonly laneWidth: number;
+}
+
+/** The default options of the router `attraction`. */
+export const ATTRACTION_DEFAULTS: Readonly<AttractionOptions> = Object.freeze({ passes: 3, attraction: 0.5, capacityWeight: 1, laneWidth: 4 });
+
+/** The declarations of the options of the router `attraction` (HWY-044). */
+export const ATTRACTION_SCHEMA: OptionSchema<AttractionOptions> = {
+  passes: { type: "integer", min: 1, max: 10, step: 1, marks: [2, 3, 5], default: 3, describe: "The number of passes. Each later pass routes each edge again from no ways." },
+  attraction: { type: "number", min: 0, max: 1, step: 0.05, marks: [0.25, 0.5, 0.75], default: 0.5, describe: "The pull of the history of a link. A busy link of the passes before costs less." },
+  capacityWeight: { type: "number", min: 0, max: 10, step: 0.5, marks: [0, 1, 4], default: 1, describe: "The cost weight of each edge over the capacity of a link." },
+  laneWidth: { type: "number", min: 1, max: 12, step: 1, marks: [4, 6], default: 4, describe: "The width of one lane. The capacity of a link is its free width divided by this width." },
+};
+
+/**
+ * This function makes the router `attraction` (HWY-044). It is the router `shared` with a negotiation over the passes.
+ * After each pass, the history `h` of each link grows by `use / m`, with `m` the edges of the key. The history stops at `0.9 / a`.
+ * In each pass, a link costs `len (1 - a h) (1 + b max(0, use - cap))` times the cost in `shared`.
+ * The busy links of the passes before thus pull the edges, and a link over its capacity pushes them away.
+ */
+export function attractionRouter(options: Partial<AttractionOptions> & { readonly name: string; readonly rule?: GroupRule; readonly maxNodes?: number }): Router {
+  const o = { ...ATTRACTION_DEFAULTS, ...options };
+  return sharedRouter(
+    { name: o.name, ...(o.rule === undefined ? {} : { rule: o.rule }), ...(o.maxNodes === undefined ? {} : { maxNodes: o.maxNodes }) },
+    {
+      passes: Math.max(1, Math.floor(o.passes)),
+      attraction: Math.min(1, Math.max(0, o.attraction)),
+      capacityWeight: Math.max(0, o.capacityWeight),
+      laneWidth: Math.max(1e-6, o.laneWidth),
+    },
+  );
+}
+
+/**
+ * The router strategy `attraction` (HWY-044), with the rule `byCollection` of `shared`. It is not a built-in router, so the benchmark and the hashes of `ROUTERS` do not change.
+ * A screen module or a consumer adds it to a registry.
+ */
+export const attractionStrategy: Strategy<"router", AttractionOptions> = defineStrategy({
+  step: "router",
+  name: "attraction",
+  describe: "Negotiated attraction (HWY-044). The router `shared` routes each edge again in each pass, and the busy links of the passes before pull the edges.",
+  defaults: { ...ATTRACTION_DEFAULTS },
+  schema: ATTRACTION_SCHEMA,
+  maxNodes: 10_000,
+  run: (graph: Graph, o: Readonly<AttractionOptions>): Result => attractionRouter({ ...o, name: "attraction", rule: byCollection }).route(graph),
+});

package/src/routers/corners.ts

@@ -1,5 +1,5 @@
 import { center, type Point } from "../geom.ts";
-import { nodeIndex, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, fixedPortPoint, resolvePorts, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { justifyPlugs } from "../plugs/justify.ts";
 import { sidePlugs } from "../plugs/side.ts";
@@ -42,7 +42,8 @@ export interface CornersOptions extends WayOptions {
 export function cornersRouter(options: CornersOptions): Router {
   const router: Router = {
     name: options.name,
-    route(graph: Graph): Result {
+    route(input: Graph): Result {
+      const graph = resolvePorts(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const routes: Route[] = [];
@@ -104,8 +105,7 @@ function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number): void {
       [e.source, s, ps, pt, 3],
       [e.target, t, pt, ps, 4],
     ] as const) {
-      const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
-      if (port?.at !== undefined) continue;
+      if (fixedPortPoint(node, end) !== undefined) continue;
       const key = JSON.stringify([node.id, plug.normal.x, plug.normal.y]);
       let side = sides.get(key);
       if (!side) sides.set(key, (side = { node, normal: plug.normal, items: [] }));