@mark1russell7/highways 0.5.0 → 0.5.1

package/src/highways/mesh/index.ts

@@ -0,0 +1,209 @@
+import { dist, type Point } from "../../geom.ts";
+import type { Graph } from "../../model.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+import { tracePlan } from "../trace.ts";
+
+/** The options of the highway strategy `mesh` (HWY-004 of the notes). */
+export interface MeshOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The side of a cell of the mesh, in units of the boxes: the median of the smaller side of each box. The default is 4. */
+  readonly cell: number;
+  /** A cluster of crossings on one segment of the mesh has at most about this number of edges. The default is 8. */
+  readonly capacity: number;
+  /** Two clusters nearer than this value, in units of the boxes, become one. The default is 1. */
+  readonly merge: number;
+  /** The largest angle in degrees between a line and the main direction of a cell. A line with a larger angle does not cross the mesh there. The default is 45. */
+  readonly angle: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `mesh`. */
+export const MESH_DEFAULTS: Readonly<Required<Omit<MeshOptions, "margin" | "k">>> = Object.freeze({
+  cell: 4,
+  capacity: 8,
+  merge: 1,
+  angle: 45,
+  minSize: 2,
+});
+
+/** The number of bins of the histogram of the angles. Each bin is 10 degrees wide. */
+const BINS = 18;
+
+/** This function gives the median of the smaller side of each box of the graph, or 1 for a graph without boxes. */
+export function boxUnit(graph: Graph): number {
+  const sides = graph.nodes.map((n) => Math.min(n.box.w, n.box.h)).sort((a, b) => a - b);
+  return sides.length > 0 ? Math.max(1e-3, sides[Math.floor(sides.length / 2)]!) : 1;
+}
+
+/** This function gives the shares `t` of the segment `a b` and `u` of the segment `c d` at their crossing. Segments that do not cross give `undefined`. */
+function crossing(a: Point, b: Point, c: Point, d: Point): { t: number; u: number } | undefined {
+  const rx = b.x - a.x;
+  const ry = b.y - a.y;
+  const sx = d.x - c.x;
+  const sy = d.y - c.y;
+  const den = rx * sy - ry * sx;
+  if (Math.abs(den) < 1e-12) return undefined;
+  const t = ((c.x - a.x) * sy - (c.y - a.y) * sx) / den;
+  const u = ((c.x - a.x) * ry - (c.y - a.y) * rx) / den;
+  const eps = 1e-9;
+  return t >= -eps && t <= 1 + eps && u >= -eps && u <= 1 + eps ? { t: Math.max(0, Math.min(1, t)), u: Math.max(0, Math.min(1, u)) } : undefined;
+}
+
+/** This function gives the clusters of the values by a 1D k-means with `k` centres, then joins the centres nearer than `merge`. The result gives the centre of each value. */
+export function clusters1d(values: readonly number[], k: number, merge: number): number[] {
+  const n = values.length;
+  if (n === 0) return [];
+  const sorted = [...values].sort((a, b) => a - b);
+  const count = Math.max(1, Math.min(n, k));
+  let centres = Array.from({ length: count }, (_, i) => sorted[Math.min(n - 1, Math.floor(((i + 0.5) * n) / count))]!);
+  const nearest = (v: number): number => {
+    let best = 0;
+    for (let i = 1; i < centres.length; i++) if (Math.abs(centres[i]! - v) < Math.abs(centres[best]! - v)) best = i;
+    return best;
+  };
+  for (let it = 0; it < 20; it++) {
+    const sum = centres.map(() => 0);
+    const num = centres.map(() => 0);
+    for (const v of values) {
+      const i = nearest(v);
+      sum[i] = sum[i]! + v;
+      num[i] = num[i]! + 1;
+    }
+    const next = centres.map((c, i) => (num[i]! > 0 ? sum[i]! / num[i]! : c));
+    const moved = next.some((c, i) => Math.abs(c - centres[i]!) > 1e-9);
+    centres = next;
+    if (!moved) break;
+  }
+  // The join of the near centres: the weighted mean of each run of centres closer than `merge`.
+  const weight = centres.map(() => 0);
+  for (const v of values) {
+    const i = nearest(v);
+    weight[i] = weight[i]! + 1;
+  }
+  const order = centres
+    .map((c, i) => ({ c, w: weight[i]! }))
+    .filter((x) => x.w > 0)
+    .sort((p, q) => p.c - q.c);
+  const joined: { c: number; w: number }[] = [];
+  for (const x of order) {
+    const last = joined[joined.length - 1];
+    if (last && x.c - last.c < merge) {
+      const w = last.w + x.w;
+      last.c = (last.c * last.w + x.c * x.w) / w;
+      last.w = w;
+    } else joined.push({ ...x });
+  }
+  centres = joined.map((x) => x.c);
+  return values.map((v) => centres[nearest(v)]!);
+}
+
+/** One cell of the mesh: its place in the grid, the histogram of the angles of its lines, and the lines through it. */
+interface MeshCell {
+  readonly cx: number;
+  readonly cy: number;
+  readonly bins: number[];
+  /** The sum of the angles of the lines in each bin. */
+  readonly angles: number[];
+  readonly lines: Set<number>;
+}
+
+/**
+ * This function gives the waypoints of the control mesh (HWY-004, GBEC of Cui, Zhou, Qu, Wong and Li 2008).
+ * A grid of cells covers the board. The main direction of each cell is the peak of a histogram of the angles of the straight lines through it.
+ * The segment of the mesh in a cell goes through its middle, across that direction. The crossings of the lines with the segment form clusters by a 1D k-means.
+ * The centre of the cluster of each crossing is a waypoint of its edge. The waypoints of an edge are in the order of the edge.
+ */
+export function meshWaypoints(input: HighwayInput, finder: WayFinder, o: Readonly<MeshOptions>): Map<string, Point[]> {
+  const plugs = edgePlugs(input.graph);
+  const out = new Map<string, Point[]>();
+  if (plugs.length === 0) return out;
+  const unit = boxUnit(input.graph);
+  const side = Math.max(1e-3, o.cell * unit);
+  const lines = plugs.map(({ ps, pt }) => ({ a: finder.out(ps), b: finder.out(pt) }));
+  let x0 = Infinity;
+  let y0 = Infinity;
+  for (const l of lines) {
+    x0 = Math.min(x0, l.a.x, l.b.x);
+    y0 = Math.min(y0, l.a.y, l.b.y);
+  }
+  const cells = new Map<string, MeshCell>();
+  lines.forEach((l, e) => {
+    const len = dist(l.a, l.b);
+    if (len <= 1e-9) return;
+    const ang = ((Math.atan2(l.b.y - l.a.y, l.b.x - l.a.x) % Math.PI) + Math.PI) % Math.PI;
+    const bin = Math.min(BINS - 1, Math.floor((ang / Math.PI) * BINS));
+    const steps = Math.max(1, Math.ceil((2 * len) / side));
+    for (let s = 0; s <= steps; s++) {
+      const u = s / steps;
+      const cx = Math.floor((l.a.x + (l.b.x - l.a.x) * u - x0) / side);
+      const cy = Math.floor((l.a.y + (l.b.y - l.a.y) * u - y0) / side);
+      const id = `${cx},${cy}`;
+      let cell = cells.get(id);
+      if (!cell) {
+        cell = { cx, cy, bins: new Array<number>(BINS).fill(0), angles: new Array<number>(BINS).fill(0), lines: new Set() };
+        cells.set(id, cell);
+      }
+      if (!cell.lines.has(e)) {
+        cell.lines.add(e);
+        cell.bins[bin] = cell.bins[bin]! + 1;
+        cell.angles[bin] = cell.angles[bin]! + ang;
+      }
+    }
+  });
+  const capacity = Math.max(1, o.capacity);
+  const maxAngle = (Math.max(0, Math.min(90, o.angle)) * Math.PI) / 180;
+  const marks: { t: number; p: Point }[][] = lines.map(() => []);
+  for (const id of [...cells.keys()].sort()) {
+    const cell = cells.get(id)!;
+    if (cell.lines.size < 2) continue;
+    let peak = 0;
+    for (let i = 1; i < BINS; i++) if (cell.bins[i]! > cell.bins[peak]!) peak = i;
+    // The main direction is the mean angle of the lines in the peak bin.
+    const theta = cell.angles[peak]! / cell.bins[peak]!;
+    const mid = { x: x0 + (cell.cx + 0.5) * side, y: y0 + (cell.cy + 0.5) * side };
+    const across = { x: -Math.sin(theta), y: Math.cos(theta) };
+    // The segment goes from side to side of the cell.
+    const half = side / 2 / Math.max(Math.abs(across.x), Math.abs(across.y));
+    const c = { x: mid.x - across.x * half, y: mid.y - across.y * half };
+    const d = { x: mid.x + across.x * half, y: mid.y + across.y * half };
+    const hits: { e: number; t: number; u: number }[] = [];
+    for (const e of [...cell.lines].sort((p, q) => p - q)) {
+      const l = lines[e]!;
+      const len = dist(l.a, l.b);
+      const cos = Math.abs(((l.b.x - l.a.x) * Math.cos(theta) + (l.b.y - l.a.y) * Math.sin(theta)) / len);
+      if (Math.acos(Math.min(1, cos)) > maxAngle + 1e-9) continue;
+      const x = crossing(l.a, l.b, c, d);
+      if (x) hits.push({ e, t: x.t, u: x.u });
+    }
+    if (hits.length < 2) continue;
+    const centres = clusters1d(
+      hits.map((h) => h.u * 2 * half),
+      Math.ceil(hits.length / capacity),
+      Math.max(0, o.merge) * unit,
+    );
+    const size = new Map<number, number>();
+    for (const v of centres) size.set(v, (size.get(v) ?? 0) + 1);
+    hits.forEach((h, i) => {
+      const v = centres[i]!;
+      if ((size.get(v) ?? 0) < 2) return;
+      marks[h.e]!.push({ t: h.t, p: { x: c.x + across.x * v, y: c.y + across.y * v } });
+    });
+  }
+  plugs.forEach(({ edge }, e) => {
+    const list = marks[e]!.sort((p, q) => p.t - q.t).map((m) => m.p);
+    if (list.length > 0) out.set(edge.id, list);
+  });
+  return out;
+}
+
+/**
+ * This function gives the highways of the control mesh (HWY-004). Each edge goes through the centres of its clusters on the mesh, along the corner graph.
+ * The centres of one cluster are one point, so the edges of a cluster share the ways between them. The stretches that `minSize` ways share become highways.
+ */
+export function meshPlan(input: HighwayInput, o: Readonly<MeshOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const waypoints = meshWaypoints(input, finder, o);
+  return tracePlan(input, finder, waypoints, { snap: 0, minSize: o.minSize, key: "mesh" });
+}

