@mark1russell7/highways 0.4.2 → 0.5.0

package/src/highways/growth/index.ts

@@ -0,0 +1,148 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes, nearestPlace, tidyPlan } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The order of the edges in the growth: the longest first route first, or the order of the graph. */
+export type GrowthOrder = "length" | "input";
+
+/** The options of the highway strategy `growth` (HWY-055 of the note on highways). */
+export interface GrowthOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The order of the edges. The default is `length`. */
+  readonly order: GrowthOrder;
+  /** The cost of the part on a spine, as a share of its length. The ramps cost their full length. The default is 0.5. */
+  readonly share: number;
+  /** An edge joins a highway only when its way along it is this value times its first route or shorter. The default is 1.3. */
+  readonly stretch: number;
+  /** A spine end extends when this number of its lanes or more go on together. The default is 3. */
+  readonly extendLanes: number;
+  /** The lanes go on together when their ends are this distance from their center or nearer, in units of the board. The default is 2. */
+  readonly extendRadius: number;
+  /** A highway with this number of edges or more stays in the plan. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `growth`. */
+export const GROWTH_DEFAULTS: Readonly<GrowthOptions> = Object.freeze({ order: "length", share: 0.5, stretch: 1.3, extendLanes: 3, extendRadius: 2, minSize: 2 });
+
+interface Grown {
+  spine: Point[];
+  members: { edge: string; on: number; off: number }[];
+}
+
+interface Rider {
+  readonly edge: string;
+  readonly ps: Point;
+  readonly pt: Point;
+  readonly a: Point;
+  readonly b: Point;
+  readonly len: number;
+}
+
+/**
+ * This function gives the highways of local growth (HWY-055). The edges come one by one, by default the longest first route first.
+ * Each edge joins the highway with the largest saving: its first route less its ramps and `share` of its part on the spine. Without a saving, the edge starts a highway on its own way.
+ * After the growth, a spine end can go on to the center of the far ends of its lanes.
+ * This occurs when `extendLanes` of them or more are near that center and the line is clear.
+ */
+export function growthPlan(input: HighwayInput, o: Readonly<GrowthOptions>): HighwayPlan {
+  const graph = input.graph;
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const pad = finder.margin / 2;
+  const routes = firstRoutes(input);
+  const riders: Rider[] = edgePlugs(graph).map(({ edge, ps, pt }) => {
+    const route = routes.get(edge.id);
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    return { edge: edge.id, ps: ps.point, pt: pt.point, a, b, len: route ? polylineLength(route) : dist(ps.point, pt.point) };
+  });
+  if (o.order === "length") riders.sort((p, q) => q.len - p.len || (p.edge < q.edge ? -1 : p.edge > q.edge ? 1 : 0));
+  const grown: Grown[] = [];
+  const short = finder.margin;
+  for (const r of riders) {
+    let best = -1;
+    let bestSave = 0;
+    let bestOn = 0;
+    let bestOff = 0;
+    grown.forEach((h, hi) => {
+      const on = nearestPlace(h.spine, r.a);
+      const off = nearestPlace(h.spine, r.b);
+      const part = lengthBetween(h.spine, Math.min(on, off), Math.max(on, off));
+      if (part <= short) return;
+      const ramps = dist(r.a, pointAt(h.spine, on)) + dist(pointAt(h.spine, off), r.b);
+      if (ramps + part > o.stretch * r.len) return;
+      const save = r.len - (ramps + o.share * part);
+      if (save > bestSave) [best, bestSave, bestOn, bestOff] = [hi, save, on, off];
+    });
+    if (best >= 0) {
+      grown[best]!.members.push({ edge: r.edge, on: bestOn, off: bestOff });
+      continue;
+    }
+    const raw = finder.corners.path(r.a, r.b);
+    if (!raw) continue;
+    const spine = finder.corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= short) continue;
+    grown.push({ spine, members: [{ edge: r.edge, on: 0, off: spine.length - 1 }] });
+  }
+
+  // A spine end goes on while enough of its lanes go on together.
+  const byEdge = new Map(riders.map((r) => [r.edge, r]));
+  const radius = o.extendRadius * boardUnit(graph);
+  const need = Math.max(2, Math.round(o.extendLanes));
+  for (const h of grown) {
+    for (const end of ["first", "last"] as const) {
+      const last = h.spine.length - 1;
+      const at = end === "first" ? 0 : last;
+      // The far point of each lane at this end: the point out of the plug that the lane goes to or comes from.
+      const far: { m: Grown["members"][number]; side: "on" | "off"; p: Point }[] = [];
+      for (const m of h.members) {
+        const r = byEdge.get(m.edge)!;
+        if (m.on === at) far.push({ m, side: "on", p: r.a });
+        else if (m.off === at) far.push({ m, side: "off", p: r.b });
+      }
+      if (far.length < need) continue;
+      const c = { x: far.reduce((s, f) => s + f.p.x, 0) / far.length, y: far.reduce((s, f) => s + f.p.y, 0) / far.length };
+      const near = far.filter((f) => dist(f.p, c) <= radius);
+      const tip = h.spine[at]!;
+      if (near.length < need || dist(tip, c) <= short) continue;
+      if (finder.obstacles.inside(c, pad) || !finder.obstacles.clear(tip, c, pad)) continue;
+      if (end === "first") {
+        h.spine.unshift(c);
+        for (const m of h.members) [m.on, m.off] = [m.on + 1, m.off + 1];
+        for (const f of near) f.m[f.side] = 0;
+      } else {
+        h.spine.push(c);
+        for (const f of near) f.m[f.side] = last + 1;
+      }
+    }
+  }
+
+  const highways: Highway[] = [];
+  grown.forEach((h, hi) => {
+    if (h.members.length < Math.max(2, o.minSize)) return;
+    const spine = h.spine;
+    const back = [...spine].reverse();
+    const lanes = orderLanes(
+      spine,
+      h.members.map((m) => {
+        const r = byEdge.get(m.edge)!;
+        return { edge: m.edge, points: m.on <= m.off ? [r.ps, r.a, ...spine, r.b, r.pt] : [r.ps, r.a, ...back, r.b, r.pt] };
+      }),
+      "bundle",
+    );
+    const byLane = new Map(h.members.map((m) => [m.edge, m]));
+    const members: HighwayMember[] = lanes.map((edge) => {
+      const m = byLane.get(edge)!;
+      return memberAt(spine, edge, m.on, m.off);
+    });
+    highways.push({ id: `h${hi}`, key: `g${hi}`, spine, lanes, members });
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/hdbscan/index.ts

@@ -0,0 +1,250 @@
+import { dist, type Point } from "../../geom.ts";
+import { flowDistance } from "../flow-clusters/index.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The distance of two edges: 1 less their compatibility of FDEB, or the flow distance in 4D of HWY-023. */
+export type EdgeDistance = "compatibility" | "flow";
+
+/** The values of `EdgeDistance`. */
+export const EDGE_DISTANCES: readonly EdgeDistance[] = Object.freeze(["compatibility", "flow"]);
+
+/** The options of the highway strategy `hdbscan` (HWY-028 of the note on highways). */
+export interface HdbscanOptions {
+  /** A cluster has this number of edges or more. The default is 3. */
+  readonly minClusterSize: number;
+  /** The core distance of an edge is the distance to its neighbour of this rank. The default is 3. */
+  readonly minSamples: number;
+  /** The distance of two edges. The default is `compatibility`. */
+  readonly distance: EdgeDistance;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `hdbscan`. */
+export const HDBSCAN_DEFAULTS: Readonly<HdbscanOptions> = Object.freeze({ minClusterSize: 3, minSamples: 3, distance: "compatibility", spine: "trunk" });
+
+/** The largest number of edges in one distance matrix. A larger graph splits into blocks of edges in the order of their sources. */
+const BLOCK = 2500;
+
+/**
+ * This function gives the compatibility of two edges of FDEB (Holten and van Wijk 2009): `Ca Cs Cp Cv`, from 0 to 1.
+ * `Ca` is the angle, `Cs` the scale, `Cp` the position and `Cv` the visibility. The direction of an edge does not change the value.
+ */
+export function compatibility(p0: Point, p1: Point, q0: Point, q1: Point): number {
+  const lp = dist(p0, p1);
+  const lq = dist(q0, q1);
+  if (lp <= 1e-9 || lq <= 1e-9) return 0;
+  const ca = Math.abs(((p1.x - p0.x) * (q1.x - q0.x) + (p1.y - p0.y) * (q1.y - q0.y)) / (lp * lq));
+  const avg = (lp + lq) / 2;
+  const cs = 2 / (avg / Math.min(lp, lq) + Math.max(lp, lq) / avg);
+  const pm = { x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2 };
+  const qm = { x: (q0.x + q1.x) / 2, y: (q0.y + q1.y) / 2 };
+  const cp = avg / (avg + dist(pm, qm));
+  const cv = Math.min(visibility(p0, p1, q0, q1), visibility(q0, q1, p0, p1));
+  return ca * cs * cp * cv;
+}
+
+/** This function gives the visibility of the edge `q` from the edge `p` of FDEB: `max(1 - 2 |pm - im| / |i0 i1|, 0)`. The points `i` are the projection of `q` on the line of `p`. */
+function visibility(p0: Point, p1: Point, q0: Point, q1: Point): number {
+  const dx = p1.x - p0.x;
+  const dy = p1.y - p0.y;
+  const l2 = dx * dx + dy * dy;
+  const project = (q: Point): Point => {
+    const u = ((q.x - p0.x) * dx + (q.y - p0.y) * dy) / l2;
+    return { x: p0.x + u * dx, y: p0.y + u * dy };
+  };
+  const i0 = project(q0);
+  const i1 = project(q1);
+  const span = dist(i0, i1);
+  if (span <= 1e-9) return 0;
+  const im = { x: (i0.x + i1.x) / 2, y: (i0.y + i1.y) / 2 };
+  const pm = { x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2 };
+  return Math.max(1 - (2 * dist(pm, im)) / span, 0);
+}
+
+/**
+ * This function gives the HDBSCAN clusters of the points of a distance matrix (Campello, Moulavi and Sander 2013). The value -1 is noise.
+ * The core distance of a point is the distance to its `minSamples`-th nearest point. The mutual reachability is `max(core(a), core(b), d(a, b))`.
+ * The minimum spanning tree of the mutual reachability gives the tree of the clusters. A split with two parts of `minClusterSize` or more gives two clusters.
+ * The selection keeps the clusters with the largest stability, `sum (lambda_leave - lambda_birth)`, with `lambda = 1 / distance`. The root is not a cluster.
+ */
+export function hdbscanLabels(n: number, d: Float64Array, minClusterSize: number, minSamples: number): Int32Array {
+  const labels = new Int32Array(n).fill(-1);
+  const mcs = Math.max(2, Math.round(minClusterSize));
+  if (n < mcs || n < 2) return labels;
+  const k = Math.max(1, Math.min(n - 1, Math.round(minSamples)));
+  // The core distance of each point.
+  const core = new Float64Array(n);
+  const row = new Float64Array(n - 1);
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let j = 0; j < n; j++) if (j !== i) row[c++] = d[i * n + j]!;
+    row.sort();
+    core[i] = row[k - 1]!;
+  }
+  const reach = (i: number, j: number): number => Math.max(core[i]!, core[j]!, d[i * n + j]!);
+  // The minimum spanning tree (Prim), with ties to the lower index.
+  const inTree = new Uint8Array(n);
+  const best = new Float64Array(n).fill(Infinity);
+  const from = new Int32Array(n).fill(-1);
+  const links: { a: number; b: number; w: number }[] = [];
+  let cur = 0;
+  inTree[0] = 1;
+  for (let step = 1; step < n; step++) {
+    let next = -1;
+    for (let j = 0; j < n; j++) {
+      if (inTree[j]) continue;
+      const w = reach(cur, j);
+      if (w < best[j]!) [best[j], from[j]] = [w, cur];
+      if (next < 0 || best[j]! < best[next]!) next = j;
+    }
+    inTree[next] = 1;
+    links.push({ a: from[next]!, b: next, w: best[next]! });
+    cur = next;
+  }
+  links.sort((p, q) => p.w - q.w || p.a - q.a || p.b - q.b);
+  // The single linkage tree: the node `n + i` is the merge `i`.
+  const parent = new Int32Array(2 * n - 1).fill(-1);
+  const left = new Int32Array(n - 1);
+  const right = new Int32Array(n - 1);
+  const height = new Float64Array(n - 1);
+  const size = new Int32Array(2 * n - 1).fill(1);
+  const uf = new Int32Array(2 * n - 1);
+  for (let i = 0; i < uf.length; i++) uf[i] = i;
+  const find = (i: number): number => {
+    while (uf[i] !== i) i = uf[i] = uf[uf[i]!]!;
+    return i;
+  };
+  links.forEach((l, i) => {
+    const ra = find(l.a);
+    const rb = find(l.b);
+    const node = n + i;
+    left[i] = ra;
+    right[i] = rb;
+    height[i] = l.w;
+    size[node] = size[ra]! + size[rb]!;
+    parent[ra] = node;
+    parent[rb] = node;
+    uf[ra] = node;
+    uf[rb] = node;
+  });
+  const root = 2 * n - 2;
+  const lambdaOf = (h: number): number => 1 / Math.max(h, 1e-9);
+  const leaves = (node: number): number[] => {
+    const out: number[] = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const x = stack.pop()!;
+      if (x < n) out.push(x);
+      else stack.push(left[x - n]!, right[x - n]!);
+    }
+    return out;
+  };
+  // The condensed tree. Each cluster has a birth lambda, a parent cluster, its stability and the points that leave it at their lambda.
+  const birth: number[] = [0];
+  const up: number[] = [-1];
+  const stability: number[] = [0];
+  const fall = new Int32Array(n).fill(0);
+  const queue: [node: number, cluster: number][] = [[root, 0]];
+  while (queue.length > 0) {
+    const [node, c] = queue.shift()!;
+    const i = node - n;
+    const lambda = lambdaOf(height[i]!);
+    const kids = [left[i]!, right[i]!];
+    const big = kids.filter((x) => size[x]! >= mcs);
+    if (big.length === 2) {
+      for (const x of kids) {
+        const id = birth.length;
+        birth.push(lambda);
+        up.push(c);
+        stability.push(0);
+        stability[c] = stability[c]! + size[x]! * (lambda - birth[c]!);
+        queue.push([x, id]);
+      }
+      continue;
+    }
+    for (const x of kids) {
+      if (big.includes(x)) {
+        if (x >= n) queue.push([x, c]);
+        else {
+          fall[x] = c;
+          stability[c] = stability[c]! + (lambda - birth[c]!);
+        }
+        continue;
+      }
+      for (const p of leaves(x)) {
+        fall[p] = c;
+        stability[c] = stability[c]! + (lambda - birth[c]!);
+      }
+    }
+  }
+  // The selection by the excess of mass, from the last cluster to the first. A child cluster always has a larger id than its parent.
+  const count = birth.length;
+  const chosen = new Uint8Array(count);
+  const value = [...stability];
+  const children: number[][] = Array.from({ length: count }, () => []);
+  for (let c = 1; c < count; c++) children[up[c]!]!.push(c);
+  for (let c = count - 1; c >= 1; c--) {
+    const sub = children[c]!.reduce((s, x) => s + value[x]!, 0);
+    if (children[c]!.length > 0 && sub > value[c]!) value[c] = sub;
+    else {
+      chosen[c] = 1;
+      const stack = [...children[c]!];
+      while (stack.length > 0) {
+        const x = stack.pop()!;
+        chosen[x] = 0;
+        stack.push(...children[x]!);
+      }
+    }
+  }
+  for (let p = 0; p < n; p++) {
+    let c = fall[p]!;
+    while (c > 0 && !chosen[c]) c = up[c]!;
+    labels[p] = c > 0 ? c : -1;
+  }
+  return labels;
+}
+
+/**
+ * This function gives the HDBSCAN clusters of the edges (HWY-028). The edges that are noise get no group.
+ * Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export function hdbscanClusters(input: HighwayInput, o: Readonly<HdbscanOptions>): Map<string, EdgeGroup> {
+  const ends = edgePlugs(input.graph).map(({ edge, ps, pt }) => ({ edge: edge.id, s: ps.point, t: pt.point }));
+  const groups = new Map<string, EdgeGroup>();
+  const order = ends.length > BLOCK ? [...ends].sort((a, b) => a.s.x - b.s.x || a.s.y - b.s.y || (a.edge < b.edge ? -1 : 1)) : ends;
+  const between = (a: (typeof ends)[number], b: (typeof ends)[number]): number =>
+    o.distance === "flow" ? flowDistance(a.s, a.t, b.s, b.t, false).d : 1 - compatibility(a.s, a.t, b.s, b.t);
+  for (let from = 0; from < order.length; from += BLOCK) {
+    const block = order.slice(from, from + BLOCK);
+    const n = block.length;
+    const d = new Float64Array(n * n);
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++) {
+        const v = between(block[i]!, block[j]!);
+        d[i * n + j] = v;
+        d[j * n + i] = v;
+      }
+    const labels = hdbscanLabels(n, d, o.minClusterSize, o.minSamples);
+    const lead = new Map<number, number>();
+    block.forEach((e, i) => {
+      const c = labels[i]!;
+      if (c < 0) return;
+      if (!lead.has(c)) lead.set(c, i);
+      const l = block[lead.get(c)!]!;
+      const flip = (e.t.x - e.s.x) * (l.t.x - l.s.x) + (e.t.y - e.s.y) * (l.t.y - l.s.y) < 0;
+      groups.set(e.edge, { key: `c${from}:${c}`, flip });
+    });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of the HDBSCAN clusters (HWY-028). The clusters that live over a long range of densities are the highways.
+ * The number of highways is not fixed, and the noise edges stay alone.
+ */
+export function hdbscanPlan(input: HighwayInput, o: Readonly<HdbscanOptions>): HighwayPlan {
+  return groupedPlan(input, hdbscanClusters(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minClusterSize)) });
+}

