@mark1russell7/highways 0.1.2 → 0.1.4

package/src/levels.ts

@@ -1,4 +1,4 @@
-import { center, dist, type Box, type Point } from "./geom.ts";
+import { center, dist, polylineLength, type Box, type Point } from "./geom.ts";
 import type { LevelItem, LevelLink, Node, Side } from "./model.ts";
 import { pointOnSide, SIDE_NORMAL, sideToward, type Plug } from "./plugs.ts";
 import { CornerGraph, Obstacles } from "./visibility.ts";
@@ -14,6 +14,23 @@ export interface ItemPair {
 /** The parts of a way finder that a link uses. */
 type Ways = Pick<WayFinder, "obstacles" | "corners" | "margin" | "out">;
 
+/** The free plugs of a node, and the reach of each plug. */
+interface FreePlugs {
+  readonly plugs: readonly Plug[];
+  readonly reach: readonly number[];
+}
+
+/** The ways of a level, with a second corner graph and the free plugs of the nodes. */
+interface LevelWays extends Ways {
+  /** This function gives a second corner graph with a small margin. The first link that needs it makes it. */
+  readonly tight: () => CornerGraph;
+  /** The free plugs of each node that a link needed. */
+  readonly free: Map<Node, FreePlugs>;
+}
+
+/** The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through. */
+const TIGHT_MARGIN = 1;
+
 const EPS = 1e-6;
 
 /**
@@ -58,23 +75,43 @@ export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair
     const [fs, ft] = facingPlugs(s.box, t.box, inset);
     let points = isFree(ways, s, fs) && isFree(ways, t, ft) ? quickWay(ways, ends(ways, s, fs, t, ft)) : undefined;
     // Else the link goes from the middle of a side. Each item has at most four such plugs, so the corner graph finds their ends one time.
-    points ??= squareWay(ways, ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box))));
+    points ??= sideWay(ways, s, t, inset);
     out.push({ source: p.source, target: p.target, count: p.count, points });
   }
   return out;
 }
 
+/**
+ * This function gives a way from plug to plug between the plugs at the middle of a side of the two nodes.
+ * Without a way in the corner graph, the link goes straight between the ends, with legs parallel to the axes where they are clear.
+ * When that line goes through another box, the link goes between the free plugs of the two nodes (`freeWay`) instead.
+ */
+function sideWay(ways: LevelWays, s: Node, t: Node, inset: number): Point[] {
+  const e = ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box)));
+  const quick = quickWay(ways, e);
+  if (quick) return quick;
+  const path = ways.corners.path(e.a, e.b);
+  const way = pulled(ways, e.ps, path ?? [e.a, e.b], e.pt);
+  if (path || ways.obstacles.clearPath(way, 0, new Set([s, t]))) return way;
+  return freeWay(ways, s, t, inset) ?? way;
+}
+
 /**
  * This function makes the obstacles and the corner graph of the items of a level.
  * The buckets of the obstacles grow with the items, so a long link visits few buckets.
+ * The corner graphs use `cones`, so a link goes along the corridors between the groups, not around the outer edge of the board.
  */
