@mark1russell7/highways 0.4.1 → 0.5.0

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/level-links/index.ts

@@ -0,0 +1,114 @@
+import { dist, pointBoxDistance, polylineLength, type Point } from "../../geom.ts";
+import { levelLinks, type ItemPair } from "../../levels.ts";
+import { nodeIndex } from "../../model.ts";
+import { buildSections, levelCut } from "../../sections.ts";
+import { WayFinder } from "../../ways.ts";
+import { basePlan, firstRoutes, tidyPlan, type HighwayBase } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `level-links` (HWY-056 with WILD-034 of the notes). */
+export interface LevelHighwayOptions {
+  /** The plan of the edges that do not ride a level link. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The depth of the level in the tree of sections. Depth 1 is the level below the root. The default is 1. */
+  readonly depth: number;
+  /** A level link becomes a highway when this number of edges or more ride it. The default is 2. */
+  readonly minSize: number;
+  /** An edge rides the link only when its way along the link is this many times its first route, or shorter. The default is 1.5. */
+  readonly stretch: number;
+}
+
+/** The default options of the strategy `level-links`. */
+export const LEVEL_HIGHWAY_DEFAULTS: Readonly<LevelHighwayOptions> = Object.freeze({ from: "shared-ways", depth: 1, minSize: 2, stretch: 1.5 });
+
+/** This function gives the stretch of a polyline from the length `from` to the length `to`, along the polyline. */
+function cut(p: readonly Point[], from: number, to: number): Point[] {
+  const out: Point[] = [];
+  let walked = 0;
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    const len = dist(a, b);
+    const s = Math.max(from, walked);
+    const e = Math.min(to, walked + len);
+    if (e > s && len > 0) {
+      const at = (l: number): Point => ({ x: a.x + ((b.x - a.x) * (l - walked)) / len, y: a.y + ((b.y - a.y) * (l - walked)) / len });
+      if (out.length === 0) out.push(at(s));
+      out.push(at(e));
+    }
+    walked += len;
+  }
+  return out;
+}
+
+/**
+ * This function gives a highway for each link of a zoom level, with the edges between its two items (HWY-056, WILD-034).
+ * The level is the cut of the tree of sections at `depth`. The link goes around the boxes of the other items (`levelLinks`).
+ * The spine is the link without a margin at each end, so it stays off the boxes of the two items. It must stay out of each box.
+ * The edges between the two items, in each direction, ride the spine. The ramps go through the corner graph inside the items.
+ *
+ * An edge rides only when the ramps (as straight lines) and the spine are `stretch` times its first route, or shorter.
+ * A link with fewer than `minSize` such edges is not a highway. The other edges keep their highways of the plan `from`.
+ * Thus a zoom from the level to the routes shows the same lines, which open into lanes.
+ */
+export function levelHighwayPlan(input: HighwayInput, o: Readonly<LevelHighwayOptions>): HighwayPlan {
+  const graph = input.graph;
+  const base = basePlan(input, o.from);
+  if (graph.nodes.length === 0) return base;
+  const byId = nodeIndex(graph);
+  const root = buildSections(graph.nodes);
+  const { items, owner } = levelCut(graph.nodes, root, Math.max(0, Math.round(o.depth)));
+  const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+  // The edges between each pair of items, by the pair in the order of the items.
+  const between = new Map<string, { a: number; b: number; edges: { edge: string; forward: boolean }[] }>();
+  for (const e of graph.edges) {
+    const iu = indexOfNode.get(e.source.node);
+    const iv = indexOfNode.get(e.target.node);
+    if (iu === undefined || iv === undefined) continue;
+    const x = owner[iu]!;
+    const y = owner[iv]!;
+    if (x === y) continue;
+    const [a, b] = x < y ? [x, y] : [y, x];
+    const key = `${a}\u0000${b}`;
+    const pair = between.get(key) ?? { a, b, edges: [] };
+    pair.edges.push({ edge: e.id, forward: x === a });
+    between.set(key, pair);
+  }
+  const pairs = [...between.values()].filter((p) => p.edges.length >= Math.max(2, o.minSize));
+  if (pairs.length === 0) return base;
+  const itemPairs: ItemPair[] = pairs.map((p) => ({ source: items[p.a]!.id, target: items[p.b]!.id, count: p.edges.length }));
+  const links = levelLinks(items, itemPairs);
+  const linkOf = new Map(links.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+  const ways = new WayFinder(graph.nodes);
+  const first = firstRoutes(input);
+  const edgeOf = new Map(graph.edges.map((e) => [e.id, e]));
+  const added: Highway[] = [];
+  const riders = new Set<string>();
+  for (const p of pairs) {
+    const points = linkOf.get(`${items[p.a]!.id}\u0000${items[p.b]!.id}`);
+    if (!points || points.length < 2) continue;
+    const length = polylineLength(points);
+    if (length <= 4 * ways.margin) continue;
+    const spine = cut(points, ways.margin, length - ways.margin);
+    if (spine.length < 2 || !ways.obstacles.clearPath(spine, 1)) continue;
+    const head = spine[0]!;
+    const tail = spine[spine.length - 1]!;
+    const along = polylineLength(spine);
+    const members: HighwayMember[] = [];
+    for (const { edge, forward } of p.edges) {
+      const e = edgeOf.get(edge)!;
+      const s = byId.get(e.source.node)!;
+      const t = byId.get(e.target.node)!;
+      const [enter, leave] = forward ? [head, tail] : [tail, head];
+      const way = pointBoxDistance(enter, s.box) + along + pointBoxDistance(leave, t.box);
+      const own = polylineLength(first.get(edge) ?? []);
+      if (own > 0 && way > o.stretch * own) continue;
+      members.push(forward ? memberAt(spine, edge, 0, spine.length - 1) : memberAt(spine, edge, spine.length - 1, 0));
+    }
+    if (members.length < Math.max(2, o.minSize)) continue;
+    for (const m of members) riders.add(m.edge);
+    added.push({ id: "", key: `level${o.depth}:${items[p.a]!.id}:${items[p.b]!.id}`, spine, lanes: members.map((m) => m.edge), members });
+  }
+  const rest = base.highways.map((h) => ({ ...h, members: h.members.filter((m) => !riders.has(m.edge)) }));
+  return tidyPlan({ highways: [...rest, ...added] });
+}

package/src/highways/meet/index.ts

@@ -0,0 +1,84 @@
+import { dist, type Point } from "../../geom.ts";
+import { basePlan, firstRoutes, tidyPlan, type HighwayBase } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `meet` (HWY-050 of the note on highways). */
+export interface MeetOptions {
+  /** The plan whose merge points and split points the strategy moves. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** A first route meets the spine where it is this distance from the spine, or nearer. The default is 8: two lanes of 4. */
+  readonly near: number;
+  /** A first route meets the spine only where it runs at this angle to the spine, or less, in degrees. The default is 45. */
+  readonly maxTurn: number;
+  /** A member keeps its places when the stretch where its first route meets the spine is shorter than this length. The default is 10. */
+  readonly minRun: number;
+}
+
+/** The default options of the strategy `meet`. */
+export const MEET_DEFAULTS: Readonly<MeetOptions> = Object.freeze({ from: "shared-ways", near: 8, maxTurn: 45, minRun: 10 });
+
+/** This function gives the distance from a point to a polyline, and the unit direction of the nearest leg. */
+function nearestLeg(line: readonly Point[], p: Point): { d: number; ux: number; uy: number } {
+  let best = { d: Infinity, ux: 1, uy: 0 };
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const len = dist(a, b);
+    if (len <= 1e-9) continue;
+    const u = Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / (len * len)));
+    const d = dist(p, { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u });
+    if (d < best.d) best = { d, ux: (b.x - a.x) / len, uy: (b.y - a.y) / len };
+  }
+  return best;
+}
+
+/**
+ * This function gives a member with its merge point and its split point where its first route meets the spine and parts from it (HWY-050).
+ * The function samples the stretch of the member on the spine, at steps of `near / 2` or less.
+ * A sample meets the route when the route is `near` or nearer, and its nearest leg runs at `maxTurn` or less to the spine.
+ * The new merge point is the first sample that meets the route, in the direction of the member. The new split point is the last one.
+ * So the edge joins the spine late and leaves it early. The places only move inward.
+ * The member keeps its places when no sample meets the route, or when the met stretch is shorter than `minRun`.
+ */
+export function meetMember(spine: readonly Point[], member: HighwayMember, route: readonly Point[] | undefined, o: Readonly<MeetOptions>): HighwayMember {
+  if (!route || route.length < 2 || spine.length < 2) return member;
+  const lo = Math.min(member.on, member.off);
+  const hi = Math.max(member.on, member.off);
+  const cos = Math.cos((Math.max(0, Math.min(90, o.maxTurn)) * Math.PI) / 180);
+  const step = Math.max(1e-3, o.near / 2);
+  let first = Infinity;
+  let last = -Infinity;
+  for (let i = Math.floor(lo); i < Math.min(spine.length - 1, Math.ceil(hi)); i++) {
+    const from = Math.max(lo, i);
+    const to = Math.min(hi, i + 1);
+    if (to <= from) continue;
+    const a = spine[i]!;
+    const b = spine[i + 1]!;
+    const len = dist(a, b);
+    if (len <= 1e-9) continue;
+    const tx = (b.x - a.x) / len;
+    const ty = (b.y - a.y) / len;
+    const n = Math.min(256, Math.max(1, Math.ceil(((to - from) * len) / step)));
+    for (let j = 0; j <= n; j++) {
+      const at = from + ((to - from) * j) / n;
+      const leg = nearestLeg(route, pointAt(spine, at));
+      if (leg.d > o.near || Math.abs(leg.ux * tx + leg.uy * ty) < cos - 1e-12) continue;
+      first = Math.min(first, at);
+      last = Math.max(last, at);
+    }
+  }
+  if (!(last > first) || lengthBetween(spine, first, last) < o.minRun) return member;
+  return member.on <= member.off ? memberAt(spine, member.edge, first, last, member.seq) : memberAt(spine, member.edge, last, first, member.seq);
+}
+
+/**
+ * This function gives the highways of the plan `from`, with merge points and split points where the routes meet and part (HWY-050).
+ * The first route of each edge is the route of `input.routes`, or its route without highways.
+ * Each member gets the places of `meetMember`. The spines and the trips do not change.
+ */
+export function meetPlan(input: HighwayInput, o: Readonly<MeetOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  if (plan.highways.length === 0) return plan;
+  const first = firstRoutes(input);
+  return tidyPlan({ highways: plan.highways.map((h) => ({ ...h, members: h.members.map((m) => meetMember(h.spine, m, first.get(m.edge), o)) })) });
+}

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 });
+}

package/src/highways/model.ts

@@ -9,6 +9,11 @@ export interface HighwayInput {
    * The strategy `corridors` makes the ways of the corner graph, as the router `corners` finds them.
    */
   readonly routes?: Result;
+  /**
+   * This value is the graph before an edit and the plan of the same strategy on it. A strategy that keeps its highways stable over edits reads it.
+   * The gates `hysteresis` (HWY-046) and `ids` (HWY-054) read it. The other strategies ignore it.
+   */
+  readonly previous?: { readonly graph: Graph; readonly plan: HighwayPlan };
 }
 
 /**