package/src/highways/hough/index.ts

@@ -0,0 +1,182 @@
+import { dist, type Point } from "../../geom.ts";
+import type { WayOptions } from "../../ways.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { linePoint, snapPlan, type SnapLine } from "../snap.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `hough` (HWY-024 of the note on highways). */
+export interface HoughOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The width of the votes in the angle, in degrees. An edge joins a peak within this angle. The default is 8. */
+  readonly dTheta: number;
+  /** The width of the votes in the offset, in units of the board. An edge joins a peak when its middle is this near to the line. The default is 12. */
+  readonly dRho: number;
+  /** A peak with fewer edges than this number is not a corridor. The default is 3. */
+  readonly minVotes: number;
+  /** With `true`, the peaks are only horizontal or vertical lines. The default is `false`. */
+  readonly orthogonal: boolean;
+}
+
+/** The default options of the strategy `hough`. */
+export const HOUGH_DEFAULTS: Readonly<Required<Omit<HoughOptions, "margin" | "k">>> = Object.freeze({ dTheta: 8, dRho: 12, minVotes: 3, orthogonal: false });
+
+/** The line of one edge: its direction angle from 0 to pi, its offset along the normal, its middle and its ends. */
+interface EdgeLine {
+  readonly edge: string;
+  readonly theta: number;
+  readonly s: Point;
+  readonly t: Point;
+  readonly mid: Point;
+  readonly len: number;
+}
+
+/** A peak of the votes: its angle, its offset and the sum of its votes. */
+export interface HoughPeak {
+  readonly theta: number;
+  readonly rho: number;
+  readonly votes: number;
+}
+
+const DEG = Math.PI / 180;
+
+/** This function gives the offset of a point from the line through the origin with the direction angle `theta`. */
+const offsetOf = (p: Point, theta: number): number => -p.x * Math.sin(theta) + p.y * Math.cos(theta);
+
+/** This function gives the place of a point along the direction angle `theta`. */
+const placeOf = (p: Point, theta: number): number => p.x * Math.cos(theta) + p.y * Math.sin(theta);
+
+/** This function gives the difference of two direction angles, from 0 to pi / 2. */
+function angleGap(a: number, b: number): number {
+  const d = Math.abs(a - b) % Math.PI;
+  return Math.min(d, Math.PI - d);
+}
+
+/**
+ * This function gives the peaks of the votes of the lines (Duda and Hart 1972). Each line votes for its angle and its offset, with a weight of its length.
+ * A vote spreads as a Gaussian with the widths `dTheta / 2` and `dRho / 2`. The accumulator has bins of 1 degree and of `dRho / 4`.
+ * A peak is a bin with a larger sum than each other bin within `dTheta` and `dRho`. The peaks come in the order of their votes.
+ */
+export function houghPeaks(lines: readonly { theta: number; mid: Point; len: number }[], o: Readonly<Pick<HoughOptions, "dTheta" | "dRho" | "orthogonal">>): HoughPeak[] {
+  if (lines.length === 0) return [];
+  const thetas = o.orthogonal ? [0, 90] : Array.from({ length: 180 }, (_, i) => i);
+  const T = thetas.length;
+  const rhoStep = Math.max(1e-6, o.dRho / 4);
+  let maxRho = 0;
+  for (const l of lines) maxRho = Math.max(maxRho, Math.abs(l.mid.x) + Math.abs(l.mid.y));
+  const R = Math.ceil(maxRho / rhoStep) + 4;
+  const rows = 2 * R + 1;
+  const acc = new Float64Array(T * rows);
+  const wTheta = Math.max(1e-6, o.dTheta);
+  const sT = wTheta / 2;
+  const sR = o.dRho / 2;
+  const reachR = Math.ceil(o.dRho / rhoStep);
+  for (const l of lines) {
+    for (let ti = 0; ti < T; ti++) {
+      const gap = angleGap(thetas[ti]! * DEG, l.theta) / DEG;
+      if (gap > wTheta) continue;
+      const rho = offsetOf(l.mid, thetas[ti]! * DEG);
+      const center = Math.round(rho / rhoStep);
+      const wt = Math.exp(-(gap * gap) / (2 * sT * sT)) * l.len;
+      for (let r = center - reachR; r <= center + reachR; r++) {
+        if (r < -R || r > R) continue;
+        const dr = r * rhoStep - rho;
+        acc[ti * rows + r + R] = acc[ti * rows + r + R]! + wt * Math.exp(-(dr * dr) / (2 * sR * sR));
+      }
+    }
+  }
+  const reachT = o.orthogonal ? 0 : Math.ceil(wTheta);
+  const peaks: HoughPeak[] = [];
+  for (let ti = 0; ti < T; ti++)
+    for (let r = 0; r < rows; r++) {
+      const v = acc[ti * rows + r]!;
+      if (v <= 0) continue;
+      let top = true;
+      for (let dt = -reachT; dt <= reachT && top; dt++)
+        for (let dr = -reachR; dr <= reachR && top; dr++) {
+          if (dt === 0 && dr === 0) continue;
+          let tj = ti + dt;
+          let rj = r - R;
+          // The angle wraps at 180 degrees, and the offset changes its sign there.
+          if (tj < 0) [tj, rj] = [tj + T, -rj];
+          else if (tj >= T) [tj, rj] = [tj - T, -rj];
+          rj += dr;
+          if (rj < -R || rj > R) continue;
+          const w = acc[tj * rows + rj + R]!;
+          // A tie goes to the first bin in the order of the accumulator.
+          if (w > v || (w === v && tj * rows + rj + R < ti * rows + r)) top = false;
+        }
+      if (top) peaks.push({ theta: thetas[ti]! * DEG, rho: (r - R) * rhoStep, votes: v });
+    }
+  peaks.sort((a, b) => b.votes - a.votes || a.theta - b.theta || a.rho - b.rho);
+  return peaks;
+}
+
+/**
+ * This function gives the corridors of the votes (HWY-024). Each edge joins the first peak with an angle within `dTheta` and its middle within `dRho` of the line.
+ * The corridor runs over the common span of the projections of its edges on the line. Each edge snaps to the ends of that span.
+ * A member that makes the span shorter than four margins leaves, while the peak keeps `minVotes` edges.
+ */
+export function houghLines(input: HighwayInput, o: Readonly<HoughOptions>): SnapLine[] {
+  const margin = o.margin ?? 5;
+  const lines: EdgeLine[] = [];
+  for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+    const s = ps.point;
+    const t = pt.point;
+    const len = dist(s, t);
+    if (len <= 1e-9) continue;
+    const theta = (((Math.atan2(t.y - s.y, t.x - s.x) % Math.PI) + Math.PI) % Math.PI);
+    lines.push({ edge: edge.id, theta, s, t, mid: { x: (s.x + t.x) / 2, y: (s.y + t.y) / 2 }, len });
+  }
+  const peaks = houghPeaks(lines, o);
+  const taken = new Set<string>();
+  const out: SnapLine[] = [];
+  const need = Math.max(2, Math.round(o.minVotes));
+  for (const [pi, p] of peaks.entries()) {
+    let members = lines.filter((l) => !taken.has(l.edge) && angleGap(l.theta, p.theta) <= o.dTheta * DEG && Math.abs(offsetOf(l.mid, p.theta) - p.rho) <= o.dRho);
+    const span = (list: readonly EdgeLine[]): [number, number] => {
+      let lo = -Infinity;
+      let hi = Infinity;
+      for (const l of list) {
+        const a = placeOf(l.s, p.theta);
+        const b = placeOf(l.t, p.theta);
+        lo = Math.max(lo, Math.min(a, b));
+        hi = Math.min(hi, Math.max(a, b));
+      }
+      return [lo, hi];
+    };
+    let [lo, hi] = span(members);
+    while (members.length >= need && hi - lo < 4 * margin) {
+      // The member that limits the span the most leaves.
+      let best = -1;
+      let gain = -Infinity;
+      members.forEach((_, i) => {
+        const [l2, h2] = span(members.filter((__, j) => j !== i));
+        if (h2 - l2 > gain) [gain, best] = [h2 - l2, i];
+      });
+      members = members.filter((_, j) => j !== best);
+      [lo, hi] = span(members);
+    }
+    if (members.length < need || hi - lo < 4 * margin) continue;
+    for (const l of members) taken.add(l.edge);
+    const a = linePoint(p.theta, p.rho, lo);
+    const b = linePoint(p.theta, p.rho, hi);
+    out.push({
+      key: `p${pi}`,
+      a,
+      b,
+      members: members.map((l) => {
+        const forward = placeOf(l.s, p.theta) <= placeOf(l.t, p.theta);
+        return { edge: l.edge, from: forward ? a : b, to: forward ? b : a, at: 0 };
+      }),
+    });
+  }
+  return out;
+}
+
+/**
+ * This function gives the highways of the Hough votes (HWY-024). The peaks of the votes of the straight lines of the edges are corridors.
+ * Each corridor is a spine through the corner graph, and its edges ride it over their common span.
+ */
+export function houghPlan(input: HighwayInput, o: Readonly<HoughOptions>): HighwayPlan {
+  const way = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  return snapPlan(input, houghLines(input, o), { ...way, minSize: Math.max(2, Math.round(o.minVotes)) });
+}