@mark1russell7/highways 0.4.1 → 0.5.0

package/src/highways/nested/index.ts

@@ -0,0 +1,143 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { polylineLength, type Point } from "../../geom.ts";
+import { firstRoutes } from "../base.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { mdf, resample, type BundleLine, type BundleOrder } from "../quickbundles/index.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `nested` (HWY-052 of the note on highways). */
+export interface NestedOptions {
+  /** The scale of the closest level, in units of the board. An edge joins a cluster when its distance to the centroid is this value or less. The default is 3. */
+  readonly theta: number;
+  /** The scale of each level is this value times the scale of the next closer level. The default is 2. */
+  readonly ratio: number;
+  /** The number of levels. The default is 3. */
+  readonly levels: number;
+  /** The level of the plan. Level 0 is the closest level, and level `levels - 1` is the far level. The default is 0. */
+  readonly level: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `nested`. */
+export const NESTED_DEFAULTS: Readonly<NestedOptions> = Object.freeze({
+  theta: 3,
+  ratio: 2,
+  levels: 3,
+  level: 0,
+  points: 12,
+  line: "routes",
+  order: "input",
+  minSize: 2,
+  spine: "shared",
+});
+
+interface Line {
+  readonly edge: string;
+  readonly line: readonly Point[];
+}
+
+/**
+ * This function puts lines in clusters in one pass, as QuickBundles does. Each line joins the cluster with the nearest centroid when the distance is `limit` or less.
+ * It gives the index of the cluster of each line, and `flip` when the line goes against the centroid.
+ */
+function clusterLines(lines: readonly Line[], limit: number): { cluster: number; flip: boolean }[] {
+  const clusters: { sum: { x: number; y: number }[]; n: number; centroid: Point[] }[] = [];
+  return lines.map(({ line }) => {
+    let best = -1;
+    let bestD = Infinity;
+    let bestFlip = false;
+    clusters.forEach((c, ci) => {
+      const m = mdf(line, c.centroid);
+      if (m.d < bestD) [best, bestD, bestFlip] = [ci, m.d, m.flip];
+    });
+    if (best < 0 || bestD > limit) {
+      clusters.push({ sum: line.map((p) => ({ ...p })), n: 1, centroid: [...line] });
+      return { cluster: clusters.length - 1, flip: false };
+    }
+    const c = clusters[best]!;
+    const oriented = bestFlip ? [...line].reverse() : line;
+    oriented.forEach((p, i) => {
+      c.sum[i]!.x += p.x;
+      c.sum[i]!.y += p.y;
+    });
+    c.n++;
+    c.centroid = c.sum.map((p) => ({ x: p.x / c.n, y: p.y / c.n }));
+    return { cluster: best, flip: bestFlip };
+  });
+}
+
+/**
+ * This function gives the groups of edges of each level, from the closest level (index 0) to the far level.
+ * The far level puts all the edges in clusters at the scale `theta × ratio^(levels - 1)`.
+ * Each closer level puts the edges of each cluster of the level above in clusters, at its own scale. Thus each group of a level is in one group of the level above.
+ */
+export function nestedGroups(input: HighwayInput, o: Readonly<NestedOptions>): Map<string, EdgeGroup>[] {
+  const graph = input.graph;
+  const unit = boardUnit(graph);
+  const levels = Math.max(1, Math.round(o.levels));
+  const k = Math.max(2, Math.round(o.points));
+  const routes = o.line === "routes" ? firstRoutes(input) : undefined;
+  const lines: Line[] = edgePlugs(graph).map(({ edge, ps, pt }) => ({ edge: edge.id, line: resample(routes?.get(edge.id) ?? [ps.point, pt.point], k) }));
+  if (o.order === "length") lines.sort((a, b) => polylineLength(b.line) - polylineLength(a.line) || (a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : 0));
+  const out: Map<string, EdgeGroup>[] = [];
+  // Each part is a list of lines with one key of the level above. The far level has one part with all the lines.
+  let parts: { key: string; lines: Line[] }[] = [{ key: "n", lines }];
+  for (let d = levels - 1; d >= 0; d--) {
+    const limit = o.theta * o.ratio ** d * unit;
+    const groups = new Map<string, EdgeGroup>();
+    const next: { key: string; lines: Line[] }[] = [];
+    for (const part of parts) {
+      const found = clusterLines(part.lines, limit);
+      const children = new Map<number, Line[]>();
+      found.forEach(({ cluster, flip }, i) => {
+        const key = `${part.key}.${cluster}`;
+        groups.set(part.lines[i]!.edge, { key, flip });
+        const list = children.get(cluster);
+        if (list) list.push(part.lines[i]!);
+        else children.set(cluster, [part.lines[i]!]);
+      });
+      for (const [cluster, list] of children) next.push({ key: `${part.key}.${cluster}`, lines: list });
+    }
+    out.unshift(groups);
+    parts = next;
+  }
+  return out;
+}
+
+/**
+ * This function gives the number of groups of the closer level `fine` with edges in two groups or more of the level `coarse`.
+ * An edge that is not in `coarse` does not count. The groups of `nestedGroups` give 0.
+ */
+export function nestingViolations(coarse: ReadonlyMap<string, EdgeGroup>, fine: ReadonlyMap<string, EdgeGroup>): number {
+  const parents = new Map<string, Set<string>>();
+  for (const [edge, g] of fine) {
+    const up = coarse.get(edge);
+    if (!up) continue;
+    const set = parents.get(g.key);
+    if (set) set.add(up.key);
+    else parents.set(g.key, new Set([up.key]));
+  }
+  let n = 0;
+  for (const set of parents.values()) if (set.size > 1) n++;
+  return n;
+}
+
+/**
+ * This function gives the highways of one level of the nested clusters (HWY-052). The level is `o.level`, with 0 as the closest level.
+ * The clusters of that level with `minSize` edges or more get highways, as in the strategy `quickbundles`.
+ */
+export function nestedPlan(input: HighwayInput, o: Readonly<NestedOptions>): HighwayPlan {
+  const levels = nestedGroups(input, o);
+  const level = Math.max(0, Math.min(levels.length - 1, Math.round(o.level)));
+  return groupedPlan(input, levels[level]!, { spine: o.spine, minSize: o.minSize });
+}

package/src/highways/od-cells/index.ts

@@ -0,0 +1,50 @@
+import { buildSections, levelCut } from "../../sections.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `od-cells` (EDA-033 with WILD-032 of the notes). */
+export interface OdCellOptions {
+  /** The depth of the cells in the tree of sections. Depth 1 is the level below the root. The default is 2. */
+  readonly level: number;
+  /** A pair of cells with this number of edges or more gets a trunk. The default is 3. */
+  readonly minGroup: number;
+  /** An edge rides the trunk only when each of its legs is this share of the span or shorter. The default is 0.3. */
+  readonly legMax: number;
+  /** The spine of each pair of cells. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `od-cells`. */
+export const OD_CELL_DEFAULTS: Readonly<OdCellOptions> = Object.freeze({ level: 2, minGroup: 3, legMax: 0.3, spine: "trunk" });
+
+/**
+ * This function gives the groups of the edges by the pair of the cells of their two nodes (EDA-033, WILD-032).
+ * The cells are the items of the zoom level at the depth `level`. The edges of one pair of cells, in either direction, are one group.
+ * An edge inside one cell is in no group.
+ */
+export function odGroups(input: HighwayInput, o: Readonly<OdCellOptions>): Map<string, EdgeGroup> {
+  const nodes = input.graph.nodes;
+  const groups = new Map<string, EdgeGroup>();
+  if (nodes.length === 0) return groups;
+  const { owner } = levelCut(nodes, buildSections(nodes), Math.max(0, Math.round(o.level)));
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  for (const e of input.graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined) continue;
+    const a = owner[u]!;
+    const b = owner[v]!;
+    if (a === b) continue;
+    groups.set(e.id, a < b ? { key: `od${a}:${b}`, flip: false } : { key: `od${b}:${a}`, flip: true });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of the consolidation by origin and destination cells (EDA-033, WILD-032).
+ * Carriers merge the loads from one region to another into one truck between two terminals. Thus each pair of cells with `minGroup` edges or more gets one trunk.
+ * The terminals are the Weber points of the plugs in each cell. An edge with a leg longer than `legMax` times the span goes alone.
+ */
+export function odCellPlan(input: HighwayInput, o: Readonly<OdCellOptions>): HighwayPlan {
+  return groupedPlan(input, odGroups(input, o), { spine: o.spine, minSize: o.minGroup, legMax: o.legMax });
+}

package/src/highways/quickbundles/index.ts

@@ -0,0 +1,117 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { firstRoutes } from "../base.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The line of each edge that QuickBundles compares: its first route, or the straight line between its plugs. */
+export type BundleLine = "routes" | "lines";
+
+/** The order of the edges in the one pass: the order of the graph, or the longest line first. */
+export type BundleOrder = "input" | "length";
+
+/** The options of the highway strategy `quickbundles` (HWY-026 of the note on highways). */
+export interface QuickBundlesOptions {
+  /** An edge joins a cluster when its distance to the centroid is this value or less, in units of the board. The default is 3. */
+  readonly theta: number;
+  /** The number of points of each line after the resampling. The default is 12. */
+  readonly points: number;
+  /** The line of each edge. The default is `routes`. */
+  readonly line: BundleLine;
+  /** The order of the edges. The default is `input`, so an added edge does not change the clusters before it. */
+  readonly order: BundleOrder;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `quickbundles`. */
+export const QUICKBUNDLES_DEFAULTS: Readonly<QuickBundlesOptions> = Object.freeze({ theta: 3, points: 12, line: "routes", order: "input", minSize: 2, spine: "shared" });
+
+/** This function gives `k` points at equal steps of length along a polyline, from its first point to its last point. */
+export function resample(line: readonly Point[], k: number): Point[] {
+  const n = Math.max(2, Math.round(k));
+  if (line.length === 0) throw new Error("The polyline has no point.");
+  if (line.length === 1) return Array.from({ length: n }, () => line[0]!);
+  const at: number[] = [0];
+  for (let i = 1; i < line.length; i++) at.push(at[i - 1]! + dist(line[i - 1]!, line[i]!));
+  const total = at[at.length - 1]!;
+  const out: Point[] = [];
+  let j = 1;
+  for (let i = 0; i < n; i++) {
+    const s = (total * i) / (n - 1);
+    while (j < line.length - 1 && at[j]! < s) j++;
+    const a = line[j - 1]!;
+    const b = line[j]!;
+    const len = at[j]! - at[j - 1]!;
+    const u = len > 0 ? Math.max(0, Math.min(1, (s - at[j - 1]!) / len)) : 0;
+    out.push({ x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+  }
+  return out;
+}
+
+/**
+ * This function gives the MDF distance of two lines with the same number of points. It is the mean distance of their points.
+ * The function compares the points in the same direction and in the opposite direction, and keeps the smaller mean.
+ * `flip` is `true` when the opposite direction is smaller.
+ */
+export function mdf(p: readonly Point[], q: readonly Point[]): { d: number; flip: boolean } {
+  const n = p.length;
+  let direct = 0;
+  let back = 0;
+  for (let i = 0; i < n; i++) {
+    direct += dist(p[i]!, q[i]!);
+    back += dist(p[i]!, q[n - 1 - i]!);
+  }
+  return back < direct ? { d: back / n, flip: true } : { d: direct / n, flip: false };
+}
+
+/**
+ * This function gives the clusters of QuickBundles (Garyfallidis 2012) as groups of edges.
+ * In one pass, each edge joins the cluster with the nearest centroid when the MDF distance is `theta` units or less. Else it starts a cluster.
+ * The centroid is the running mean of the lines of the cluster, each in the direction of the centroid.
+ */
+export function quickBundles(input: HighwayInput, o: Readonly<QuickBundlesOptions>): Map<string, EdgeGroup> {
+  const graph = input.graph;
+  const limit = o.theta * boardUnit(graph);
+  const k = Math.max(2, Math.round(o.points));
+  const routes = o.line === "routes" ? firstRoutes(input) : undefined;
+  const lines = edgePlugs(graph).map(({ edge, ps, pt }) => ({ edge: edge.id, line: resample(routes?.get(edge.id) ?? [ps.point, pt.point], k) }));
+  if (o.order === "length") lines.sort((a, b) => polylineLength(b.line) - polylineLength(a.line) || (a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : 0));
+  const clusters: { sum: { x: number; y: number }[]; n: number; centroid: Point[] }[] = [];
+  const groups = new Map<string, EdgeGroup>();
+  for (const { edge, line } of lines) {
+    let best = -1;
+    let bestD = Infinity;
+    let bestFlip = false;
+    clusters.forEach((c, ci) => {
+      const m = mdf(line, c.centroid);
+      if (m.d < bestD) [best, bestD, bestFlip] = [ci, m.d, m.flip];
+    });
+    if (best < 0 || bestD > limit) {
+      clusters.push({ sum: line.map((p) => ({ ...p })), n: 1, centroid: line });
+      groups.set(edge, { key: `q${clusters.length - 1}`, flip: false });
+      continue;
+    }
+    const c = clusters[best]!;
+    const oriented = bestFlip ? [...line].reverse() : line;
+    oriented.forEach((p, i) => {
+      c.sum[i]!.x += p.x;
+      c.sum[i]!.y += p.y;
+    });
+    c.n++;
+    c.centroid = c.sum.map((p) => ({ x: p.x / c.n, y: p.y / c.n }));
+    groups.set(edge, { key: `q${best}`, flip: bestFlip });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of QuickBundles (HWY-026). The clusters of `quickBundles` with `minSize` edges or more get highways.
+ * With the spine `shared`, the edges of each cluster share their ways through the corner graph. With `trunk`, each cluster gets one trunk.
+ */
+export function quickBundlesPlan(input: HighwayInput, o: Readonly<QuickBundlesOptions>): HighwayPlan {
+  return groupedPlan(input, quickBundles(input, o), { spine: o.spine, minSize: 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 });
+}