@mark1russell7/highways 0.4.2 → 0.5.0

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

@@ -0,0 +1,181 @@
+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 HighwayPlan } from "../model.ts";
+import { candidatePlan, type CandidateSource } from "../select/index.ts";
+import { spinePart } from "../snap.ts";
+import { edgePlugs, sharedStretches } from "../stretches.ts";
+
+/** A generator of candidate arcs: `runs` (the shared stretches of the first ways of all edges) or a generator of the strategy `select`. */
+export type ArcSource = "runs" | CandidateSource;
+
+/** The values of `ArcSource`. */
+export const ARC_SOURCES: readonly ArcSource[] = Object.freeze(["runs", "corridors", "quickbundles", "wspd", "road-classes", "flow-field", "od-cells", "shared-ways"]);
+
+/** The options of the highway strategy `hub-arcs` (HWY-042 of the note on highways). */
+export interface HubArcOptions {
+  /** The largest number of arcs (highways). The default is 12. */
+  readonly q: number;
+  /** The cost of a length on an arc against a length off the arcs, from 0 to 1. The default is 0.5. */
+  readonly alpha: number;
+  /** An edge rides an arc only when its legs plus its part of the arc are this many times its first route or less. The default is 1.25. */
+  readonly stretch: number;
+  /** The number of passes of the local search with one swap. The default is 1. */
+  readonly swaps: number;
+  /** An arc with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+  /** The generators of the candidate arcs. The default is `runs`, `corridors` and `road-classes`. */
+  readonly generators: readonly ArcSource[];
+}
+
+/** The default options of the strategy `hub-arcs`. */
+export const HUB_ARC_DEFAULTS: Readonly<HubArcOptions> = Object.freeze({
+  q: 12,
+  alpha: 0.5,
+  stretch: 1.25,
+  swaps: 1,
+  minSize: 2,
+  generators: Object.freeze(["runs", "corridors", "road-classes"] as ArcSource[]),
+});
+
+/** The largest number of candidate arcs. The longest arcs stay. */
+const MAX_ARCS = 400;
+
+/** The place of one edge on one arc: where it joins and leaves, and the cost it saves against its first route. */
+interface Ride {
+  readonly on: number;
+  readonly off: number;
+  readonly save: number;
+}
+
+/** This function gives the candidate arcs: the spines of the plans of the generators, without the copies, with the longest first. */
+export function candidateArcs(input: HighwayInput, generators: readonly ArcSource[]): Point[][] {
+  const spines: Point[][] = [];
+  for (const g of generators) {
+    const plan = g === "runs" ? runsPlan(input) : candidatePlan(input, g);
+    for (const h of plan.highways) spines.push([...h.spine]);
+  }
+  const seen = new Set<string>();
+  const out: Point[][] = [];
+  for (const s of spines) {
+    if (s.length < 2 || polylineLength(s) <= 1e-6) continue;
+    const key = s.map((p) => `${Math.round(p.x)},${Math.round(p.y)}`).join(";");
+    const back = [...s].reverse().map((p) => `${Math.round(p.x)},${Math.round(p.y)}`).join(";");
+    if (seen.has(key) || seen.has(back)) continue;
+    seen.add(key);
+    out.push(s);
+  }
+  out.sort((a, b) => polylineLength(b) - polylineLength(a));
+  return out.slice(0, MAX_ARCS);
+}
+
+/** This function gives the shared stretches of the first ways of all edges, with no keys. */
+function runsPlan(input: HighwayInput): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const ways = edgePlugs(input.graph).map(({ edge, ps, pt }) => {
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    return { edge: edge.id, key: "", points: finder.corners.path(a, b) ?? [a, b] };
+  });
+  return sharedStretches(ways, { minSize: 2, pull: (p) => finder.corners.pull(p) });
+}
+
+/**
+ * This function gives the highways of the hub arc location (Campbell, Ernst and Krishnamoorthy 2005). It chooses at most `q` arcs from the candidates.
+ * An edge on an arc costs its two legs plus `alpha` times its part of the arc. An edge off the arcs costs its first route.
+ * The greedy step adds the arc that saves the most cost. Then each swap pass changes one chosen arc for one other arc while the saving grows.
+ * Each edge rides the arc that saves the most for it.
+ */
+export function hubArcPlan(input: HighwayInput, o: Readonly<HubArcOptions>): HighwayPlan {
+  const margin = 5;
+  const routes = firstRoutes(input);
+  const plugs = edgePlugs(input.graph);
+  const arcs = candidateArcs(input, o.generators);
+  const q = Math.max(0, Math.round(o.q));
+  if (q === 0 || arcs.length === 0) return { highways: [] };
+  // The saving of each edge on each arc. A saving of 0 means that the edge does not ride the arc.
+  const rides: (Ride | undefined)[][] = arcs.map((spine) =>
+    plugs.map(({ edge, ps, pt }) => {
+      const first = routes.get(edge.id);
+      const base = first ? polylineLength(first) : dist(ps.point, pt.point);
+      const on = nearestPlace(spine, ps.point);
+      const off = nearestPlace(spine, pt.point);
+      const along = lengthBetween(spine, Math.min(on, off), Math.max(on, off));
+      if (along < margin) return undefined;
+      const legs = dist(ps.point, pointAt(spine, on)) + dist(pointAt(spine, off), pt.point);
+      if (legs + along > o.stretch * base) return undefined;
+      const save = base - (legs + o.alpha * along);
+      return save > 0 ? { on, off, save } : undefined;
+    }),
+  );
+  const n = plugs.length;
+  const total = (chosen: readonly number[]): number => {
+    let sum = 0;
+    for (let e = 0; e < n; e++) {
+      let best = 0;
+      for (const a of chosen) best = Math.max(best, rides[a]![e]?.save ?? 0);
+      sum += best;
+    }
+    return sum;
+  };
+  const chosen: number[] = [];
+  while (chosen.length < q) {
+    const now = total(chosen);
+    let pick = -1;
+    let gain = 1e-9;
+    for (let a = 0; a < arcs.length; a++) {
+      if (chosen.includes(a)) continue;
+      const g = total([...chosen, a]) - now;
+      if (g > gain) [gain, pick] = [g, a];
+    }
+    if (pick < 0) break;
+    chosen.push(pick);
+  }
+  for (let pass = 0; pass < Math.round(o.swaps); pass++) {
+    let better = false;
+    for (let i = 0; i < chosen.length; i++) {
+      const now = total(chosen);
+      let pick = -1;
+      let gain = 1e-9;
+      for (let a = 0; a < arcs.length; a++) {
+        if (chosen.includes(a)) continue;
+        const next = chosen.map((x, j) => (j === i ? a : x));
+        const g = total(next) - now;
+        if (g > gain) [gain, pick] = [g, a];
+      }
+      if (pick >= 0) {
+        chosen[i] = pick;
+        better = true;
+      }
+    }
+    if (!better) break;
+  }
+  // Each edge rides its best arc.
+  const riders = new Map<number, { edge: string; ride: Ride; points: Point[] }[]>();
+  plugs.forEach(({ edge, ps, pt }, e) => {
+    let best = -1;
+    for (const a of chosen) if ((rides[a]![e]?.save ?? 0) > (best < 0 ? 0 : rides[best]![e]!.save)) best = a;
+    if (best < 0) return;
+    const ride = rides[best]![e]!;
+    const list = riders.get(best) ?? [];
+    list.push({ edge: edge.id, ride, points: [ps.point, ...spinePart(arcs[best]!, ride.on, ride.off), pt.point] });
+    riders.set(best, list);
+  });
+  const highways: Highway[] = [];
+  for (const a of [...chosen].sort((x, y) => x - y)) {
+    const list = riders.get(a) ?? [];
+    if (list.length < Math.max(2, o.minSize)) continue;
+    const spine = arcs[a]!;
+    const lanes = orderLanes(spine, list.map((r) => ({ edge: r.edge, points: r.points })), "bundle");
+    const byEdge = new Map(list.map((r) => [r.edge, r.ride]));
+    highways.push({
+      id: `h${highways.length}`,
+      key: `a${a}`,
+      spine,
+      lanes,
+      members: lanes.map((edge) => memberAt(spine, edge, byEdge.get(edge)!.on, byEdge.get(edge)!.off)),
+    });
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/index.ts

@@ -19,4 +19,19 @@ export { FLOW_FIELD_DEFAULTS, flowFieldPlan, type FieldEnd, type FlowFieldOption
 export { SplitTree, WSPD_DEFAULTS, wspdGroups, wspdPlan, type SplitCell, type WspdOptions } from "./wspd/index.ts";
 export { OD_CELL_DEFAULTS, odCellPlan, odGroups, type OdCellOptions } from "./od-cells/index.ts";
 export { CANDIDATE_SOURCES, candidatePlan, candidateScore, SELECT_DEFAULTS, selectPlan, type CandidateSource, type SelectOptions } from "./select/index.ts";
+export { MINGLE_DEFAULTS, mingleBundles, minglePlan, type MingleOptions } from "./mingle/index.ts";
+export { SPIRAL_DEFAULTS, spiralJoin, spiralPlan, spiralTree, type SpiralNode, type SpiralOptions } from "./spiral/index.ts";
+export { FLOW_CLUSTER_DEFAULTS, flowClusterPlan, flowClusters, flowDistance, chainClusters, LINKAGES, type FlowClusterOptions, type Linkage } from "./flow-clusters/index.ts";
+export { characteristicPoints, representative, segmentClusters, segmentDistance, TRACLUS_DEFAULTS, traclusPlan, type RouteSegment, type TraclusOptions } from "./traclus/index.ts";
+export { DIFFUSION_DEFAULTS, diffusionPlan, linkDensity, type DiffusionOptions } from "./diffusion/index.ts";
+export { NESTED_DEFAULTS, nestedGroups, nestedPlan, nestingViolations, type NestedOptions } from "./nested/index.ts";
+export { channelOverflows, LANES_DEFAULTS, lanesPlan, type LanesOptions } from "./lanes/index.ts";
+export { GROWTH_DEFAULTS, growthPlan, type GrowthOptions, type GrowthOrder } from "./growth/index.ts";
+export { EDGE_PATH_DEFAULTS, edgePathPlan, edgePaths, type EdgePathOptions, type PathStep } from "./edge-paths/index.ts";
+export { SOFT_KEY_DEFAULTS, softDistance, softKeyClusters, softKeyPlan, type SoftKeyOptions } from "./soft-keys/index.ts";
+export { linePoint, snapPlan, spinePart, type SnapLine, type SnapMember, type SnapOptions } from "./snap.ts";
+export { HOUGH_DEFAULTS, houghLines, houghPeaks, houghPlan, type HoughOptions, type HoughPeak } from "./hough/index.ts";
+export { densityRidges, lineDensity, RIDGE_DEFAULTS, ridgeLines, ridgePlan, type DensityImage, type Ridge, type RidgeOptions, type RidgeSource } from "./ridges/index.ts";
+export { compatibility, EDGE_DISTANCES, HDBSCAN_DEFAULTS, hdbscanClusters, hdbscanLabels, hdbscanPlan, type EdgeDistance, type HdbscanOptions } from "./hdbscan/index.ts";
+export { ARC_SOURCES, candidateArcs, HUB_ARC_DEFAULTS, hubArcPlan, type ArcSource, type HubArcOptions } from "./hub-arcs/index.ts";
 export * from "./gates/index.ts";

package/src/highways/lanes/index.ts

@@ -0,0 +1,189 @@
+import { channelWidth } from "../../channels.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import type { Graph } from "../../model.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, nearestPlace, tidyPlan, type HighwayBase } from "../base.ts";
+import { memberAt, pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `lanes` (HWY-051 of the note on highways). */
+export interface LanesOptions {
+  /** 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 plan that the strategy changes. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The gap between two lanes. The default is 4. */
+  readonly laneGap: number;
+  /** The largest width of a highway. The default is 32. */
+  readonly maxWidth: number;
+  /** The number of times that a highway can split, one half after the other. The default is 3. */
+  readonly depth: number;
+}
+
+/** The default options of the strategy `lanes`. */
+export const LANES_DEFAULTS: Readonly<LanesOptions> = Object.freeze({ from: "shared-ways", laneGap: 4, maxWidth: 32, depth: 3 });
+
+/** The cost factor of a link that is too narrow for the lanes, for the way of the second half. */
+const NARROW_COST = 8;
+
+/** This function gives the number of lanes of a highway on each leg of its spine. A lane is a member whose part on the spine holds the leg. */
+function lanesOnLegs(h: Highway): number[] {
+  const legs = new Array<number>(Math.max(0, h.spine.length - 1)).fill(0);
+  for (const m of h.members) {
+    const lo = Math.min(m.on, m.off);
+    const hi = Math.max(m.on, m.off);
+    for (let i = 0; i < legs.length; i++) if (lo < i + 1 && hi > i) legs[i]!++;
+  }
+  return legs;
+}
+
+/** This function gives the width of `n` lanes. */
+const widthOf = (n: number, o: Readonly<LanesOptions>): number => Math.min(o.maxWidth, n * o.laneGap);
+
+/**
+ * This function gives the number of legs of the spines of a plan where the lanes do not fit in the channel.
+ * A leg with two lanes or more needs `min(maxWidth, lanes × laneGap)`. The channel is the free space across the leg (`channelWidth`).
+ */
+export function channelOverflows(graph: Graph, plan: HighwayPlan, o: Readonly<Pick<LanesOptions, "laneGap" | "maxWidth" | "margin" | "k">>): number {
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const full = { from: "none" as const, depth: 0, ...o };
+  let n = 0;
+  for (const h of plan.highways) {
+    const legs = lanesOnLegs(h);
+    legs.forEach((count, i) => {
+      if (count > 1 && channelWidth(finder.obstacles, h.spine[i]!, h.spine[i + 1]!) < widthOf(count, full)) n++;
+    });
+  }
+  return n;
+}
+
+/**
+ * This function gives the plan of `from`, with each highway that does not fit in its channels split in two (HWY-051).
+ * The lanes split into two halves by lane order. The first half keeps the spine. The second half gets a new spine through the corners, where the narrow links cost more.
+ * A highway with fewer than four lanes moves as one to the new spine.
+ * A half that still does not fit splits again, up to `depth` times. A new spine needs a shorter length of narrow legs than the old spine.
+ */
+export function lanesPlan(input: HighwayInput, o: Readonly<LanesOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const corners = finder.corners;
+  const widths = new Map<string, number>();
+  const channel = (a: Point, b: Point): number => {
+    const key = a.x < b.x || (a.x === b.x && a.y <= b.y) ? `${a.x},${a.y},${b.x},${b.y}` : `${b.x},${b.y},${a.x},${a.y}`;
+    let w = widths.get(key);
+    if (w === undefined) widths.set(key, (w = channelWidth(finder.obstacles, a, b)));
+    return w;
+  };
+  const narrowLegs = (h: Highway): number[] => {
+    const out: number[] = [];
+    lanesOnLegs(h).forEach((count, i) => {
+      if (count > 1 && channel(h.spine[i]!, h.spine[i + 1]!) < widthOf(count, o)) out.push(i);
+    });
+    return out;
+  };
+  // The length of the legs of a spine that are too narrow for `need`.
+  const tight = (spine: readonly Point[], need: number): number => spine.reduce((n, p, i) => (i > 0 && channel(spine[i - 1]!, p) < need ? n + dist(spine[i - 1]!, p) : n), 0);
+
+  const pad = finder.margin / 2;
+  const reach = 2 * (o.k ?? 8);
+  /**
+   * This function gives the cheapest way from `from` to `to` through the corners (Dijkstra). A link narrower than `need` costs `NARROW_COST` times its length.
+   * Unlike `corners.path`, it also prices the first link and the last link, and it does not take the straight line without a price.
+   */
+  const detour = (from: Point, to: Point, need: number): Point[] | undefined => {
+    const pts: Point[] = [from, to];
+    const id = (j: number): number => j + 2;
+    const pointOf = (n: number): Point => (n < 2 ? pts[n]! : corners.points[n - 2]!);
+    const best = new Map<number, number>([[0, 0]]);
+    const parent = new Map<number, number>();
+    const done = new Set<number>();
+    const heap: [number, number][] = [[0, 0]];
+    const push = (c: number, n: number): void => {
+      heap.push([c, n]);
+      for (let i = heap.length - 1; i > 0; ) {
+        const up = (i - 1) >> 1;
+        if (heap[up]![0] <= heap[i]![0]) break;
+        [heap[up], heap[i]] = [heap[i]!, heap[up]!];
+        i = up;
+      }
+    };
+    const pop = (): [number, number] => {
+      const top = heap[0]!;
+      const last = heap.pop()!;
+      if (heap.length > 0) {
+        heap[0] = last;
+        for (let i = 0; ; ) {
+          const l = 2 * i + 1;
+          const r = l + 1;
+          let m = i;
+          if (l < heap.length && heap[l]![0] < heap[m]![0]) m = l;
+          if (r < heap.length && heap[r]![0] < heap[m]![0]) m = r;
+          if (m === i) break;
+          [heap[m], heap[i]] = [heap[i]!, heap[m]!];
+          i = m;
+        }
+      }
+      return top;
+    };
+    while (heap.length > 0 && done.size < 20_000) {
+      const [c, n] = pop();
+      if (done.has(n)) continue;
+      done.add(n);
+      if (n === 1) break;
+      const p = pointOf(n);
+      const next = corners.nearestVisible(p, reach, n >= 2 ? n - 2 : -1).map(id);
+      if (finder.obstacles.clear(p, to, pad)) next.push(1);
+      for (const m of next) {
+        if (done.has(m)) continue;
+        const q = pointOf(m);
+        const d = dist(p, q);
+        const g = c + (channel(p, q) < need ? d * NARROW_COST : d);
+        if (g < (best.get(m) ?? Infinity)) {
+          best.set(m, g);
+          parent.set(m, n);
+          push(g, m);
+        }
+      }
+    }
+    if (!done.has(1)) return undefined;
+    const out: Point[] = [];
+    for (let n: number | undefined = 1; n !== undefined; n = parent.get(n)) out.push(pointOf(n));
+    return out.reverse();
+  };
+
+  // This function moves the members to a new spine. A member whose two places meet on the new spine leaves the highway.
+  const move = (h: Highway, spine: readonly Point[], edges: readonly string[]): Highway => {
+    const byEdge = new Map(h.members.map((m) => [m.edge, m]));
+    const members: HighwayMember[] = [];
+    for (const edge of edges) {
+      const m = byEdge.get(edge)!;
+      const on = nearestPlace(spine, pointAt(h.spine, m.on));
+      const off = nearestPlace(spine, pointAt(h.spine, m.off));
+      if (Math.abs(on - off) < 1e-6) continue;
+      members.push({ ...memberAt(spine, edge, on, off), seq: m.seq });
+    }
+    return { ...h, spine, lanes: members.map((m) => m.edge), members };
+  };
+
+  const split = (h: Highway, depth: number): Highway[] => {
+    if (depth <= 0 || narrowLegs(h).length === 0) return [h];
+    // A highway with fewer than four lanes cannot give two halves of two lanes. All its lanes move to the new spine.
+    const half = h.lanes.length < 4 ? 0 : Math.ceil(h.lanes.length / 2);
+    const first = h.lanes.slice(0, half);
+    const second = h.lanes.slice(half);
+    const need = widthOf(second.length, o);
+    const from = h.spine[0]!;
+    const to = h.spine[h.spine.length - 1]!;
+    const raw = detour(from, to, need);
+    if (!raw) return [h];
+    const pulled = corners.pull(raw);
+    const spine = tight(pulled, need) <= tight(raw, need) ? pulled : raw;
+    if (spine.length < 2 || polylineLength(spine) <= finder.margin || tight(spine, need) >= tight(h.spine, need)) return [h];
+    const moved = move(h, spine, second);
+    if (first.length === 0) return split(moved, depth - 1);
+    return [...split(move(h, h.spine, first), depth - 1), ...split(moved, depth - 1)];
+  };
+
+  return tidyPlan({ highways: plan.highways.flatMap((h) => split(h, Math.max(0, Math.round(o.depth)))) });
+}

package/src/highways/mingle/index.ts

@@ -0,0 +1,171 @@
+import { dist, type Point } from "../../geom.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+import { meetingPoints } from "../weiszfeld/index.ts";
+
+/** The options of the highway strategy `mingle` (HWY-003 of the note on highways). */
+export interface MingleOptions {
+  /** Each bundle looks for a merge among this number of nearest bundles in 4D. The default is 8. */
+  readonly k: number;
+  /** The largest turn of an edge at a meeting point, in degrees. A larger turn moves the meeting point along the trunk. The default is 40. */
+  readonly maxTurn: number;
+  /** The number of levels of merges. The default is 6. */
+  readonly levels: number;
+  /** The weight of the trunk in the ink. With 1, the trunk costs its length one time. The default is 1. */
+  readonly weight: number;
+  /** A bundle with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each bundle. The default is `trunk`: one trunk between the two meeting points. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `mingle`. */
+export const MINGLE_DEFAULTS: Readonly<MingleOptions> = Object.freeze({ k: 8, maxTurn: 40, levels: 6, weight: 1, minSize: 2, spine: "trunk" });
+
+/** One bundle of MINGLE: its edges with their direction, the ends on each side, the two meeting points and the ink. */
+interface Bundle {
+  readonly edges: readonly { readonly edge: string; readonly flip: boolean }[];
+  readonly a: readonly Point[];
+  readonly b: readonly Point[];
+  readonly m1: Point;
+  readonly m2: Point;
+  readonly ink: number;
+}
+
+/** The number of steps of Weiszfeld for the meeting points of a bundle. */
+const STEPS = 12;
+
+/** This function gives the turn in degrees from the direction `p` to `q` to the direction `q` to `r`. A leg of length 0 gives no turn. */
+function turnAt(p: Point, q: Point, r: Point): number {
+  const ux = q.x - p.x;
+  const uy = q.y - p.y;
+  const vx = r.x - q.x;
+  const vy = r.y - q.y;
+  if (Math.hypot(ux, uy) < 1e-9 || Math.hypot(vx, vy) < 1e-9) return 0;
+  return (Math.abs(Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy)) * 180) / Math.PI;
+}
+
+/** The number of steps of the bisection that moves a meeting point to the turn limit. */
+const SLIDE_STEPS = 24;
+
+/** This function gives the point at the share `t` of the way from `p` to `q`. */
+function lerp(p: Point, q: Point, t: number): Point {
+  return { x: p.x + t * (q.x - p.x), y: p.y + t * (q.y - p.y) };
+}
+
+/**
+ * This function moves the meeting point `m` along the trunk to the meeting point `far`. It stops when each end of `ends` turns at most `maxTurn` degrees at `m`.
+ * The turn of each end gets smaller when `m` moves to `far`, so a bisection finds the smallest move. The point stays at most at the middle of the trunk.
+ * The function gives `undefined` when the middle of the trunk does not obey the limit.
+ */
+function slide(m: Point, far: Point, ends: readonly Point[], maxTurn: number): Point | undefined {
+  const worst = (p: Point): number => Math.max(...ends.map((e) => turnAt(e, p, far)));
+  if (worst(m) <= maxTurn) return m;
+  if (worst(lerp(m, far, 0.5)) > maxTurn) return undefined;
+  let lo = 0;
+  let hi = 0.5;
+  for (let s = 0; s < SLIDE_STEPS; s++) {
+    const mid = (lo + hi) / 2;
+    if (worst(lerp(m, far, mid)) <= maxTurn) hi = mid;
+    else lo = mid;
+  }
+  return lerp(m, far, hi);
+}
+
+/**
+ * This function gives the bundle of the ends `a` and `b`, with its meeting points and its ink. A turn that is too large gives `undefined`.
+ * The ink is `Σ |a_i - M1| + w |M1 - M2| + Σ |M2 - b_i|`. Each edge turns at most `maxTurn` degrees at `M1` and at `M2`.
+ * As in MINGLE, a meeting point with a larger turn moves along the trunk to the other meeting point, until the turns obey the limit.
+ */
+function bundleOf(edges: Bundle["edges"], a: readonly Point[], b: readonly Point[], o: Readonly<MingleOptions>): Bundle | undefined {
+  const [w1, w2] = meetingPoints(a, b, o.weight, STEPS);
+  if (dist(w1, w2) < 1e-6) return undefined;
+  const m1 = slide(w1, w2, a, o.maxTurn);
+  const m2 = slide(w2, w1, b, o.maxTurn);
+  if (!m1 || !m2) return undefined;
+  let ink = o.weight * dist(m1, m2);
+  for (let i = 0; i < a.length; i++) ink += dist(a[i]!, m1) + dist(m2, b[i]!);
+  return { edges, a, b, m1, m2, ink };
+}
+
+/** This function gives the bundle of `p` and `q`, with `q` turned around when `flip` is `true`. */
+function merged(p: Bundle, q: Bundle, flip: boolean, o: Readonly<MingleOptions>): Bundle | undefined {
+  const edges = [...p.edges, ...q.edges.map((e) => ({ edge: e.edge, flip: e.flip !== flip }))];
+  return bundleOf(edges, [...p.a, ...(flip ? q.b : q.a)], [...p.b, ...(flip ? q.a : q.b)], o);
+}
+
+/** This function gives the 4D distance of two bundles by their meeting points, and `flip` when the opposite direction is nearer. */
+function distance4(p: Bundle, q: Bundle): { d: number; flip: boolean } {
+  const direct = Math.hypot(dist(p.m1, q.m1), dist(p.m2, q.m2));
+  const back = Math.hypot(dist(p.m1, q.m2), dist(p.m2, q.m1));
+  return back < direct ? { d: back, flip: true } : { d: direct, flip: false };
+}
+
+/**
+ * This function gives the bundles of MINGLE (Gansner, Hu, North and Scheidegger 2011) as groups of edges.
+ * Each edge is a point in 4D: its two plugs. At each level, each bundle examines its `k` nearest bundles in 4D.
+ * A merge saves ink when the ink of the joint bundle is less than the sum of the two inks. The merges with the largest gain go first.
+ * A bundle merges one time at most in a level. The levels stop after `levels` levels, or when no merge saves ink.
+ */
+export function mingleBundles(input: HighwayInput, o: Readonly<MingleOptions>): Map<string, EdgeGroup> {
+  let bundles: Bundle[] = edgePlugs(input.graph).map(({ edge, ps, pt }) => ({
+    edges: [{ edge: edge.id, flip: false }],
+    a: [ps.point],
+    b: [pt.point],
+    m1: ps.point,
+    m2: pt.point,
+    ink: dist(ps.point, pt.point),
+  }));
+  const k = Math.max(1, Math.round(o.k));
+  for (let level = 0; level < Math.round(o.levels); level++) {
+    const offers: { i: number; j: number; gain: number; joint: Bundle }[] = [];
+    const tried = new Set<number>();
+    const n = bundles.length;
+    bundles.forEach((p, i) => {
+      const near = bundles
+        .map((q, j) => ({ j, ...distance4(p, q) }))
+        .filter((x) => x.j !== i)
+        .sort((x, y) => x.d - y.d || x.j - y.j)
+        .slice(0, k);
+      for (const { j, flip } of near) {
+        const lo = Math.min(i, j);
+        const hi = Math.max(i, j);
+        if (tried.has(lo * n + hi)) continue;
+        tried.add(lo * n + hi);
+        const joint = merged(bundles[lo]!, bundles[hi]!, flip, o);
+        if (!joint) continue;
+        const gain = bundles[lo]!.ink + bundles[hi]!.ink - joint.ink;
+        if (gain > 1e-9) offers.push({ i: lo, j: hi, gain, joint });
+      }
+    });
+    if (offers.length === 0) break;
+    offers.sort((x, y) => y.gain - x.gain || x.i - y.i || x.j - y.j);
+    const used = new Set<number>();
+    const next: Bundle[] = [];
+    for (const x of offers) {
+      if (used.has(x.i) || used.has(x.j)) continue;
+      used.add(x.i);
+      used.add(x.j);
+      next.push(x.joint);
+    }
+    bundles.forEach((p, i) => {
+      if (!used.has(i)) next.push(p);
+    });
+    bundles = next;
+  }
+  const groups = new Map<string, EdgeGroup>();
+  bundles.forEach((p, i) => {
+    for (const e of p.edges) groups.set(e.edge, { key: `m${i}`, flip: e.flip });
+  });
+  return groups;
+}
+
+/**
+ * This function gives the highways of MINGLE (HWY-003). The bundles of `mingleBundles` with `minSize` edges or more get highways.
+ * With the spine `trunk`, each bundle gets one trunk between its two meeting points, through the corner graph.
+ * With `shared`, the edges of each bundle share their ways through the corner graph.
+ */
+export function minglePlan(input: HighwayInput, o: Readonly<MingleOptions>): HighwayPlan {
+  return groupedPlan(input, mingleBundles(input, o), { spine: o.spine, minSize: o.minSize });
+}