-function levelWays(nodes: readonly Node[], options: WayOptions): Ways {
+function levelWays(nodes: readonly Node[], options: WayOptions): LevelWays {
   const margin = options.margin ?? 5;
+  const k = options.k ?? 8;
   let size = 0;
   for (const n of nodes) size += Math.max(n.box.w, n.box.h);
   const obstacles = new Obstacles(nodes, Math.max(180, (2 * size) / Math.max(1, nodes.length)));
-  const corners = new CornerGraph(nodes, obstacles, { margin, k: options.k ?? 8 });
-  return { obstacles, corners, margin, out: (p) => ({ x: p.point.x + p.normal.x * margin, y: p.point.y + p.normal.y * margin }) };
+  const corners = new CornerGraph(nodes, obstacles, { margin, k, cones: true });
+  const out = (p: Plug): Point => ({ x: p.point.x + p.normal.x * margin, y: p.point.y + p.normal.y * margin });
+  let tight: CornerGraph | undefined;
+  const tightGraph = (): CornerGraph => (tight ??= new CornerGraph(nodes, obstacles, { margin: Math.min(margin, TIGHT_MARGIN), k, cones: true }));
+  return { obstacles, corners, margin, out, tight: tightGraph, free: new Map() };
 }
 
 /**
@@ -129,6 +166,105 @@ function sidePlug(ways: Ways, node: Node, toward: Point): Plug {
   return plug(order[0]!);
 }
 
+/**
+ * This function gives the free plugs of a node: on each side, the free point nearest to the middle of the side.
+ * A point is free when it and the point at `margin` from it are in no other box. The function keeps the plugs of each node.
+ */
+function freePlugs(ways: LevelWays, node: Node, inset: number): FreePlugs {
+  const known = ways.free.get(node);
+  if (known) return known;
+  const b = node.box;
+  const out: Plug[] = [];
+  for (const side of SIDES) {
+    const n = SIDE_NORMAL[side];
+    const across = n.x === 0;
+    // The side goes from `lo` to `hi` along its axis, at the coordinate `at` of the other axis.
+    const lo = across ? b.x : b.y;
+    const hi = across ? b.x + b.w : b.y + b.h;
+    const at = across ? (n.y > 0 ? b.y + b.h : b.y) : n.x > 0 ? b.x + b.w : b.x;
+    const far = at + (across ? n.y : n.x) * ways.margin;
+    // A box covers a point of the side when the point or its way out is inside the box, as in `isFree`.
+    const covered: [number, number][] = [];
+    const strip = across
+      ? { x: lo, y: Math.min(at, far), w: hi - lo, h: Math.abs(far - at) }
+      : { x: Math.min(at, far), y: lo, w: Math.abs(far - at), h: hi - lo };
+    ways.obstacles.query(strip, (m) => {
+      if (m === node) return;
+      const o = m.box;
+      const [o0, o1, p0, p1] = across ? [o.x, o.x + o.w, o.y, o.y + o.h] : [o.y, o.y + o.h, o.x, o.x + o.w];
+      if ((at > p0 && at < p1) || (far > p0 && far < p1)) covered.push([o0, o1]);
+    });
+    const mid = (lo + hi) / 2;
+    let best: number | undefined;
+    for (const [f0, f1] of freeSpans(lo, hi, covered)) {
+      const room = Math.min(inset, (f1 - f0) / 2);
+      const u = Math.max(f0 + room, Math.min(f1 - room, mid));
+      if (best === undefined || Math.abs(u - mid) < Math.abs(best - mid)) best = u;
+    }
+    if (best !== undefined) out.push({ point: across ? { x: best, y: at } : { x: at, y: best }, normal: n });
+  }
+  const free = { plugs: out, reach: out.map((p) => reach(ways, node, p)) };
+  ways.free.set(node, free);
+  return free;
+}
+
+/** This function gives the indices of the plugs, and the plugs that face `toward` most come first. */
+function facingOrder(plugs: readonly Plug[], from: Point, toward: Point): number[] {
+  const facing = (p: Plug): number => p.normal.x * (toward.x - from.x) + p.normal.y * (toward.y - from.y);
+  return plugs.map((_, i) => i).sort((u, v) => facing(plugs[v]!) - facing(plugs[u]!) || u - v);
+}
+
+/** This function gives the parts of the span from `lo` to `hi` outside each open interval of `covered`. A part of zero length does not count. */
+function freeSpans(lo: number, hi: number, covered: [number, number][]): [number, number][] {
+  covered.sort((u, v) => u[0] - v[0]);
+  const out: [number, number][] = [];
+  let x = lo;
+  for (const [c0, c1] of covered) {
+    if (c0 > x) out.push([x, Math.min(c0, hi)]);
+    x = Math.max(x, c1);
+    if (x >= hi) break;
+  }
+  if (x < hi) out.push([x, hi]);
+  return out.filter(([a, b]) => b - a > EPS);
+}
+
+/**
+ * This function gives the shortest way between the free plugs of the two nodes, or `undefined` when the second corner graph has none.
+ * A link uses it when its plugs at the middle of a side find no way. Other boxes can cover such a plug, or close the space in front of it.
+ */
+function freeWay(ways: LevelWays, s: Node, t: Node, inset: number): Point[] | undefined {
+  const fs = freePlugs(ways, s, inset);
+  const ft = freePlugs(ways, t, inset);
+  const cs = center(s.box);
+  const ct = center(t.box);
+  const is = facingOrder(fs.plugs, cs, ct);
+  const it = facingOrder(ft.plugs, ct, cs);
+  const from = is.map((i) => fs.plugs[i]!);
+  const to = it.map((k) => ft.plugs[k]!);
+  const ra = is.map((i) => fs.reach[i]!);
+  const rb = it.map((k) => ft.reach[k]!);
+  // A pair of plugs with one or two clear legs between them gives the short way.
+  let best: Point[] | undefined;
+  let bestLength = Infinity;
+  from.forEach((ps, i) =>
+    to.forEach((pt, k) => {
+      const way = quickWay(ways, endsAt(ps, ra[i]!, pt, rb[k]!));
+      const length = way ? polylineLength(way) : Infinity;
+      if (length < bestLength) {
+        best = way;
+        bestLength = length;
+      }
+    }),
+  );
+  if (best) return best;
+  // Else one search of the second corner graph finds the shortest way from a plug of `s` to a plug of `t`.
+  // The corners of the second graph are near the boxes, so the way can go through a gap that is narrower than the margin.
+  const a = from.map((ps, i) => ({ point: along(ps, ra[i]!), cost: ra[i]! }));
+  const b = to.map((pt, k) => ({ point: along(pt, rb[k]!), cost: rb[k]! }));
+  const found = ways.tight().pathAmong(a, b);
+  return found && pulled(ways, from[found.from]!, found.points, to[found.to]!);
+}
+
 /** The two ends of a link: each plug, and the point where the link turns away from the normal of the plug. */
 interface Ends {
   readonly ps: Plug;
@@ -143,8 +279,11 @@ interface Ends {
  * Two plugs that face each other across a narrow space make the link turn in the middle of that space.
  */
 function ends(ways: Ways, s: Node, ps: Plug, t: Node, pt: Plug): Ends {
-  let ra = reach(ways, s, ps);
-  let rb = reach(ways, t, pt);
+  return endsAt(ps, reach(ways, s, ps), pt, reach(ways, t, pt));
+}
+
+/** This function gives the ends of a link from the plug `ps` to the plug `pt`, with the reach of each plug. */
+function endsAt(ps: Plug, ra: number, pt: Plug, rb: number): Ends {
   // Two plugs that face each other turn at the same distance, so the link does not go past itself.
   if (ps.normal.x === -pt.normal.x && ps.normal.y === -pt.normal.y) {
     const d = (pt.point.x - ps.point.x) * ps.normal.x + (pt.point.y - ps.point.y) * ps.normal.y;
@@ -182,14 +321,12 @@ function quickWay(ways: Ways, e: Ends): Point[] | undefined {
 }
 
 /**
- * This function gives a way from plug to plug through the corner graph. The way leaves and enters each plug along its normal.
- * Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
+ * This function gives a way from the plug `ps` through the points of `path` to the plug `pt`.
+ * The way leaves and enters each plug along its normal. Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
  */
-function squareWay(ways: Ways, e: Ends): Point[] {
-  const quick = quickWay(ways, e);
-  if (quick) return quick;
-  const legs = squarePull(ways.corners.path(e.a, e.b) ?? [e.a, e.b], ways.obstacles, ways.margin / 2, axisOf(e.ps.normal), axisOf(e.pt.normal));
-  return tidy([e.ps.point, ...legs, e.pt.point]);
+function pulled(ways: Ways, ps: Plug, path: readonly Point[], pt: Plug): Point[] {
+  const legs = squarePull(path, ways.obstacles, ways.margin / 2, axisOf(ps.normal), axisOf(pt.normal));
+  return tidy([ps.point, ...legs, pt.point]);
 }
 
 type Axis = "x" | "y";

package/src/room/index.ts

@@ -0,0 +1,334 @@
+import { center, type Box, type Point } from "../geom.ts";
+import { levelLinks } from "../levels.ts";
+import type { Edge, Graph, Router } from "../model.ts";
+
+/** An item with a box: a node of a graph, an item of a level or a box of a host layout. */
+export interface Boxed {
+  readonly id: string;
+  readonly box: Box;
+}
+
+/** A link between two boxes. For a bundled link, `count` is the number of its edges. The default count is 1. */
+export interface RoomLink {
+  readonly source: string;
+  readonly target: string;
+  readonly count?: number;
+}
+
+/**
+ * A gap of a board: a boundary of the sweep over the left or top edges of the boxes.
+ * On the axis `x`, the gap is a vertical channel between two columns. On the axis `y`, it is a horizontal channel between two rows.
+ */
+export interface Gap {
+  readonly axis: "x" | "y";
+  /** The place of the gap in the order of the gaps on its axis, from 0. */
+  readonly index: number;
+  /** The coordinate where the boxes after the gap start, on the axis of the gap. */
+  readonly at: number;
+  /** The ids of the boxes that end at the near side of the gap. */
+  readonly before: readonly string[];
+  /** The ids of the boxes that start at the far side of the gap, at `at`. */
+  readonly after: readonly string[];
+  /** The current width of the gap: the distance from the nearest box edge before the gap to `at`. */
+  readonly width: number;
+  /** The number of lanes that the links need in the gap. */
+  readonly lanes: number;
+  /** The width that the gap needs: at least the current width, and at least `gutter + lanes × spacing`. */
+  readonly need: number;
+}
+
+/** The ways that `roomDemand` finds the lanes of each gap. */
+export type RoomMethod = "routes" | "lines";
+
+/** The options of `roomDemand` and `makeRoom`. */
+export interface RoomOptions {
+  /** The smallest width of each gap. The default is 8. */
+  readonly gutter?: number;
+  /** The width of one lane: the distance between two lines that run side by side. The default is 4. */
+  readonly spacing?: number;
+  /**
+   * The largest growth of the board on each axis, as a share of its size. The default is `Infinity`.
+   * When the lanes need more, each gap gets its gutter, and the lanes share the rest in proportion.
+   */
+  readonly maxGrowth?: number;
+  /**
+   * The way to find the lanes. The default is `routes`.
+   * With `routes`, the function routes the links one time on the board with each gap open to the gutter.
+   * The lanes of a gap are the most routes that run along the gap side by side.
+   * With `lines`, the lanes of a gap are the straight lines between the centers of the boxes that cross the gap.
+   */
+  readonly method?: RoomMethod;
+  /** The router of the method `routes`. Without it, the links go as the links of a zoom level (`levelLinks`), with the margin `gutter / 2`. */
+  readonly router?: Router;
+  /** With `count`, a link takes one lane for each of its edges. With `link`, the default, a link takes one lane. */
+  readonly lanes?: "link" | "count";
+  /** Two box edges nearer than this distance make one boundary of the sweep. The default is 0.5. */
+  readonly snap?: number;
+}
+
+/** The demand of a board and the board with its gaps open. */
+export interface Room<T extends Boxed> {
+  readonly gaps: readonly Gap[];
+  readonly items: T[];
+}
+
+const DEFAULT_GUTTER = 8;
+const DEFAULT_SPACING = 4;
+const DEFAULT_SNAP = 0.5;
+
+type Axis = "x" | "y";
+
+const lo = (b: Box, a: Axis): number => (a === "x" ? b.x : b.y);
+const len = (b: Box, a: Axis): number => (a === "x" ? b.w : b.h);
+const other = (a: Axis): Axis => (a === "x" ? "y" : "x");
+
+/**
+ * This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+ * Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
+ */
+export function boardGaps(items: readonly Boxed[], snap: number = DEFAULT_SNAP): Gap[] {
+  return [...axisGaps(items, "x", snap), ...axisGaps(items, "y", snap)];
+}
+
+function axisGaps(items: readonly Boxed[], axis: Axis, snap: number): Gap[] {
+  const starts = [...new Set(items.map((i) => lo(i.box, axis)))].sort((u, v) => u - v);
+  const bounds: number[] = [];
+  for (const s of starts) if (bounds.length === 0 || s - bounds[bounds.length - 1]! > snap) bounds.push(s);
+  const after: string[][] = bounds.map(() => []);
+  for (const i of items) after[lastAtOrBefore(bounds, lo(i.box, axis) + snap)]!.push(i.id);
+  const ends = items.map((i) => ({ id: i.id, end: lo(i.box, axis) + len(i.box, axis) })).sort((u, v) => u.end - v.end);
+  const gaps: Gap[] = [];
+  let k = 0;
+  for (let n = 1; n < bounds.length; n++) {
+    const at = bounds[n]!;
+    // The nearest box edge before the gap is the largest end at or before the boundary.
+    while (k < ends.length && ends[k]!.end <= at + snap) k++;
+    const near = k > 0 ? ends[k - 1]!.end : at;
+    const before: string[] = [];
+    for (let j = k - 1; j >= 0 && ends[j]!.end >= near - snap; j--) before.push(ends[j]!.id);
+    gaps.push({ axis, index: n - 1, at, before: before.reverse(), after: after[n]!, width: Math.max(0, at - near), lanes: 0, need: Math.max(0, at - near) });
+  }
+  return gaps;
+}
+
+/** This function gives the index of the last value of the sorted list `v` that is at or before `x`, or 0. */
+function lastAtOrBefore(v: readonly number[], x: number): number {
+  let a = 0;
+  let b = v.length - 1;
+  while (a < b) {
+    const m = (a + b + 1) >> 1;
+    if (v[m]! <= x) a = m;
+    else b = m - 1;
+  }
+  return a;
+}
+
+/**
+ * This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+ * A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+ * The function moves no box nearer to another box, so it makes no overlap.
+ */
+export function openGaps<T extends Boxed>(items: readonly T[], gaps: readonly Gap[], snap: number = DEFAULT_SNAP): T[] {
+  const shift = (axis: Axis): ((v: number) => number) => {
+    const list = gaps.filter((g) => g.axis === axis).sort((u, v) => u.at - v.at);
+    const at = list.map((g) => g.at);
+    const sum: number[] = [];
+    let s = 0;
+    for (const g of list) sum.push((s += Math.max(0, g.need - g.width)));
+    return (v) => (list.length === 0 || at[0]! > v + snap ? 0 : sum[lastAtOrBefore(at, v + snap)]!);
+  };
+  const sx = shift("x");
+  const sy = shift("y");
+  return items.map((i) => ({ ...i, box: { ...i.box, x: i.box.x + sx(i.box.x), y: i.box.y + sy(i.box.y) } }));
+}
+
+/**
+ * This function gives the room that the links need in each gap of the board.
+ * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+ */
+export function roomDemand(items: readonly Boxed[], links: readonly RoomLink[], options: RoomOptions = {}): Gap[] {
+  const gutter = options.gutter ?? DEFAULT_GUTTER;
+  const spacing = options.spacing ?? DEFAULT_SPACING;
+  const snap = options.snap ?? DEFAULT_SNAP;
+  const weight = (l: RoomLink): number => (options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1);
+  const gaps = boardGaps(items, snap);
+  const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
+  const raw = gaps.map((g, i) => ({ ...g, lanes: lanes[i]!, need: Math.max(g.width, gutter + lanes[i]! * spacing) }));
+  return capGrowth(items, raw, gutter, options.maxGrowth ?? Infinity);
+}
+
+/** This function gives the demand of the board and the board with each gap open to its need. */
+export function makeRoom<T extends Boxed>(items: readonly T[], links: readonly RoomLink[], options: RoomOptions = {}): Room<T> {
+  const gaps = roomDemand(items, links, options);
+  return { gaps, items: openGaps(items, gaps, options.snap ?? DEFAULT_SNAP) };
+}
+
+/** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
+export function roomLinks(graph: Graph): RoomLink[] {
+  const byPair = new Map<string, { source: string; target: string; count: number }>();
+  for (const e of graph.edges) {
+    const [s, t] = [e.source.node, e.target.node];
+    if (s === t) continue;
+    const key = s < t ? `${s}\u0000${t}` : `${t}\u0000${s}`;
+    const known = byPair.get(key);
+    if (known) known.count++;
+    else byPair.set(key, { source: s, target: t, count: 1 });
+  }
+  return [...byPair.values()];
+}
+
+/** This function counts, for each gap, the straight lines between the centers of the boxes of a link that cross the gap. */
+function lineLanes(items: readonly Boxed[], links: readonly RoomLink[], gaps: readonly Gap[], weight: (l: RoomLink) => number): number[] {
+  const byId = new Map(items.map((i) => [i.id, center(i.box)]));
+  return gaps.map((g) => {
+    let n = 0;
+    for (const l of links) {
+      const a = byId.get(l.source);
+      const b = byId.get(l.target);
+      if (a && b && Math.min(a[g.axis], b[g.axis]) < g.at && Math.max(a[g.axis], b[g.axis]) > g.at) n += weight(l);
+    }
+    return n;
+  });
+}
+
+/**
+ * This function routes the links one time on the board with each gap open to the gutter.
+ * The lanes of a gap are the largest number of routes that run along the gap at one place.
+ * A piece of a route goes along a gap when it is in the channel of the gap.
+ * It must also go farther along the gap than across it.
+ */
+function routeLanes(
+  items: readonly Boxed[],
+  links: readonly RoomLink[],
+  gaps: readonly Gap[],
+  gutter: number,
+  snap: number,
+  weight: (l: RoomLink) => number,
+  router: Router | undefined,
+): number[] {
+  const probeGaps = gaps.map((g) => ({ ...g, need: Math.max(g.width, gutter) }));
+  const probe = openGaps(items, probeGaps, snap);
+  const ways = probeWays(probe, links, gutter, router);
+  return probeGaps.map((g) => {
+    // The channel of the gap on the probe board: its far side moves with the growth of each gap up to this one.
+    let grow = 0;
+    for (const h of probeGaps) if (h.axis === g.axis && h.at <= g.at + snap) grow += h.need - h.width;
+    const hi = g.at + grow;
+    const lo = hi - g.need;
+    const spans: { from: number; to: number; w: number }[] = [];
+    ways.forEach((points, i) => {
+      const along = alongSpans(points, g.axis, lo, hi);
+      for (const [from, to] of merge(along)) spans.push({ from, to, w: weight(links[i]!) });
+    });
+    return density(spans);
+  });
+}
+
+/** This function gives the points of the way of each link on the probe board, in the order of the links. */
+function probeWays(items: readonly Boxed[], links: readonly RoomLink[], gutter: number, router: Router | undefined): (readonly Point[])[] {
+  if (router) {
+    const edges: Edge[] = links.map((l, i) => ({ id: `l${i}`, source: { node: l.source }, target: { node: l.target } }));
+    const routes = new Map(router.route({ nodes: items, edges }).routes.map((r) => [r.edge, r.points]));
+    return edges.map((e) => routes.get(e.id) ?? []);
+  }
+  const level = items.map((i) => ({ id: i.id, box: i.box, nodes: [i.id] }));
+  const pairs = links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 }));
+  // The margin puts the corners of the two sides of a gap on its middle line.
+  const out = levelLinks(level, pairs, { margin: Math.max(1, gutter / 2) });
+  const byPair = new Map(out.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+  return links.map((l) => byPair.get(`${l.source}\u0000${l.target}`) ?? []);
+}
+
+/**
+ * This function gives the spans along the axis of a gap where the polyline goes along the channel from `lo` to `hi`.
+ * The axis `x` gap is a vertical channel, so its spans are on the y axis.
+ */
+function alongSpans(p: readonly Point[], axis: Axis, lo: number, hi: number): [number, number][] {
+  const across = axis;
+  const along = other(axis);
+  const out: [number, number][] = [];
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    const da = b[across] - a[across];
+    // The part of the segment inside the channel, as the parameters t0 and t1 of the segment.
+    let t0 = 0;
+    let t1 = 1;
+    if (Math.abs(da) < 1e-9) {
+      if (a[across] < lo - 1e-6 || a[across] > hi + 1e-6) continue;
+    } else {
+      const u = (lo - a[across]) / da;
+      const v = (hi - a[across]) / da;
+      t0 = Math.max(0, Math.min(u, v));
+      t1 = Math.min(1, Math.max(u, v));
+      if (t1 <= t0) continue;
+    }
+    const s = a[along] + (b[along] - a[along]) * t0;
+    const e = a[along] + (b[along] - a[along]) * t1;
+    const run = Math.abs(e - s);
+    const cross = Math.abs(da) * (t1 - t0);
+    if (run > cross && run > 1e-6) out.push([Math.min(s, e), Math.max(s, e)]);
+  }
+  return out;
+}
+
+/** This function joins the spans that overlap, so that one link counts one time at each place. */
+function merge(spans: [number, number][]): [number, number][] {
+  spans.sort((u, v) => u[0] - v[0]);
+  const out: [number, number][] = [];
+  for (const s of spans) {
+    const last = out[out.length - 1];
+    if (last && s[0] <= last[1]) last[1] = Math.max(last[1], s[1]);
+    else out.push([s[0], s[1]]);
+  }
+  return out;
+}
+
+/** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
+function density(spans: readonly { from: number; to: number; w: number }[]): number {
+  const events: [number, number][] = [];
+  for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
+  // At one coordinate, the ends come before the starts.
+  events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
+  let n = 0;
+  let best = 0;
+  for (const [, w] of events) {
+    n += w;
+    best = Math.max(best, n);
+  }
+  return best;
+}
+
+/**
+ * This function keeps the growth of the board on each axis at most `maxGrowth` times its size.
+ * Each gap keeps its gutter. The lanes of all gaps of the axis share the rest of the growth in proportion.
+ */
+function capGrowth(items: readonly Boxed[], gaps: Gap[], gutter: number, maxGrowth: number): Gap[] {
+  if (!Number.isFinite(maxGrowth)) return gaps;
+  const out = [...gaps];
+  for (const axis of ["x", "y"] as const) {
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    for (const i of items) {
+      x0 = Math.min(x0, lo(i.box, axis));
+      x1 = Math.max(x1, lo(i.box, axis) + len(i.box, axis));
+    }
+    const budget = Math.max(0, maxGrowth) * Math.max(0, x1 - x0);
+    let base = 0;
+    let spare = 0;
+    for (const g of gaps) {
+      if (g.axis !== axis) continue;
+      const b = Math.max(0, gutter - g.width);
+      base += b;
+      spare += Math.max(0, g.need - g.width - b);
+    }
+    if (base + spare <= budget || spare === 0) continue;
+    const f = Math.max(0, (budget - base) / spare);
+    gaps.forEach((g, i) => {
+      if (g.axis !== axis) return;
+      const b = Math.max(0, gutter - g.width);
+      out[i] = { ...g, need: g.width + b + f * Math.max(0, g.need - g.width - b) };
+    });
+  }
+  return out;
+}

package/src/routers/sections.ts

@@ -1,4 +1,5 @@
-import { center, dist, polylineLength, type Box, type Point } from "../geom.ts";
+import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
+import { center, dist, pointSegmentDistance, polylineLength, type Box, type Point } from "../geom.ts";
 import { levelLinks, type ItemPair } from "../levels.ts";
 import { nodeIndex, type Graph, type Level, type LevelItem, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
@@ -23,12 +24,20 @@ export interface SectionsOptions extends WayOptions, SectionOptions {
 
 const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
 
+/**
+ * A hub can be this many units farther from the target than the nearest approach of the way before it.
+ * A hub farther away goes out and back, so the way skips it.
+ */
+const HUB_SLACK = 2 * BACKTRACK_MIN;
+
 /**
  * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
  * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
  * Each way from hub to hub is found one time, so all the edges on it share its points.
  * The edges in one section of the lowest level go straight around the nodes.
  *
+ * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ *
  * The result gives one zoom level for each depth of the tree.
  * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
  */
@@ -66,6 +75,20 @@ export function sectionsRouter(options: SectionsOptions): Router {
         }
         return h;
       };
+      // The sections of the chain whose hubs do not take the way away from its target. The test uses the straight lines from hub to hub.
+      const forward = (list: readonly Section[], from: Point, to: Point): Section[] => {
+        const kept: Section[] = [];
+        let near = dist(from, to);
+        let last = from;
+        for (const c of list) {
+          const h = hub(c);
+          if (dist(h, to) > near + HUB_SLACK) continue;
+          near = Math.min(near, pointSegmentDistance(to, last, h));
+          last = h;
+          kept.push(c);
+        }
+        return kept;
+      };
       const up = (s: Section): Section[] => {
         const out: Section[] = [];
         for (let x: Section | undefined = s; x; x = parent.get(x)) out.push(x);
@@ -111,20 +134,24 @@ export function sectionsRouter(options: SectionsOptions): Router {
         const lca = a.find((x) => common.has(x))!;
         const keep = options.hubs ?? Infinity;
         const side = (list: Section[]): Section[] => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
-        const chain = [...side(a), ...side(b).reverse()];
+        const end = ways.out(pt);
+        const start = ways.out(ps);
+        const chain = forward([...side(a), ...side(b).reverse()], start, pt.point);
+        if (chain.length === 0) {
+          routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+          continue;
+        }
         const out: Point[] = [ps.point];
         const append = (p: readonly Point[]): void => {
           for (const q of p) if (dist(q, out[out.length - 1]!) > 1e-9) out.push(q);
         };
         const used: string[] = [];
-        const start = ways.out(ps);
         append(piece(at(start), start, chain[0]!.id, hub(chain[0]!), used));
         for (let i = 1; i < chain.length; i++) append(piece(chain[i - 1]!.id, hub(chain[i - 1]!), chain[i]!.id, hub(chain[i]!), used));
-        const end = ways.out(pt);
         append(piece(chain[chain.length - 1]!.id, hub(chain[chain.length - 1]!), at(end), end, used));
         append([pt.point]);
-        // A way through the hubs that is too long gives way to the direct way.
-        if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin) {
+        // A way through the hubs that is too long, or that goes out and back, gives way to the direct way.
+        if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin || goesOutAndBack(out)) {
           routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
           continue;
         }