@mark1russell7/highways 0.4.2 → 0.5.1

package/src/highways/power/index.ts

@@ -0,0 +1,117 @@
+import type { WayOptions } from "../../ways.ts";
+import { nodeLinks, type GroupScope } from "../confluent/index.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The rule of a module: the nodes with the same neighbours (`exact`), or with near neighbours by the Jaccard index (`near`). */
+export type ModuleRule = "exact" | "near";
+
+/** The values of `ModuleRule`. */
+export const MODULE_RULES: readonly ModuleRule[] = Object.freeze(["exact", "near"]);
+
+/** The options of the highway strategy `power` (HWY-014 of the notes). */
+export interface PowerOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The rule of the modules. The default is `exact`. */
+  readonly modules: ModuleRule;
+  /** With the rule `near`, a node joins a module at this Jaccard index or more with the first node of the module. The default is 0.8. */
+  readonly jaccard: number;
+  /** A power edge saves the number of its edges less 1. It becomes a highway when it saves this number of edges or more. The default is 2. */
+  readonly minSaved: number;
+  /** The edges of one power edge. With `collection`, a power edge holds the edges of one collection. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each power edge. The default is `trunk`. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+
+/** The default options of the strategy `power`. */
+export const POWER_DEFAULTS: Readonly<Required<Omit<PowerOptions, "margin" | "k">>> = Object.freeze({
+  modules: "exact",
+  jaccard: 0.8,
+  minSaved: 2,
+  scope: "all",
+  spine: "trunk",
+  legMax: 1,
+});
+
+/** This function gives the Jaccard index of two sets: the size of their common part over the size of their union. Two empty sets give 1. */
+export function jaccardIndex(a: ReadonlySet<string>, b: ReadonlySet<string>): number {
+  let common = 0;
+  for (const x of a) if (b.has(x)) common++;
+  const union = a.size + b.size - common;
+  return union === 0 ? 1 : common / union;
+}
+
+/**
+ * This function gives the module of each node. With `exact`, the nodes with the same set of neighbours are one module.
+ * With `near`, the nodes go in the order of their degree, the largest first. A node joins the first module whose first node has a Jaccard index of `jaccard` or more with it.
+ * The function gives the modules as lists of nodes, each in the order of the ids.
+ */
+export function modulesOf(links: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>, rule: ModuleRule, jaccard: number): string[][] {
+  const nodes = [...links.keys()].sort();
+  const sets = new Map(nodes.map((u) => [u, new Set(links.get(u)!.keys())] as const));
+  if (rule === "exact") {
+    const byKey = new Map<string, string[]>();
+    for (const u of nodes) {
+      const key = [...sets.get(u)!].sort().join("\u0000");
+      const list = byKey.get(key);
+      if (list) list.push(u);
+      else byKey.set(key, [u]);
+    }
+    return [...byKey.values()];
+  }
+  const order = [...nodes].sort((u, v) => sets.get(v)!.size - sets.get(u)!.size || (u < v ? -1 : u > v ? 1 : 0));
+  const modules: string[][] = [];
+  for (const u of order) {
+    const home = modules.find((m) => !sets.get(m[0]!)!.has(u) && jaccardIndex(sets.get(m[0]!)!, sets.get(u)!) >= jaccard);
+    if (home) home.push(u);
+    else modules.push([u]);
+  }
+  return modules.map((m) => [...m].sort());
+}
+
+/**
+ * This function gives the highways of the edge compression with modules and power graphs (HWY-014, Dwyer, Henry Riche, Marriott and Mears 2013).
+ * The edges between two modules are one power edge. With modules of the rule `exact`, each node of one module links to each node of the other.
+ * A power edge that saves `minSaved` edges or more is one highway from module to module.
+ * Its trunk goes between the Weber points of the two ends.
+ * The search does not nest modules, so it finds no power edge inside a power edge.
+ */
+export function powerPlan(input: HighwayInput, o: Readonly<PowerOptions>): HighwayPlan {
+  const groups = new Map<string, EdgeGroup>();
+  const sourceOf = new Map(input.graph.edges.map((e) => [e.id, e.source.node] as const));
+  for (const scope of nodeLinks(input.graph, o.scope)) {
+    const modules = modulesOf(scope.links, o.modules, o.jaccard);
+    const moduleOf = new Map<string, number>();
+    modules.forEach((m, i) => {
+      for (const u of m) moduleOf.set(u, i);
+    });
+    // The edges between each pair of modules, with the smaller index first.
+    const between = new Map<string, { i: number; j: number; edges: string[] }>();
+    for (const [u, m] of scope.links)
+      for (const [v, edges] of m) {
+        const i = moduleOf.get(u)!;
+        const j = moduleOf.get(v)!;
+        if (i >= j) continue;
+        const key = `${i},${j}`;
+        let p = between.get(key);
+        if (!p) between.set(key, (p = { i, j, edges: [] }));
+        for (const e of edges) if (!p.edges.includes(e)) p.edges.push(e);
+      }
+    const pairs = [...between.values()].sort((p, q) => q.edges.length - p.edges.length || p.i - q.i || p.j - q.j);
+    for (const p of pairs) {
+      if (p.edges.length - 1 < Math.max(1, o.minSaved)) continue;
+      const first = new Set(modules[p.i]);
+      const key = `p${scope.key}/${p.i}-${p.j}`;
+      for (const e of p.edges) if (!groups.has(e)) groups.set(e, { key, flip: !first.has(sourceOf.get(e)!) });
+    }
+  }
+  return groupedPlan(input, groups, {
+    ...(o.margin === undefined ? {} : { margin: o.margin }),
+    ...(o.k === undefined ? {} : { k: o.k }),
+    spine: o.spine,
+    minSize: 2,
+    legMax: o.legMax,
+  });
+}