package/src/highways/mlseb/index.ts

@@ -0,0 +1,204 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { DensitySource } from "../kdeeb/index.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { resample } from "../quickbundles/index.ts";
+import { edgePlugs } from "../stretches.ts";
+import { outOfBoxes, tracePlan } from "../trace.ts";
+
+/** The local fit of the moving least squares: a line, or a parabola in the frame of the line. */
+export type MlsFit = "line" | "parabola";
+
+/** The values of `MlsFit`. */
+export const MLS_FITS: readonly MlsFit[] = Object.freeze(["line", "parabola"]);
+
+/** The options of the highway strategy `mlseb` (HWY-008 of the notes). */
+export interface MlsebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the fit at the first step, as a multiple of `boardUnit`: the median short side of the boxes. The default is 2. */
+  readonly radius: number;
+  /** Each step multiplies the radius by this value. The default is 0.8. */
+  readonly decay: number;
+  /** The number of steps. The default is 6. */
+  readonly steps: number;
+  /** The local fit. The default is `line`. */
+  readonly fit: MlsFit;
+  /** The weight of the angle, from 0 to 1. With 1, a sample at a right angle to the point has no weight. The default is 1. */
+  readonly angleWeight: number;
+  /** The spacing of the sample points of each edge, in units of the board. The default is 8. */
+  readonly spacing: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `mlseb`. */
+export const MLSEB_DEFAULTS: Readonly<Required<Omit<MlsebOptions, "margin" | "k">>> = Object.freeze({
+  source: "lines",
+  radius: 2,
+  decay: 0.8,
+  steps: 6,
+  fit: "line",
+  angleWeight: 1,
+  spacing: 8,
+  snap: 8,
+  minSize: 2,
+});
+
+/** One sample point of an edge, with the unit tangent of its edge there. */
+interface Sample {
+  readonly p: Point;
+  readonly tx: number;
+  readonly ty: number;
+}
+
+/** This function gives the unit tangent of a polyline at its point `i`, from the point before it to the point after it. */
+function tangent(line: readonly Point[], i: number): { tx: number; ty: number } {
+  const a = line[Math.max(0, i - 1)]!;
+  const b = line[Math.min(line.length - 1, i + 1)]!;
+  const l = Math.hypot(b.x - a.x, b.y - a.y);
+  return l > 1e-12 ? { tx: (b.x - a.x) / l, ty: (b.y - a.y) / l } : { tx: 1, ty: 0 };
+}
+
+/**
+ * This function gives the point of the moving least squares fit at the point `p`. The weight of a sample `q` is `exp(-|q-p|^2 / r^2)`.
+ * The angle term multiplies it by `1 - a + a |cos|`, with `cos` the cosine of the angle between the two tangents.
+ * The fit `line` gives the projection of `p` on the weighted line of the samples. The fit `parabola` fits `s = c0 + c1 t + c2 t^2` in the frame of that line.
+ * Without weight, the function gives `p`.
+ */
+export function mlsPoint(p: Point, t: { tx: number; ty: number }, near: readonly Sample[], r: number, angleWeight: number, fit: MlsFit): Point {
+  const a = Math.max(0, Math.min(1, angleWeight));
+  const ws: number[] = [];
+  let sw = 0;
+  let cx = 0;
+  let cy = 0;
+  for (const s of near) {
+    const d2 = (s.p.x - p.x) ** 2 + (s.p.y - p.y) ** 2;
+    const w = Math.exp(-d2 / (r * r)) * (1 - a + a * Math.abs(s.tx * t.tx + s.ty * t.ty));
+    ws.push(w);
+    sw += w;
+    cx += w * s.p.x;
+    cy += w * s.p.y;
+  }
+  if (sw <= 1e-12) return p;
+  cx /= sw;
+  cy /= sw;
+  let sxx = 0;
+  let syy = 0;
+  let sxy = 0;
+  near.forEach((s, i) => {
+    const w = ws[i]!;
+    sxx += w * (s.p.x - cx) ** 2;
+    syy += w * (s.p.y - cy) ** 2;
+    sxy += w * (s.p.x - cx) * (s.p.y - cy);
+  });
+  const theta = 0.5 * Math.atan2(2 * sxy, sxx - syy);
+  const ux = Math.cos(theta);
+  const uy = Math.sin(theta);
+  const tp = (p.x - cx) * ux + (p.y - cy) * uy;
+  if (fit === "line") return { x: cx + tp * ux, y: cy + tp * uy };
+  // The parabola: the normal equations of the weighted least squares in the frame (u, n), with n = (-uy, ux).
+  const m = [0, 0, 0, 0, 0];
+  const v = [0, 0, 0];
+  near.forEach((s, i) => {
+    const w = ws[i]!;
+    const tq = (s.p.x - cx) * ux + (s.p.y - cy) * uy;
+    const sq = -(s.p.x - cx) * uy + (s.p.y - cy) * ux;
+    let pw = w;
+    for (let k = 0; k < 5; k++) {
+      m[k] = m[k]! + pw;
+      if (k < 3) v[k] = v[k]! + pw * sq;
+      pw *= tq;
+    }
+  });
+  const A = [
+    [m[0]!, m[1]!, m[2]!],
+    [m[1]!, m[2]!, m[3]!],
+    [m[2]!, m[3]!, m[4]!],
+  ];
+  const c = solve3(A, v);
+  if (!c) return { x: cx + tp * ux, y: cy + tp * uy };
+  const sp = c[0]! + c[1]! * tp + c[2]! * tp * tp;
+  return { x: cx + tp * ux - sp * uy, y: cy + tp * uy + sp * ux };
+}
+
+/** This function solves a system of three linear equations by Cramer's rule. A system without one solution gives `undefined`. */
+function solve3(A: readonly (readonly number[])[], b: readonly number[]): number[] | undefined {
+  const det = (m: readonly (readonly number[])[]): number =>
+    m[0]![0]! * (m[1]![1]! * m[2]![2]! - m[1]![2]! * m[2]![1]!) - m[0]![1]! * (m[1]![0]! * m[2]![2]! - m[1]![2]! * m[2]![0]!) + m[0]![2]! * (m[1]![0]! * m[2]![1]! - m[1]![1]! * m[2]![0]!);
+  const d = det(A);
+  const scale = Math.abs(A[0]![0]!) * Math.abs(A[1]![1]!) * Math.abs(A[2]![2]!);
+  if (!Number.isFinite(d) || Math.abs(d) <= 1e-12 * Math.max(1, scale)) return undefined;
+  return [0, 1, 2].map((k) => det(A.map((row, i) => row.map((x, j) => (j === k ? b[i]! : x)))) / d);
+}
+
+/**
+ * This function gives the polylines of the moving least squares bundling (MLSEB, Wu, Zeng, Zhu and Yu 2017). The ends of each polyline stay.
+ * In each step, each inner point moves to the local fit of the samples of all edges within the radius. Then the radius shrinks by `decay`.
+ * A move is at most the radius. A point in a box moves out of it.
+ */
+export function mlsebLines(input: HighwayInput, finder: WayFinder, o: Readonly<MlsebOptions>): Map<string, Point[]> {
+  const plugs = edgePlugs(input.graph);
+  const out = new Map<string, Point[]>();
+  if (plugs.length === 0) return out;
+  const routes = o.source === "routes" ? firstRoutes(input) : undefined;
+  const spacing = Math.max(1e-3, o.spacing);
+  let lines: Point[][] = plugs.map(({ edge, ps, pt }) => {
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    const route = routes?.get(edge.id);
+    const base = route && route.length > 2 ? [a, ...route.slice(1, -1), b] : [a, b];
+    let len = 0;
+    for (let i = 1; i < base.length; i++) len += dist(base[i - 1]!, base[i]!);
+    return resample(base, Math.max(2, Math.min(129, Math.ceil(len / spacing) + 1)));
+  });
+  const pad = finder.margin / 2;
+  let r = Math.max(1e-3, o.radius * boardUnit(input.graph));
+  for (let step = 0; step < Math.max(0, Math.round(o.steps)); step++) {
+    // The grid of the samples, with cells of side `r`. A sample within `2 r` is in the 5 by 5 cells around a point.
+    const grid = new Map<string, Sample[]>();
+    const cellOf = (p: Point): [number, number] => [Math.floor(p.x / r), Math.floor(p.y / r)];
+    for (const l of lines)
+      l.forEach((p, i) => {
+        const [gx, gy] = cellOf(p);
+        const k = `${gx},${gy}`;
+        const s = { p, ...tangent(l, i) };
+        const list = grid.get(k);
+        if (list) list.push(s);
+        else grid.set(k, [s]);
+      });
+    const reach = 2 * r;
+    lines = lines.map((l) =>
+      l.map((p, i) => {
+        if (i === 0 || i === l.length - 1) return p;
+        const [gx, gy] = cellOf(p);
+        const near: Sample[] = [];
+        for (let dy = -2; dy <= 2; dy++)
+          for (let dx = -2; dx <= 2; dx++) for (const s of grid.get(`${gx + dx},${gy + dy}`) ?? []) if (dist(s.p, p) <= reach) near.push(s);
+        let q = mlsPoint(p, tangent(l, i), near, r, o.angleWeight, o.fit);
+        const d = dist(p, q);
+        if (d > r) q = { x: p.x + ((q.x - p.x) * r) / d, y: p.y + ((q.y - p.y) * r) / d };
+        return outOfBoxes(finder.obstacles, q, pad);
+      }),
+    );
+    r *= Math.max(0, Math.min(1, o.decay));
+    if (r <= 1e-3) break;
+  }
+  plugs.forEach(({ edge }, e) => out.set(edge.id, lines[e]!));
+  return out;
+}
+
+/**
+ * This function gives the highways of the moving least squares bundling (HWY-008). The points of `mlsebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export function mlsebPlan(input: HighwayInput, o: Readonly<MlsebOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const lines = mlsebLines(input, finder, o);
+  const waypoints = new Map([...lines].map(([edge, l]) => [edge, l.slice(1, -1)] as const));
+  return tracePlan(input, finder, waypoints, { snap: o.snap, minSize: o.minSize, key: "mlseb" });
+}

package/src/highways/p-hub/index.ts

@@ -0,0 +1,248 @@
+import { center, dist, polylineLength, type Point } from "../../geom.ts";
+import { buildSections, type Section } from "../../sections.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { snapPlan, type SnapLine, type SnapMember } from "../snap.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The allocation of the edges to the hubs: `single` (each node to its nearest hub) or `multiple` (each edge to its best pair of hubs). */
+export type HubAllocation = "single" | "multiple";
+
+/** The values of `HubAllocation`. */
+export const HUB_ALLOCATIONS: readonly HubAllocation[] = Object.freeze(["single", "multiple"]);
+
+/** The candidate points of the hubs: the corners of the corner graph, or the centres of the cells of the tree of sections. */
+export type HubCandidates = "corners" | "sections";
+
+/** The values of `HubCandidates`. */
+export const HUB_CANDIDATES: readonly HubCandidates[] = Object.freeze(["corners", "sections"]);
+
+/** The options of the highway strategy `p-hub` (HWY-041 of the note on highways). */
+export interface PHubOptions {
+  /** The number of hubs. The value 0 gives the root of the number of nodes, rounded. The default is 0. */
+  readonly p: number;
+  /** The cost of a length on a link between two hubs against a length off the links, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** The allocation of the edges to the hubs. The default is `single`. */
+  readonly allocation: HubAllocation;
+  /** The candidate points of the hubs. The default is `corners`. */
+  readonly candidates: HubCandidates;
+  /** An edge rides a link only when its way through the two hubs is this many times its first route or less. The default is 1.25. */
+  readonly detour: number;
+  /** The number of passes of the local search with one swap of a hub. The default is 1. */
+  readonly swaps: number;
+  /** A link with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `p-hub`. */
+export const P_HUB_DEFAULTS: Readonly<PHubOptions> = Object.freeze({ p: 0, alpha: 0.5, allocation: "single", candidates: "corners", detour: 1.25, swaps: 1, minSize: 2 });
+
+/** The largest number of candidate points. A larger set keeps each `k`-th point. */
+const MAX_CANDIDATES = 300;
+
+/** One edge for the hub location: its two plug points, the centres of its two nodes, and the length of its first route. */
+interface HubEdge {
+  readonly edge: string;
+  readonly s: Point;
+  readonly t: Point;
+  readonly u: string;
+  readonly v: string;
+  readonly base: number;
+}
+
+/** This function gives the centres of the cells of each section of the tree. */
+function sectionCentres(root: Section): Point[] {
+  const out: Point[] = [];
+  const walk = (s: Section): void => {
+    out.push(center(s.cell));
+    s.children.forEach(walk);
+  };
+  walk(root);
+  return out;
+}
+
+/** This function gives the candidate points of the hubs, at most `MAX_CANDIDATES`, without the copies. */
+export function hubCandidates(input: HighwayInput, candidates: HubCandidates): Point[] {
+  const raw = candidates === "sections" ? sectionCentres(buildSections(input.graph.nodes)) : [...new WayFinder(input.graph.nodes).corners.points];
+  const seen = new Set<string>();
+  const points = raw.filter((p) => {
+    const key = `${Math.round(p.x)},${Math.round(p.y)}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (points.length <= MAX_CANDIDATES) return points;
+  const k = Math.ceil(points.length / MAX_CANDIDATES);
+  return points.filter((_, i) => i % k === 0);
+}
+
+/**
+ * This function chooses `p` points of `candidates` as the p-median of `points`. The greedy step adds the candidate that lowers the sum of the distances most.
+ * Then at most 4 passes of swaps lower the sum more. The result is the indices of the chosen candidates.
+ */
+export function pMedian(points: readonly Point[], candidates: readonly Point[], p: number): number[] {
+  const chosen: number[] = [];
+  const near = points.map(() => Infinity);
+  while (chosen.length < Math.min(p, candidates.length)) {
+    let pick = -1;
+    let best = Infinity;
+    for (let c = 0; c < candidates.length; c++) {
+      if (chosen.includes(c)) continue;
+      let sum = 0;
+      for (let i = 0; i < points.length; i++) sum += Math.min(near[i]!, dist(points[i]!, candidates[c]!));
+      if (sum < best - 1e-9) [best, pick] = [sum, c];
+    }
+    if (pick < 0) break;
+    chosen.push(pick);
+    points.forEach((q, i) => {
+      near[i] = Math.min(near[i]!, dist(q, candidates[pick]!));
+    });
+  }
+  // The swaps of Teitz and Bart: one chosen candidate changes for one other candidate while the sum falls.
+  // The nearest and the second nearest chosen candidate of each point give the sum after a swap in one pass over the points.
+  const d = candidates.map((c) => points.map((q) => dist(q, c)));
+  let first: number[] = [];
+  let second: number[] = [];
+  const nearTwo = (): void => {
+    first = points.map(() => -1);
+    second = points.map(() => -1);
+    points.forEach((_, p) => {
+      chosen.forEach((_, j) => {
+        const v = d[chosen[j]!]![p]!;
+        if (first[p]! < 0 || v < d[chosen[first[p]!]!]![p]!) [second[p], first[p]] = [first[p]!, j];
+        else if (second[p]! < 0 || v < d[chosen[second[p]!]!]![p]!) second[p] = j;
+      });
+    });
+  };
+  const at = (j: number, p: number): number => (j < 0 ? Infinity : d[chosen[j]!]![p]!);
+  nearTwo();
+  let sum = points.reduce((s, _, p) => s + at(first[p]!, p), 0);
+  for (let pass = 0; pass < 4; pass++) {
+    let better = false;
+    for (let i = 0; i < chosen.length; i++)
+      for (let c = 0; c < candidates.length; c++) {
+        if (chosen.includes(c)) continue;
+        let v = 0;
+        for (let p = 0; p < points.length; p++) v += Math.min(d[c]![p]!, first[p] === i ? at(second[p]!, p) : at(first[p]!, p));
+        if (v < sum - 1e-9) {
+          [sum, better] = [v, true];
+          chosen[i] = c;
+          nearTwo();
+        }
+      }
+    if (!better) break;
+  }
+  return chosen;
+}
+
+/** The two hubs of one edge, and its cost and its length on them. */
+interface HubTrip {
+  readonly h: number;
+  readonly k: number;
+  readonly cost: number;
+}
+
+/**
+ * This function gives the trip of each edge through the hubs `hubs`, or `undefined` for an edge that does not ride.
+ * The cost of a trip is `d(s, h) + alpha d(h, k) + d(k, t)`. An edge rides only when `h` and `k` differ and the cost is below its first route.
+ * Also, its length `d(s, h) + d(h, k) + d(k, t)` must be `detour` times its first route or less.
+ */
+function hubTrips(edges: readonly HubEdge[], nodes: ReadonlyMap<string, Point>, hubs: readonly Point[], o: Readonly<PHubOptions>): (HubTrip | undefined)[] {
+  const nearest = (p: Point): number => {
+    let best = 0;
+    for (let i = 1; i < hubs.length; i++) if (dist(p, hubs[i]!) < dist(p, hubs[best]!)) best = i;
+    return best;
+  };
+  const home = new Map<string, number>();
+  for (const [id, c] of nodes) home.set(id, nearest(c));
+  return edges.map((e) => {
+    const trip = (h: number, k: number): HubTrip | undefined => {
+      if (h === k) return undefined;
+      const a = dist(e.s, hubs[h]!);
+      const m = dist(hubs[h]!, hubs[k]!);
+      const b = dist(hubs[k]!, e.t);
+      const cost = a + o.alpha * m + b;
+      if (cost >= e.base || a + m + b > o.detour * e.base) return undefined;
+      return { h, k, cost };
+    };
+    if (o.allocation === "single") return trip(home.get(e.u)!, home.get(e.v)!);
+    let best: HubTrip | undefined;
+    for (let h = 0; h < hubs.length; h++)
+      for (let k = 0; k < hubs.length; k++) {
+        const t = trip(h, k);
+        if (t && (!best || t.cost < best.cost - 1e-9)) best = t;
+      }
+    return best;
+  });
+}
+
+/** This function gives the total cost of the edges: the cost of each trip, or the first route of an edge that does not ride. */
+function totalCost(edges: readonly HubEdge[], trips: readonly (HubTrip | undefined)[]): number {
+  return edges.reduce((s, e, i) => s + (trips[i]?.cost ?? e.base), 0);
+}
+
+/**
+ * This function gives the highways of the hub location (HWY-041, the p-hub median of O'Kelly 1987). The p-median of the plugs chooses `p` hubs from the candidates.
+ * Each swap pass changes one hub for one other candidate while the total cost falls. Each link between two hubs with `minSize` edges or more is a highway.
+ * The edges that ride a link snap to it, from their first hub to their second hub.
+ */
+export function pHubPlan(input: HighwayInput, o: Readonly<PHubOptions>): HighwayPlan {
+  const graph = input.graph;
+  if (graph.nodes.length === 0) return { highways: [] };
+  const routes = firstRoutes(input);
+  const edges: HubEdge[] = edgePlugs(graph).map(({ edge, ps, pt }) => {
+    const first = routes.get(edge.id);
+    return { edge: edge.id, s: ps.point, t: pt.point, u: edge.source.node, v: edge.target.node, base: first ? polylineLength(first) : dist(ps.point, pt.point) };
+  });
+  const nodes = new Map(graph.nodes.map((n) => [n.id, center(n.box)] as const));
+  const candidates = hubCandidates(input, o.candidates);
+  const p = Math.round(o.p) > 0 ? Math.round(o.p) : Math.max(2, Math.round(Math.sqrt(graph.nodes.length)));
+  if (candidates.length < 2 || edges.length === 0) return { highways: [] };
+  const chosen = pMedian(
+    edges.flatMap((e) => [e.s, e.t]),
+    candidates,
+    p,
+  );
+  const hubsOf = (list: readonly number[]): Point[] => list.map((c) => candidates[c]!);
+  let trips = hubTrips(edges, nodes, hubsOf(chosen), o);
+  let cost = totalCost(edges, trips);
+  for (let pass = 0; pass < Math.max(0, Math.round(o.swaps)); pass++) {
+    let better = false;
+    for (let i = 0; i < chosen.length; i++) {
+      let pick = -1;
+      let pickTrips = trips;
+      for (let c = 0; c < candidates.length; c++) {
+        if (chosen.includes(c)) continue;
+        const next = chosen.map((x, j) => (j === i ? c : x));
+        const t = hubTrips(edges, nodes, hubsOf(next), o);
+        const v = totalCost(edges, t);
+        if (v < cost - 1e-9) [cost, pick, pickTrips] = [v, c, t];
+      }
+      if (pick >= 0) {
+        chosen[i] = pick;
+        trips = pickTrips;
+        better = true;
+      }
+    }
+    if (!better) break;
+  }
+  const hubs = hubsOf(chosen);
+  const links = new Map<string, { a: number; b: number; members: SnapMember[] }>();
+  edges.forEach((e, i) => {
+    const t = trips[i];
+    if (!t) return;
+    const [a, b] = t.h < t.k ? [t.h, t.k] : [t.k, t.h];
+    const key = `${a}:${b}`;
+    const link = links.get(key) ?? { a, b, members: [] };
+    link.members.push({ edge: e.edge, from: hubs[t.h]!, to: hubs[t.k]!, at: 0 });
+    links.set(key, link);
+  });
+  const min = Math.max(2, Math.round(o.minSize));
+  const lines: SnapLine[] = [...links.values()]
+    .filter((l) => l.members.length >= min)
+    .sort((x, y) => x.a - y.a || x.b - y.b)
+    .map((l) => ({ key: `hub${l.a}-${l.b}`, a: hubs[l.a]!, b: hubs[l.b]!, members: l.members }));
+  return snapPlan(input, lines, { minSize: min });
+}