@mark1russell7/highways 0.4.2 → 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/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 });
+}

package/src/highways/snap.ts

@@ -0,0 +1,110 @@
+import { dist, polylineLength, type Point } from "../geom.ts";
+import { orderLanes } from "../segments.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+import { 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";
+
+/** One edge that snaps to a line: the points where it joins and leaves the line, and its place along its own way. */
+export interface SnapMember {
+  readonly edge: string;
+  /** The point on the line where the edge joins it. */
+  readonly from: Point;
+  /** The point on the line where the edge leaves it. */
+  readonly to: Point;
+  /** The place of the join along the edge, from 0 at the source to 1 at the target. It orders the highways of one edge. */
+  readonly at: number;
+}
+
+/** A straight line that a finder gives as the place of a highway, with the edges that snap to it. */
+export interface SnapLine {
+  readonly key: string;
+  readonly a: Point;
+  readonly b: Point;
+  readonly members: readonly SnapMember[];
+}
+
+/** The options of `snapPlan`. */
+export interface SnapOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A highway has this number of edges or more. The value is 2 or more. */
+  readonly minSize: number;
+}
+
+/** This function gives the line `u d + rho n` of the direction angle `theta`, with `d = (cos, sin)` and the normal `n = (-sin, cos)`. */
+export function linePoint(theta: number, rho: number, u: number): Point {
+  const c = Math.cos(theta);
+  const s = Math.sin(theta);
+  return { x: u * c - rho * s, y: u * s + rho * c };
+}
+
+/**
+ * This function gives the highways of straight lines in the free space. Each line becomes a spine through the corner graph between its two ends.
+ * An end inside a box moves to the nearest corner of the graph.
+ * Each member joins the spine at the place nearest to its point `from`, and leaves it at the place nearest to its point `to`.
+ * A member whose part of the spine is shorter than the margin does not ride. A spine with fewer than `minSize` members is not a highway.
+ * An edge on several highways takes them in the order of `at`.
+ */
+export function snapPlan(input: HighwayInput, lines: readonly SnapLine[], o: Readonly<SnapOptions>): HighwayPlan {
+  const min = Math.max(2, o.minSize);
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const corners = finder.corners;
+  const plugs = new Map(edgePlugs(input.graph).map((p) => [p.edge.id, p] as const));
+  const pad = finder.margin / 2;
+  const free = (p: Point): Point => {
+    if (!finder.obstacles.inside(p, pad)) return p;
+    const i = corners.nearest(p);
+    return i >= 0 ? corners.points[i]! : p;
+  };
+  const highways: Highway[] = [];
+  const at = new Map<string, number>();
+  for (const line of lines) {
+    const a = free(line.a);
+    const b = free(line.b);
+    if (dist(a, b) <= finder.margin) continue;
+    const raw = corners.path(a, b);
+    if (!raw) continue;
+    const spine = corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= 1e-6) continue;
+    const riders: { edge: string; on: number; off: number; points: Point[] }[] = [];
+    for (const m of line.members) {
+      const plug = plugs.get(m.edge);
+      if (!plug) continue;
+      const on = nearestPlace(spine, m.from);
+      const off = nearestPlace(spine, m.to);
+      if (lengthBetween(spine, Math.min(on, off), Math.max(on, off)) < finder.margin) continue;
+      riders.push({ edge: m.edge, on, off, points: [plug.ps.point, ...spinePart(spine, on, off), plug.pt.point] });
+    }
+    if (riders.length < min) continue;
+    const hi = highways.length;
+    for (const m of line.members) at.set(`${hi}\u0000${m.edge}`, m.at);
+    const lanes = orderLanes(spine, riders.map((r) => ({ edge: r.edge, points: r.points })), "bundle");
+    const byEdge = new Map(riders.map((r) => [r.edge, r]));
+    const members: HighwayMember[] = lanes.map((edge) => memberAt(spine, edge, byEdge.get(edge)!.on, byEdge.get(edge)!.off));
+    highways.push({ id: `h${hi}`, key: line.key, spine, lanes, members });
+  }
+  // The `seq` of each member follows `at` along its edge.
+  const trips = new Map<string, { h: number; at: number }[]>();
+  highways.forEach((h, hi) => {
+    for (const m of h.members) {
+      const list = trips.get(m.edge) ?? [];
+      list.push({ h: hi, at: at.get(`${hi}\u0000${m.edge}`) ?? 0 });
+      trips.set(m.edge, list);
+    }
+  });
+  const seq = new Map<string, number>();
+  for (const [edge, list] of trips) {
+    list.sort((p, q) => p.at - q.at || p.h - q.h);
+    list.forEach((x, k) => seq.set(`${x.h}\u0000${edge}`, k));
+  }
+  return tidyPlan({ highways: highways.map((h, hi) => ({ ...h, members: h.members.map((m) => ({ ...m, seq: seq.get(`${hi}\u0000${m.edge}`) ?? 0 })) })) });
+}
+
+/** This function gives the points of a spine from the place `on` to the place `off`, backward when `on` is larger. */
+export function spinePart(spine: readonly Point[], on: number, off: number): Point[] {
+  const lo = Math.min(on, off);
+  const hi = Math.max(on, off);
+  const out = [pointAt(spine, lo)];
+  for (let i = Math.floor(lo) + 1; i < hi; i++) out.push(spine[i]!);
+  out.push(pointAt(spine, hi));
+  return on <= off ? out : out.reverse();
+}