package/src/highways/resistance/index.ts

@@ -0,0 +1,159 @@
+import { rng } from "../../fixtures.ts";
+import type { Graph } from "../../model.ts";
+import { groupedPlan, type EdgeGroup } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { compatibilityMatrix, edgeBlocks, edgeEnds, labelGroups, spectralLabels, type SpectralOptions } from "../spectral/index.ts";
+
+/** The options of the highway strategy `resistance` (HWY-021 of the note on highways). */
+export interface ResistanceOptions extends SpectralOptions {
+  /** The number of random projections of the estimate of the resistance. The default is 16. */
+  readonly projections: number;
+  /** The weight of the resistance, from 0 to 1. A pair with `C >= c0` gets the weight `C (1 - weight R_e R_f)`. The default is 0.5. */
+  readonly weight: number;
+  /** With `true`, an edge with a resistance of 0.99 or more (a bridge) gets no pair. The default is `false`. */
+  readonly sparsify: boolean;
+}
+
+/** The default options of the strategy `resistance`. */
+export const RESISTANCE_DEFAULTS: Readonly<ResistanceOptions> = Object.freeze({
+  c0: 0.5,
+  clusters: 0,
+  kMax: 16,
+  minSize: 2,
+  spine: "trunk",
+  projections: 16,
+  weight: 0.5,
+  sparsify: false,
+});
+
+/** The seed of the random projections. One seed gives the same estimate each time. */
+const SEED = 21;
+
+/** A resistance of this value or more marks a bridge. */
+const BRIDGE = 0.99;
+
+/**
+ * This function solves `L z = y` with the method of conjugate gradients. `L` is the Laplacian of the graph, and `y` has a sum of 0 on each connected part.
+ * The result has a mean of 0 on each connected part.
+ */
+function solveLaplacian(n: number, adj: readonly (readonly number[])[], y: Float64Array, part: Int32Array, parts: number): Float64Array {
+  const mul = (v: Float64Array, out: Float64Array): void => {
+    for (let i = 0; i < n; i++) {
+      let s = adj[i]!.length * v[i]!;
+      for (const j of adj[i]!) s -= v[j]!;
+      out[i] = s;
+    }
+  };
+  const centre = (v: Float64Array): void => {
+    const sum = new Float64Array(parts);
+    const size = new Float64Array(parts);
+    for (let i = 0; i < n; i++) {
+      sum[part[i]!] = sum[part[i]!]! + v[i]!;
+      size[part[i]!] = size[part[i]!]! + 1;
+    }
+    for (let i = 0; i < n; i++) v[i] = v[i]! - sum[part[i]!]! / size[part[i]!]!;
+  };
+  const z = new Float64Array(n);
+  const r = Float64Array.from(y);
+  centre(r);
+  const p = Float64Array.from(r);
+  const lp = new Float64Array(n);
+  let rr = r.reduce((s, v) => s + v * v, 0);
+  const stop = 1e-20 * Math.max(1, rr);
+  for (let iter = 0; iter < 4 * n + 20 && rr > stop; iter++) {
+    mul(p, lp);
+    const pl = p.reduce((s, v, i) => s + v * lp[i]!, 0);
+    if (pl <= 0) break;
+    const a = rr / pl;
+    for (let i = 0; i < n; i++) {
+      z[i] = z[i]! + a * p[i]!;
+      r[i] = r[i]! - a * lp[i]!;
+    }
+    const next = r.reduce((s, v) => s + v * v, 0);
+    const b = next / rr;
+    rr = next;
+    for (let i = 0; i < n; i++) p[i] = r[i]! + b * p[i]!;
+  }
+  centre(z);
+  return z;
+}
+
+/**
+ * This function gives an estimate of the effective resistance of each edge of the graph (Spielman and Srivastava 2011).
+ * It takes `k` random vectors `q` of the values `±1/√k` on the edges. It solves `L z = Bᵀ q` for each vector. Then `R(u, v) ≈ Σ (z_u - z_v)²`.
+ * The value is from 0 to 1. A loop and an edge with an unknown node get 0. Parallel edges share the current, so each gets a lower value.
+ */
+export function edgeResistance(graph: Graph, projections: number): Map<string, number> {
+  const index = new Map(graph.nodes.map((v, i) => [v.id, i] as const));
+  const n = graph.nodes.length;
+  const adj: number[][] = graph.nodes.map(() => []);
+  const ends: { id: string; u: number; v: number }[] = [];
+  for (const e of graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined || u === v) continue;
+    adj[u]!.push(v);
+    adj[v]!.push(u);
+    ends.push({ id: e.id, u, v });
+  }
+  // The connected parts of the graph.
+  const part = new Int32Array(n).fill(-1);
+  let parts = 0;
+  for (let i = 0; i < n; i++) {
+    if (part[i]! >= 0) continue;
+    const stack = [i];
+    part[i] = parts;
+    while (stack.length > 0) {
+      const a = stack.pop()!;
+      for (const b of adj[a]!)
+        if (part[b]! < 0) {
+          part[b] = parts;
+          stack.push(b);
+        }
+    }
+    parts++;
+  }
+  const k = Math.max(1, Math.round(projections));
+  const random = rng(SEED);
+  const sum = new Float64Array(ends.length);
+  for (let r = 0; r < k; r++) {
+    const y = new Float64Array(n);
+    for (const { u, v } of ends) {
+      const q = (random() < 0.5 ? -1 : 1) / Math.sqrt(k);
+      y[u] = y[u]! + q;
+      y[v] = y[v]! - q;
+    }
+    const z = solveLaplacian(n, adj, y, part, parts);
+    ends.forEach(({ u, v }, i) => {
+      sum[i] = sum[i]! + (z[u]! - z[v]!) ** 2;
+    });
+  }
+  const out = new Map<string, number>(graph.edges.map((e) => [e.id, 0] as const));
+  ends.forEach(({ id }, i) => out.set(id, Math.max(0, Math.min(1, sum[i]!))));
+  return out;
+}
+
+/**
+ * This function gives the clusters of the edges with the compatibility scaled by the resistance (HWY-021).
+ * The compatibility of a pair is `C (1 - weight R_e R_f)`. A pair of two bridges thus gets a lower value. Then the spectral clusters of `spectral` apply.
+ */
+export function resistanceClusters(input: HighwayInput, o: Readonly<ResistanceOptions>): Map<string, EdgeGroup> {
+  const resistance = edgeResistance(input.graph, o.projections);
+  const weight = Math.max(0, Math.min(1, o.weight));
+  const groups = new Map<string, EdgeGroup>();
+  edgeBlocks(edgeEnds(input)).forEach((block, b) => {
+    const r = block.map((e) => resistance.get(e.edge) ?? 0);
+    const scale = (i: number, j: number): number => (o.sparsify && (r[i]! >= BRIDGE || r[j]! >= BRIDGE) ? 0 : 1 - weight * r[i]! * r[j]!);
+    const labels = spectralLabels(block.length, compatibilityMatrix(block, o.c0, scale), o);
+    labelGroups(block, labels, `p${b}:`, groups);
+  });
+  return groups;
+}
+
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph with the weights of the effective resistance (HWY-021).
+ * The clusters with `minSize` edges or more get highways.
+ */
+export function resistancePlan(input: HighwayInput, o: Readonly<ResistanceOptions>): HighwayPlan {
+  return groupedPlan(input, resistanceClusters(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minSize)) });
+}

package/src/highways/ridges/index.ts

@@ -0,0 +1,328 @@
+import { dist, type Point } from "../../geom.ts";
+import type { WayOptions } 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 lines that make the density: the straight lines of the edges, or their first routes. */
+export type RidgeSource = "lines" | "routes";
+
+/** The options of the highway strategy `ridges` (HWY-032 of the note on highways). */
+export interface RidgeOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The lines of the density. The default is `lines`. */
+  readonly source: RidgeSource;
+  /** The side of a cell of the density image, in units of the board. The default is 8. A large board gets larger cells, up to 1024 cells on a side. */
+  readonly cell: number;
+  /** The width of the blur, in units of the board. The default is 16. */
+  readonly bandwidth: number;
+  /** A ridge cell has this share of the largest strength or more. The default is 0.15. */
+  readonly strength: number;
+  /** A ridge has this length or more, in units of the board. The default is 60. */
+  readonly minLength: number;
+  /** An edge snaps to a ridge when its line is this near to the ridge, in units of the board. The default is 16. */
+  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 `ridges`. */
+export const RIDGE_DEFAULTS: Readonly<Required<Omit<RidgeOptions, "margin" | "k">>> = Object.freeze({ source: "lines", cell: 8, bandwidth: 16, strength: 0.15, minLength: 60, snap: 16, minSize: 2 });
+
+/** The largest angle between an edge and a ridge that it snaps to, in degrees. */
+const MAX_ANGLE = 30;
+
+/** The density image: the cells, its size, and the place of its first cell. */
+export interface DensityImage {
+  readonly w: number;
+  readonly h: number;
+  readonly cell: number;
+  readonly x0: number;
+  readonly y0: number;
+  readonly rho: Float64Array;
+}
+
+/**
+ * This function gives the density of the polylines on a grid of cells, after a Gaussian blur of the width `bandwidth`.
+ * Each polyline adds 1 to each cell that it goes through, one time for each polyline.
+ */
+export function lineDensity(lines: readonly (readonly Point[])[], box: { x: number; y: number; w: number; h: number }, cellSize: number, bandwidth: number): DensityImage {
+  const cell = Math.max(cellSize, box.w / 1024, box.h / 1024, 1e-6);
+  const pad = 3 * bandwidth;
+  const x0 = box.x - pad;
+  const y0 = box.y - pad;
+  const w = Math.max(1, Math.ceil((box.w + 2 * pad) / cell));
+  const h = Math.max(1, Math.ceil((box.h + 2 * pad) / cell));
+  const raw = new Float64Array(w * h);
+  const stamp = new Int32Array(w * h).fill(-1);
+  lines.forEach((p, li) => {
+    for (let i = 1; i < p.length; i++) {
+      const a = p[i - 1]!;
+      const b = p[i]!;
+      const steps = Math.max(1, Math.ceil((2 * dist(a, b)) / cell));
+      for (let k = 0; k <= steps; k++) {
+        const x = Math.floor((a.x + ((b.x - a.x) * k) / steps - x0) / cell);
+        const y = Math.floor((a.y + ((b.y - a.y) * k) / steps - y0) / cell);
+        if (x < 0 || y < 0 || x >= w || y >= h) continue;
+        const c = y * w + x;
+        if (stamp[c] === li) continue;
+        stamp[c] = li;
+        raw[c] = raw[c]! + 1;
+      }
+    }
+  });
+  // A blur with a Gaussian kernel, first along x, then along y.
+  const sigma = Math.max(1e-6, bandwidth / cell);
+  const r = Math.ceil(3 * sigma);
+  const kernel = Array.from({ length: 2 * r + 1 }, (_, i) => Math.exp(-((i - r) ** 2) / (2 * sigma * sigma)));
+  const sum = kernel.reduce((s, v) => s + v, 0);
+  const tmp = new Float64Array(w * h);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      let v = 0;
+      for (let i = -r; i <= r; i++) {
+        const xi = x + i;
+        if (xi >= 0 && xi < w) v += raw[y * w + xi]! * kernel[i + r]!;
+      }
+      tmp[y * w + x] = v / sum;
+    }
+  const rho = new Float64Array(w * h);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      let v = 0;
+      for (let i = -r; i <= r; i++) {
+        const yi = y + i;
+        if (yi >= 0 && yi < h) v += tmp[yi * w + x]! * kernel[i + r]!;
+      }
+      rho[y * w + x] = v / sum;
+    }
+  return { w, h, cell, x0, y0, rho };
+}
+
+/** One ridge: its two ends and the length between them. */
+export interface Ridge {
+  readonly a: Point;
+  readonly b: Point;
+}
+
+/**
+ * This function gives the ridges of a density image (Lindeberg 1998). A ridge cell has a negative eigenvalue of the Hessian with the larger size.
+ * Its density is a maximum along the eigenvector of that eigenvalue. Its strength is the density times the size of that eigenvalue.
+ * The cells with `strength` times the largest strength or more join their neighbours with a direction within 30 degrees.
+ * Each group of cells gives the segment of its main axis. A segment of `minLength` or more is a ridge. The ridges come in the order of their total strength.
+ */
+export function densityRidges(img: DensityImage, strength: number, minLength: number): Ridge[] {
+  const { w, h, rho } = img;
+  const at = (x: number, y: number): number => rho[Math.min(h - 1, Math.max(0, y)) * w + Math.min(w - 1, Math.max(0, x))]!;
+  const power = new Float64Array(w * h);
+  const across = new Float64Array(w * h * 2);
+  let top = 0;
+  for (let y = 1; y < h - 1; y++)
+    for (let x = 1; x < w - 1; x++) {
+      const v = at(x, y);
+      if (v <= 0) continue;
+      const hxx = at(x + 1, y) - 2 * v + at(x - 1, y);
+      const hyy = at(x, y + 1) - 2 * v + at(x, y - 1);
+      const hxy = (at(x + 1, y + 1) - at(x + 1, y - 1) - at(x - 1, y + 1) + at(x - 1, y - 1)) / 4;
+      const mean = (hxx + hyy) / 2;
+      const root = Math.sqrt(((hxx - hyy) / 2) ** 2 + hxy * hxy);
+      const l1 = mean - root;
+      const l2 = mean + root;
+      if (!(l1 < 0 && Math.abs(l1) > Math.abs(l2))) continue;
+      // The eigenvector of `l1` points across the ridge.
+      let vx = hxy;
+      let vy = l1 - hxx;
+      if (Math.abs(vx) + Math.abs(vy) < 1e-12) [vx, vy] = hxx <= hyy ? [1, 0] : [0, 1];
+      const n = Math.hypot(vx, vy);
+      vx /= n;
+      vy /= n;
+      const side = (s: number): number => {
+        const px = x + s * vx;
+        const py = y + s * vy;
+        const ix = Math.floor(px);
+        const iy = Math.floor(py);
+        const fx = px - ix;
+        const fy = py - iy;
+        return at(ix, iy) * (1 - fx) * (1 - fy) + at(ix + 1, iy) * fx * (1 - fy) + at(ix, iy + 1) * (1 - fx) * fy + at(ix + 1, iy + 1) * fx * fy;
+      };
+      if (v < side(1) || v < side(-1)) continue;
+      const s = v * -l1;
+      power[y * w + x] = s;
+      across[2 * (y * w + x)] = vx;
+      across[2 * (y * w + x) + 1] = vy;
+      top = Math.max(top, s);
+    }
+  if (top <= 0) return [];
+  const floor = strength * top;
+  const seen = new Uint8Array(w * h);
+  const cos = Math.cos((MAX_ANGLE * Math.PI) / 180);
+  const out: { ridge: Ridge; total: number }[] = [];
+  for (let c = 0; c < w * h; c++) {
+    if (seen[c] || power[c]! < floor || power[c]! <= 0) continue;
+    const cells: number[] = [];
+    const stack = [c];
+    seen[c] = 1;
+    while (stack.length > 0) {
+      const i = stack.pop()!;
+      cells.push(i);
+      const x = i % w;
+      const y = Math.floor(i / w);
+      for (let dy = -1; dy <= 1; dy++)
+        for (let dx = -1; dx <= 1; dx++) {
+          const xj = x + dx;
+          const yj = y + dy;
+          if ((dx === 0 && dy === 0) || xj < 0 || yj < 0 || xj >= w || yj >= h) continue;
+          const j = yj * w + xj;
+          if (seen[j] || power[j]! < floor || power[j]! <= 0) continue;
+          if (Math.abs(across[2 * i]! * across[2 * j]! + across[2 * i + 1]! * across[2 * j + 1]!) < cos) continue;
+          seen[j] = 1;
+          stack.push(j);
+        }
+    }
+    // The main axis of the cells, weighted by their strength.
+    let sw = 0;
+    let mx = 0;
+    let my = 0;
+    for (const i of cells) {
+      const p = power[i]!;
+      sw += p;
+      mx += p * (i % w);
+      my += p * Math.floor(i / w);
+    }
+    mx /= sw;
+    my /= sw;
+    let sxx = 0;
+    let syy = 0;
+    let sxy = 0;
+    for (const i of cells) {
+      const p = power[i]!;
+      const dx = (i % w) - mx;
+      const dy = Math.floor(i / w) - my;
+      sxx += p * dx * dx;
+      syy += p * dy * dy;
+      sxy += p * dx * dy;
+    }
+    const angle = 0.5 * Math.atan2(2 * sxy, sxx - syy);
+    const ux = Math.cos(angle);
+    const uy = Math.sin(angle);
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const i of cells) {
+      const u = ((i % w) - mx) * ux + (Math.floor(i / w) - my) * uy;
+      lo = Math.min(lo, u);
+      hi = Math.max(hi, u);
+    }
+    const toBoard = (u: number): Point => ({ x: img.x0 + (mx + u * ux + 0.5) * img.cell, y: img.y0 + (my + u * uy + 0.5) * img.cell });
+    const ridge = { a: toBoard(lo), b: toBoard(hi) };
+    if (dist(ridge.a, ridge.b) >= minLength) out.push({ ridge, total: sw });
+  }
+  out.sort((p, q) => q.total - p.total || p.ridge.a.x - q.ridge.a.x || p.ridge.a.y - q.ridge.a.y);
+  return out.map((x) => x.ridge);
+}
+
+/**
+ * This function gives the part of the segment `s` to `t` that is within `snap` of the ridge, between the two ends of the ridge.
+ * The part is two shares of the segment, from 0 at `s` to 1 at `t`. It gives `undefined` when the segment has no such part.
+ */
+export function nearPart(s: Point, t: Point, r: Ridge, snap: number): [number, number] | undefined {
+  const len = dist(r.a, r.b);
+  if (len <= 1e-9) return undefined;
+  const ux = (r.b.x - r.a.x) / len;
+  const uy = (r.b.y - r.a.y) / len;
+  // The place along the ridge and the offset from it are linear in the share `q` of the segment.
+  const u0 = (s.x - r.a.x) * ux + (s.y - r.a.y) * uy;
+  const u1 = (t.x - r.a.x) * ux + (t.y - r.a.y) * uy;
+  const d0 = -(s.x - r.a.x) * uy + (s.y - r.a.y) * ux;
+  const d1 = -(t.x - r.a.x) * uy + (t.y - r.a.y) * ux;
+  let lo = 0;
+  let hi = 1;
+  const clip = (v0: number, v1: number, min: number, max: number): void => {
+    // The shares where `v0 + q (v1 - v0)` is from `min` to `max`.
+    const dv = v1 - v0;
+    if (Math.abs(dv) < 1e-12) {
+      if (v0 < min || v0 > max) hi = -1;
+      return;
+    }
+    const qa = (min - v0) / dv;
+    const qb = (max - v0) / dv;
+    lo = Math.max(lo, Math.min(qa, qb));
+    hi = Math.min(hi, Math.max(qa, qb));
+  };
+  clip(u0, u1, 0, len);
+  clip(d0, d1, -snap, snap);
+  return hi > lo ? [lo, hi] : undefined;
+}
+
+/**
+ * This function gives the lines of the ridges (HWY-032), each with the edges that snap to it.
+ * An edge snaps to a ridge when the part of its line near the ridge is half of `minLength` or longer.
+ * The angle between the edge and the ridge is 30 degrees or less.
+ * The edge joins and leaves the ridge at the ends of that part. When two ridges hold one part of an edge, only the longer part rides.
+ */
+export function ridgeLines(input: HighwayInput, o: Readonly<RidgeOptions>): SnapLine[] {
+  const plugs = edgePlugs(input.graph);
+  const routes = o.source === "routes" ? firstRoutes(input) : undefined;
+  const lines = plugs.map(({ edge, ps, pt }) => routes?.get(edge.id) ?? [ps.point, pt.point]);
+  if (input.graph.nodes.length === 0 || lines.length === 0) return [];
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const n of input.graph.nodes) {
+    x0 = Math.min(x0, n.box.x);
+    y0 = Math.min(y0, n.box.y);
+    x1 = Math.max(x1, n.box.x + n.box.w);
+    y1 = Math.max(y1, n.box.y + n.box.h);
+  }
+  const img = lineDensity(lines, { x: x0, y: y0, w: x1 - x0, h: y1 - y0 }, o.cell, o.bandwidth);
+  const ridges = densityRidges(img, o.strength, o.minLength);
+  const cos = Math.cos((MAX_ANGLE * Math.PI) / 180);
+  // The parts of each edge near each ridge.
+  const parts = new Map<string, { r: number; lo: number; hi: number; long: number }[]>();
+  ridges.forEach((r, ri) => {
+    const rl = dist(r.a, r.b);
+    for (const { edge, ps, pt } of plugs) {
+      const s = ps.point;
+      const t = pt.point;
+      const el = dist(s, t);
+      if (el <= 1e-9) continue;
+      if (Math.abs(((t.x - s.x) * (r.b.x - r.a.x) + (t.y - s.y) * (r.b.y - r.a.y)) / (el * rl)) < cos) continue;
+      const near = nearPart(s, t, r, o.snap);
+      if (!near) continue;
+      const long = (near[1] - near[0]) * el;
+      if (long < o.minLength / 2) continue;
+      const list = parts.get(edge.id) ?? [];
+      list.push({ r: ri, lo: near[0], hi: near[1], long });
+      parts.set(edge.id, list);
+    }
+  });
+  const members = ridges.map((): SnapMember[] => []);
+  for (const { edge, ps, pt } of plugs) {
+    const list = (parts.get(edge.id) ?? []).sort((p, q) => q.long - p.long || p.r - q.r);
+    const kept: typeof list = [];
+    for (const p of list) if (!kept.some((k) => p.lo < k.hi && k.lo < p.hi)) kept.push(p);
+    for (const p of kept) {
+      const r = ridges[p.r]!;
+      const s = ps.point;
+      const t = pt.point;
+      const onRidge = (q: number): Point => {
+        const x = s.x + (t.x - s.x) * q;
+        const y = s.y + (t.y - s.y) * q;
+        const len = dist(r.a, r.b);
+        const u = ((x - r.a.x) * (r.b.x - r.a.x) + (y - r.a.y) * (r.b.y - r.a.y)) / (len * len);
+        return { x: r.a.x + (r.b.x - r.a.x) * u, y: r.a.y + (r.b.y - r.a.y) * u };
+      };
+      members[p.r]!.push({ edge: edge.id, from: onRidge(p.lo), to: onRidge(p.hi), at: p.lo });
+    }
+  }
+  return ridges.map((r, ri) => ({ key: `r${ri}`, a: r.a, b: r.b, members: members[ri]! }));
+}
+
+/**
+ * This function gives the highways of the ridges of the line density (HWY-032). One pass draws the density, with no advection.
+ * The ridges of the density are the spines, and the edges near a ridge snap to it between their nearest entry and exit points.
+ */
+export function ridgePlan(input: HighwayInput, o: Readonly<RidgeOptions>): HighwayPlan {
+  const way = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  return snapPlan(input, ridgeLines(input, o), { ...way, minSize: o.minSize });
+}