@mark1russell7/highways 0.2.0 → 0.3.0

package/src/index.ts

@@ -15,6 +15,7 @@ export * from "./pick.ts";
 export * from "./routers/index.ts";
 export * from "./room/index.ts";
 export * from "./room/lanes.ts";
+export * from "./room/levels/index.ts";
 export * from "./bench/properties.ts";
 export * from "./bench/quality.ts";
 export * from "./bench/links.ts";
@@ -22,4 +23,7 @@ export * from "./bench/run.ts";
 export * from "./bench/curves.ts";
 export * from "./bench/room.ts";
 export * from "./bench/sections.ts";
+export * from "./bench/measures/index.ts";
+export * from "./bench/suite.ts";
 export * from "./strategies/index.ts";
+export * from "./bench/compare.ts";

package/src/levels.ts

@@ -1,7 +1,8 @@
+import { boxesOverlap, goesOutAndBack } from "./bench/links.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";
+import { CornerGraph, Obstacles, SoftGraph } from "./visibility.ts";
 import type { WayFinder, WayOptions } from "./ways.ts";
 
 /** Two items of a level that a link joins, and the count of the edges between them. */
@@ -26,6 +27,10 @@ interface LevelWays extends Ways {
   readonly tight: () => CornerGraph;
   /** The free plugs of each node that a link needed. */
   readonly free: Map<Node, FreePlugs>;
+  /** This function gives the graph of `SoftGraph`. The first link that needs it makes it. */
+  readonly soft: () => SoftGraph;
+  /** The mean size of the boxes: the mean of the larger side of each box. */
+  readonly size: number;
 }
 
 /** The options of the links of a level: the options of the ways, and two limits of the level links. */
@@ -37,18 +42,39 @@ export interface LevelLinkOptions extends WayOptions {
   readonly tightMargin?: number;
   /** A plug stays at least this far from the corners of its side. The level links use the smaller of this value and `margin`. The default is 6. */
   readonly plugInset?: number;
+  /**
+   * The cost of a level link through a far box, in units of the mean box size. A far box overlaps neither end of the link.
+   * A link through a far box gets a second way that can go through boxes (`SoftGraph`). The link keeps the way with fewer far boxes.
+   * The value 0 turns the second way off and gives the links of version 0.1.5. The default is 8.
+   */
+  readonly throughCost?: number;
 }
 
-/** The default values of the two limits of `LevelLinkOptions`. */
-export const LEVEL_LINK_DEFAULTS: Readonly<Required<Pick<LevelLinkOptions, "tightMargin" | "plugInset">>> = Object.freeze({ tightMargin: 1, plugInset: 6 });
+/** The default values of the three limits of `LevelLinkOptions`. */
+export const LEVEL_LINK_DEFAULTS: Readonly<Required<Pick<LevelLinkOptions, "tightMargin" | "plugInset" | "throughCost">>> = Object.freeze({
+  tightMargin: 1,
+  plugInset: 6,
+  throughCost: 8,
+});
+
+/** The values of `throughCost` of the sweep of ER3d in the benchmark. The value 0 gives the links of version 0.1.5. */
+export const THROUGH_COST_SWEEP: readonly number[] = [0, 2, 4, 8, 16];
 
 const EPS = 1e-6;
 
 /**
  * This function removes the repeated points, the points in the middle of a straight run,
  * and the points where the way turns back on itself.
+ * A way of two points or more keeps two points: its first point and its last point.
+ * Two items that touch can get a link of zero length, and such a link keeps an end on each item.
  */
 function tidy(p: readonly Point[]): Point[] {
+  const out = tidyPoints(p);
+  return out.length === 1 && p.length > 1 ? [p[0]!, p[p.length - 1]!] : out;
+}
+
+/** This function does the work of `tidy`. It can give one point only. */
+function tidyPoints(p: readonly Point[]): Point[] {
   const out: Point[] = [];
   for (const q of p) {
     if (out.length > 0 && dist(q, out[out.length - 1]!) <= EPS) continue;
@@ -77,6 +103,7 @@ export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair
   const byId = new Map(nodes.map((n) => [n.id, n]));
   const ways = levelWays(nodes, options);
   const inset = Math.min(options.plugInset ?? LEVEL_LINK_DEFAULTS.plugInset, ways.margin);
+  const throughCost = options.throughCost ?? LEVEL_LINK_DEFAULTS.throughCost;
   const out: LevelLink[] = [];
   for (const p of pairs) {
     const s = byId.get(p.source);
@@ -89,7 +116,16 @@ export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair
     points ??= sideWay(ways, s, t, inset);
     out.push({ source: p.source, target: p.target, count: p.count, points });
   }
-  return out;
+  if (throughCost <= 0) return out;
+  // The second way never makes the worst detour of the level longer.
+  const limit = out.reduce((m, l) => Math.max(m, detour(l.points)), 1);
+  return out.map((l) => ({ ...l, points: fewerFar(ways, byId.get(l.source)!, byId.get(l.target)!, l.points, throughCost, limit) }));
+}
+
+/** This function gives the length of the polyline divided by the distance between its ends, as the measure `worstDetour` gives it. */
+function detour(p: readonly Point[]): number {
+  const span = p.length > 1 ? dist(p[0]!, p[p.length - 1]!) : 0;
+  return span > 1 ? polylineLength(p) / span : 1;
 }
 
 /**
@@ -122,7 +158,129 @@ function levelWays(nodes: readonly Node[], options: LevelLinkOptions): LevelWays
   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, options.tightMargin ?? LEVEL_LINK_DEFAULTS.tightMargin), k, cones: true }));
-  return { obstacles, corners, margin, out, tight: tightGraph, free: new Map() };
+  let soft: SoftGraph | undefined;
+  const softGraph = (): SoftGraph => (soft ??= new SoftGraph(nodes, obstacles, { margin, k }));
+  return { obstacles, corners, margin, out, tight: tightGraph, free: new Map(), soft: softGraph, size: size / Math.max(1, nodes.length) };
+}
+
+/** This function gives the boxes that the polyline goes through, without the boxes of `s` and `t`, and the number of far boxes among them. */
+function boxesThrough(ways: Ways, p: readonly Point[], s: Node, t: Node, near: ReadonlySet<Node>): { boxes: Set<Node>; far: number } {
+  const boxes = new Set<Node>();
+  let far = 0;
+  for (let i = 1; i < p.length; i++)
+    ways.obstacles.through(p[i - 1]!, p[i]!, (n) => {
+      if (n === s || n === t || boxes.has(n)) return;
+      boxes.add(n);
+      if (!near.has(n)) far++;
+    });
+  return { boxes, far };
+}
+
+/** This function gives the nodes whose boxes overlap the box of `s` or the box of `t`, as `boxesOverlap` sees it. */
+function nearBoxes(ways: Ways, s: Node, t: Node): Set<Node> {
+  const near = new Set<Node>();
+  for (const end of [s, t])
+    ways.obstacles.query(end.box, (n) => {
+      if (n !== s && n !== t && boxesOverlap(n.box, end.box)) near.add(n);
+    });
+  return near;
+}
+
+/**
+ * This function gives a way with fewer far boxes than `way`, or `way`. A far box overlaps neither end of the link.
+ * On a walled-in level, each box overlaps its neighbours, so a link can find no way around the boxes.
+ * Then a search of `SoftGraph` goes from the center of `s` to the center of `t`.
+ *
+ * In the search, a far box costs `cost` mean box sizes, and a near box costs one mean box size.
+ * The way starts where the path leaves the box of `s` for the last time. It ends where the path then first enters the box of `t`.
+ * The link keeps `way` when the new way goes out and back and `way` does not.
+ * It also keeps `way` when the detour of the new way is longer than `limit`.
+ */
+function fewerFar(ways: LevelWays, s: Node, t: Node, way: readonly Point[], cost: number, limit: number): readonly Point[] {
+  const near = nearBoxes(ways, s, t);
+  const before = boxesThrough(ways, way, s, t, near);
+  if (before.far === 0) return way;
+  const far = cost * ways.size;
+  const path = ways.soft().path(center(s.box), center(t.box), (n) => (n === s || n === t ? 0 : near.has(n) ? ways.size : far));
+  const clipped = clip(path, s.box, t.box);
+  if (!clipped) return way;
+  const soft = tidy(pullThrough(ways, clipped, s, t));
+  // A way that goes out and back is a new fault, so the link keeps the old way.
+  if (goesOutAndBack(soft) && !goesOutAndBack(way)) return way;
+  if (detour(soft) > limit) return way;
+  return boxesThrough(ways, soft, s, t, near).far < before.far ? soft : way;
+}
+
+/** This function tells if the point is inside the box, not on its boundary. */
+const within = (p: Point, b: Box): boolean => p.x > b.x && p.x < b.x + b.w && p.y > b.y && p.y < b.y + b.h;
+
+/** This function gives the point where the segment from `a`, inside the box, to `b` leaves the box. */
+function exitPoint(a: Point, b: Point, box: Box): Point {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let u = 1;
+  if (dx > 0) u = Math.min(u, (box.x + box.w - a.x) / dx);
+  if (dx < 0) u = Math.min(u, (box.x - a.x) / dx);
+  if (dy > 0) u = Math.min(u, (box.y + box.h - a.y) / dy);
+  if (dy < 0) u = Math.min(u, (box.y - a.y) / dy);
+  u = Math.max(0, u);
+  return { x: a.x + u * dx, y: a.y + u * dy };
+}
+
+/**
+ * This function cuts a path from the inside of the box `a` to the inside of the box `b`. The cut path starts where the path leaves `a` for the last time.
+ * It ends where the path then first enters `b`. It gives `undefined` when no such part is left.
+ */
+function clip(p: readonly Point[], a: Box, b: Box): Point[] | undefined {
+  let i = -1;
+  for (let k = 0; k < p.length; k++) if (within(p[k]!, a)) i = k;
+  if (i < 0 || i === p.length - 1) return undefined;
+  let j = -1;
+  for (let k = i + 1; k < p.length && j < 0; k++) if (within(p[k]!, b)) j = k;
+  if (j < 0) return undefined;
+  const start = exitPoint(p[i]!, p[i + 1]!, a);
+  const end = exitPoint(p[j]!, p[j - 1]!, b);
+  if (within(start, b) || within(end, a)) return undefined;
+  return [start, ...p.slice(i + 1, j), end];
+}
+
+/**
+ * This function pulls a soft path tight. From each vertex, it goes to the farthest vertex of the next 16 vertices with a straight line.
+ * The line can go only through the boxes that the path between the two vertices goes through.
+ */
+function pullThrough(ways: Ways, p: readonly Point[], s: Node, t: Node, lookahead = 16): Point[] {
+  if (p.length < 3) return [...p];
+  const boxesOf = (a: Point, b: Point): Node[] => {
+    const out: Node[] = [];
+    ways.obstacles.through(a, b, (n) => {
+      if (n !== s && n !== t) out.push(n);
+    });
+    return out;
+  };
+  // The boxes of each leg of the path, found one time.
+  const legs = p.map((q, m) => (m === 0 ? [] : boxesOf(p[m - 1]!, q)));
+  const out: Point[] = [p[0]!];
+  let i = 0;
+  while (i < p.length - 1) {
+    let next = i + 1;
+    const last = Math.min(p.length - 1, i + lookahead);
+    // The boxes of the path from vertex i to each vertex j.
+    const along: Set<Node>[] = [];
+    let seen = new Set<Node>();
+    for (let j = i + 1; j <= last; j++) {
+      seen = new Set([...seen, ...legs[j]!]);
+      along[j] = seen;
+    }
+    for (let j = last; j > i + 1; j--) {
+      if (boxesOf(p[i]!, p[j]!).every((n) => along[j]!.has(n))) {
+        next = j;
+        break;
+      }
+    }
+    out.push(p[next]!);
+    i = next;
+  }
+  return out;
 }
 
 /**

package/src/room/bends.ts

@@ -0,0 +1,203 @@
+import type { Box, Point } from "../geom.ts";
+import { Grid } from "../grid.ts";
+import type { Edge, Router } from "../model.ts";
+import { segmentsOf, type SegmentGraph } from "../segments.ts";
+import type { Boxed, Gap, RoomLink } from "./index.ts";
+
+/**
+ * The options of the room for the bends of the bundles (HWC-D). With them, `roomDemand` also opens the gaps where a bundle bends.
+ * The values agree with the options of `highwayCurves` that draw the bundles.
+ */
+export interface RoomBends {
+  /** The router that bundles the edges. Each segment of its routes with two or more edges is a bundle. */
+  readonly router: Router;
+  /** The edges that the router routes. Without them, each link gives `count` edges, with no data. */
+  readonly edges?: readonly Edge[];
+  /** The distance between two lanes of a bundle, as `laneWidth` of `highwayCurves`. The default is 4. */
+  readonly spacing?: number;
+  /** The largest width of a bundle, from its outer lane to its outer lane, as `maxWidth` of `highwayCurves`. The default is `Infinity`. */
+  readonly maxWidth?: number;
+  /** The smallest radius of each lane, as `minRadius` of `highwayCurves`. The default is 4. */
+  readonly minRadius?: number;
+  /** The number of passes of the demand of the bends. Each pass routes the board that the passes before it opened. The default is 1. */
+  readonly passes?: number;
+}
+
+/** One leg of the route of an edge: a straight piece of the center line of one segment. */
+interface BendLeg {
+  readonly a: Point;
+  readonly b: Point;
+  readonly u: Point;
+  readonly len: number;
+  /** The number of lanes of the segment of the leg. A segment of one edge has 1. */
+  readonly lanes: number;
+  /** The offset of the lane of the edge from the center line, to the left of the leg. */
+  readonly off: number;
+  /** The key of the leg: its segment and its place in the segment. Two edges of one segment share the key. */
+  readonly key: string;
+}
+
+/** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle is a spike, and it gets no arc. */
+const FLAT = 1e-6;
+const SPIKE = 0.01;
+const SAME = 1e-6;
+/** A leg with a smaller share of its length on an axis does not grow on that axis. */
+const SLANT = 0.2;
+
+const turnOf = (u: Point, w: Point): number => Math.atan2(u.x * w.y - u.y * w.x, u.x * w.x + u.y * w.y);
+
+/**
+ * This function gives the length along a leg of an S of two arcs with the radius `r` that shifts a lane by `shift`.
+ * It is the length of the shift of `highwayCurves` at a merge or a split.
+ */
+function jogLength(r: number, shift: number): number {
+  const d = Math.abs(shift);
+  if (d < SAME || r <= 0) return 0;
+  if (r < d / 2) return 2 * r;
+  return 2 * r * Math.sin(Math.acos(1 - d / (2 * r)));
+}
+
+/** This function gives the legs of the route of each edge, with the lanes and the offset of the lane on each leg. */
+function legsOf(graph: SegmentGraph, spacing: number, maxWidth: number): BendLeg[][] {
+  const byId = new Map(graph.segments.map((s) => [s.id, s]));
+  return graph.paths.map((path) => {
+    const legs: BendLeg[] = [];
+    for (const ref of path.segments) {
+      const s = byId.get(ref.segment);
+      if (!s) continue;
+      const sp = s.count > 1 ? Math.min(spacing, maxWidth / (s.count - 1)) : 0;
+      const offset = ((s.count - 1) / 2 - ref.lane) * sp;
+      const c: Point[] = [];
+      for (const p of s.points) if (c.length === 0 || Math.hypot(p.x - c[c.length - 1]!.x, p.y - c[c.length - 1]!.y) > SAME) c.push(p);
+      const n = c.length;
+      for (let j = 0; j + 1 < n; j++) {
+        const from = ref.reverse ? n - 1 - j : j;
+        const to = ref.reverse ? n - 2 - j : j + 1;
+        const a = c[from]!;
+        const b = c[to]!;
+        const len = Math.hypot(b.x - a.x, b.y - a.y);
+        legs.push({
+          a,
+          b,
+          u: { x: (b.x - a.x) / len, y: (b.y - a.y) / len },
+          len,
+          lanes: sp > 0 ? s.count : 1,
+          off: ref.reverse ? -offset : offset,
+          key: `${s.id}:${Math.min(from, to)}`,
+        });
+      }
+    }
+    return legs;
+  });
+}
+
+/**
+ * This function gives the length that the arcs at one end of a leg use on the leg, as the lanes of `highwayCurves` use it.
+ * `A` is the leg before the vertex, `B` the leg after it, and `X` the leg of the two that the length is for.
+ *
+ * - At a bend of two bundles, the center line has the radius `R = W/2 + minRadius`, with `W` the width of the wider bundle. The tangent length is `T = R tan(φ/2)`.
+ *   Each lane uses the same part of the leg, because the arcs are concentric.
+ * - At another corner, the lane has the radius `minRadius` at its own corner, at the offset `c` of the lane. The tangent length is `(minRadius + |c|) tan(φ/2)`.
+ * - A lane that joins or leaves a bundle shifts on the leg with fewer lanes. The S of the shift adds its length on that leg.
+ */
+function endLength(A: BendLeg, B: BendLeg, X: BendLeg, minRadius: number): number {
+  const phi = Math.abs(turnOf(A.u, B.u));
+  if (Math.PI - phi < SPIKE) return 0;
+  const k = phi < FLAT ? 0 : Math.tan(phi / 2);
+  const c = A.lanes < B.lanes ? B.off : A.off;
+  if (A.lanes > 1 && B.lanes > 1) return k * (Math.max(Math.abs(A.off), Math.abs(B.off), Math.abs(c)) + minRadius);
+  return k * (minRadius + Math.abs(c)) + jogLength(minRadius, c - X.off);
+}
+
+/**
+ * This function gives, for each leg of the routes, the length that the leg lacks for the arcs at its two ends.
+ * `highwayCurves` gives each end of a leg at most the half of the leg. So a leg needs `2 max(T_A, T_B)`, and this length is at least `T_A + T_B`.
+ * The first and the last leg of a route end at a plug, and the plug end needs no length.
+ */
+function shortLegs(legs: readonly (readonly BendLeg[])[], minRadius: number): Map<string, { leg: BendLeg; short: number }> {
+  const out = new Map<string, { leg: BendLeg; short: number }>();
+  for (const path of legs) {
+    if (path.every((l) => l.lanes < 2)) continue;
+    for (let j = 0; j < path.length; j++) {
+      const X = path[j]!;
+      const start = j > 0 ? endLength(path[j - 1]!, X, X, minRadius) : 0;
+      const end = j + 1 < path.length ? endLength(X, path[j + 1]!, X, minRadius) : 0;
+      const short = 2 * Math.max(start, end) - X.len;
+      if (short <= SAME) continue;
+      const known = out.get(X.key);
+      if (!known || known.short < short) out.set(X.key, { leg: X, short });
+    }
+  }
+  return out;
+}
+
+/** This function gives the mean of the longer side of the boxes. */
+function meanSide(items: readonly Boxed[]): number {
+  let s = 0;
+  for (const i of items) s += Math.max(i.box.w, i.box.h);
+  return items.length ? s / items.length : 1;
+}
+
+/** This function gives the box nearest to a point, among the boxes within `reach` of it. */
+function nearestBox(grid: Grid<Box>, p: Point, reach: number): Box | undefined {
+  let best: Box | undefined;
+  let bestD = Infinity;
+  grid.query({ x: p.x - reach, y: p.y - reach, w: 2 * reach, h: 2 * reach }, (b) => {
+    const dx = Math.max(b.x - p.x, 0, p.x - b.x - b.w);
+    const dy = Math.max(b.y - p.y, 0, p.y - b.y - b.h);
+    const d = Math.hypot(dx, dy);
+    if (d < bestD || (d === bestD && best && (b.x < best.x || (b.x === best.x && b.y < best.y)))) [best, bestD] = [b, d];
+  });
+  return bestD <= reach ? best : undefined;
+}
+
+/**
+ * This function gives the growth that each gap of the board needs for the bends of the bundles, in the order of `gaps`.
+ * The router routes the board. Each segment with two or more edges is a bundle, as `highwayCurves` opens it.
+ *
+ * A leg that is too short for the arcs at its ends grows by the gaps between its two ends.
+ * Each end of a leg moves with its nearest box, as `openGaps` moves the boxes. So a gap between the left (or top) edges of the two boxes lengthens the leg.
+ * The leg grows on the axis of its longer side. The gap nearest to the middle of the leg takes the growth.
+ * A gap that more legs need takes the largest growth, not the sum.
+ */
+export function bendGrowth(items: readonly Boxed[], links: readonly RoomLink[], gaps: readonly Gap[], bends: RoomBends, snap: number): number[] {
+  const spacing = Math.max(0, bends.spacing ?? 4);
+  const maxWidth = bends.maxWidth ?? Infinity;
+  const minRadius = Math.max(0, bends.minRadius ?? 4);
+  const edges: Edge[] = bends.edges
+    ? [...bends.edges]
+    : links.flatMap((l, i) => Array.from({ length: Math.max(1, l.count ?? 1) }, (_, k) => ({ id: `l${i}-${k}`, source: { node: l.source }, target: { node: l.target } })));
+  const graph = segmentsOf(bends.router.route({ nodes: items, edges }));
+  const short = shortLegs(legsOf(graph, spacing, maxWidth), minRadius);
+  const grow: number[] = gaps.map(() => 0);
+  if (short.size === 0) return grow;
+  const side = meanSide(items);
+  const grid = new Grid<Box>(Math.max(20, side));
+  for (const i of items) grid.add(i.box, i.box);
+  const anchor = (p: Point): Box | undefined => nearestBox(grid, p, side) ?? nearestBox(grid, p, 4 * side);
+  const byAxis = { x: [] as number[], y: [] as number[] };
+  gaps.forEach((g, i) => byAxis[g.axis].push(i));
+  for (const { leg, short: s } of short.values()) {
+    const A = anchor(leg.a);
+    const B = anchor(leg.b);
+    if (!A || !B) continue;
+    const axes = (["x", "y"] as const).filter((x) => Math.abs(leg.u[x]) >= SLANT).sort((p, q) => Math.abs(leg.u[q]) - Math.abs(leg.u[p]));
+    for (const axis of axes) {
+      const la = A[axis];
+      const lb = B[axis];
+      const lo = Math.min(la, lb);
+      const hi = Math.max(la, lb);
+      const mid = (leg.a[axis] + leg.b[axis]) / 2;
+      let pick = -1;
+      for (const i of byAxis[axis]) {
+        const g = gaps[i]!;
+        if (g.at <= lo + snap || g.at > hi + snap) continue;
+        if (pick < 0 || Math.abs(g.at - mid) < Math.abs(gaps[pick]!.at - mid)) pick = i;
+      }
+      if (pick < 0) continue;
+      grow[pick] = Math.max(grow[pick]!, s / Math.abs(leg.u[axis]));
+      break;
+    }
+  }
+  return grow;
+}

package/src/room/index.ts

@@ -1,6 +1,9 @@
 import { center, type Box, type Point } from "../geom.ts";
 import { levelLinks } from "../levels.ts";
 import type { Edge, Graph, Router } from "../model.ts";
+import { bendGrowth, type RoomBends } from "./bends.ts";
+
+export type { RoomBends } from "./bends.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 {
@@ -70,6 +73,12 @@ export interface RoomOptions {
    * The limit `maxGrowth` applies to the sum of the passes.
    */
   readonly passes?: number;
+  /**
+   * The room for the bends of the bundles (HWC-D). Without it, the default, the demand counts only the lanes of the links.
+   * With it, the router of `bends` routes the open board. Each leg of a bundle that is too short for its arcs grows by a gap.
+   * The limit `maxGrowth` applies to the sum of the growth of the links and of the bends.
+   */
+  readonly bends?: RoomBends;
 }
 
 /** The demand of a board and the board with its gaps open. */
@@ -163,9 +172,28 @@ export function roomDemand(items: readonly Boxed[], links: readonly RoomLink[],
     if (next.length !== total.length || next.some((g, i) => g.axis !== total[i]!.axis)) break;
     total = total.map((g, i) => ({ ...g, lanes: Math.max(g.lanes, next[i]!.lanes), need: g.need + Math.max(0, next[i]!.need - next[i]!.width) }));
   }
+  if (options.bends) total = withBends(items, links, total, options.bends, snap);
   return capGrowth(items, total, gutter, options.maxGrowth ?? Infinity);
 }
 
+/**
+ * This function adds the growth for the bends of the bundles to the need of each gap. Each pass routes the board with each gap open to its need.
+ * The open board has the same gaps in the same order. So the growth of each gap adds to the need of that gap.
+ */
+export function withBends(items: readonly Boxed[], links: readonly RoomLink[], gaps: readonly Gap[], bends: RoomBends, snap: number = DEFAULT_SNAP): Gap[] {
+  let total = [...gaps];
+  const passes = Math.max(1, Math.floor(bends.passes ?? 1));
+  for (let p = 0; p < passes; p++) {
+    const board = openGaps(items, total, snap);
+    const open = boardGaps(board, snap);
+    if (open.length !== total.length || open.some((g, i) => g.axis !== total[i]!.axis)) break;
+    const grow = bendGrowth(board, links, open, bends, snap);
+    if (grow.every((g) => g <= 0)) break;
+    total = total.map((g, i) => (grow[i]! > 0 ? { ...g, need: g.need + grow[i]! } : g));
+  }
+  return total;
+}
+
 /** This function gives the demand of one pass, without the limit `maxGrowth`. */
 function demandOnce(items: readonly Boxed[], links: readonly RoomLink[], options: RoomOptions): Gap[] {
   const gutter = options.gutter ?? DEFAULT_GUTTER;

package/src/room/levels/index.ts

@@ -0,0 +1,155 @@
+import type { ItemPair } from "../../levels.ts";
+import type { LevelItem } from "../../model.ts";
+import { levelCut, treeDepth, type Section } from "../../sections.ts";
+import { boardGaps, openGaps, roomDemand, withBends, type Boxed, type Gap, type RoomLink, type RoomOptions } from "../index.ts";
+
+/**
+ * The boards of the zoom levels of `levelRoom`.
+ *
+ * - `shared`: each level uses the board of the nearest level. No box moves between two levels. A far level gets the area of the nearest level.
+ * - `each`: each level has its own board. A far level opens only the gaps of its own links, and a nearer level adds to them.
+ *   Thus the items of a far level are nearer together, but a box moves in its parent when the level changes.
+ */
+export type LevelBoard = "each" | "shared";
+
+/** The options of `levelRoom`: the options of `roomDemand` for each level, and the levels that get room. */
+export interface LevelRoomOptions extends RoomOptions {
+  /** The depths of the tree that get room for their links. The default is each depth from 1 to the depth of the deepest section. */
+  readonly depths?: readonly number[];
+  /** With `true`, the last level, with each node alone, also gets room for the links between the nodes. The default is `false`. */
+  readonly nodes?: boolean;
+  /** The board of each level. The default is `shared`. */
+  readonly board?: LevelBoard;
+}
+
+/** One zoom level of `levelRoom`: its items at their open places, its links and its demand. */
+export interface RoomLevel<T extends Boxed> {
+  readonly depth: number;
+  /** The items of the level, with the bounding box of their nodes at the places of this level. */
+  readonly items: LevelItem[];
+  /** The links between the items of the level. A link counts the links of the nodes between its two items. */
+  readonly pairs: ItemPair[];
+  /** The demand of the level on the board that it gets from the level before it. A level without room has no gaps. */
+  readonly gaps: Gap[];
+  /** The nodes at the places of this level. */
+  readonly nodes: T[];
+}
+
+/** The room of each zoom level, and the board of the nearest level. */
+export interface LevelRoom<T extends Boxed> {
+  /** The levels from depth 0 to the level with each node alone, in order. */
+  readonly levels: RoomLevel<T>[];
+  /** The gaps of the board of the nodes. `openGaps(nodes, gaps)` gives the nodes of the nearest level. */
+  readonly gaps: Gap[];
+  /** The nodes of the nearest level. */
+  readonly items: T[];
+}
+
+const DEFAULT_SNAP = 0.5;
+
+/**
+ * This function gives the links between the items of a level. Each pair of items gets one link, in the order of the first link of the pair.
+ * The count of a link is the sum of the counts of its node links. A link inside one item does not count.
+ */
+export function levelPairs(items: readonly LevelItem[], owner: readonly number[], indexOf: ReadonlyMap<string, number>, links: readonly RoomLink[]): ItemPair[] {
+  const byPair = new Map<string, { source: string; target: string; count: number }>();
+  for (const l of links) {
+    const iu = indexOf.get(l.source);
+    const iv = indexOf.get(l.target);
+    if (iu === undefined || iv === undefined) continue;
+    const a = owner[iu]!;
+    const b = owner[iv]!;
+    if (a === b) continue;
+    const key = a < b ? `${a} ${b}` : `${b} ${a}`;
+    const known = byPair.get(key);
+    if (known) known.count += l.count ?? 1;
+    else byPair.set(key, { source: items[a]!.id, target: items[b]!.id, count: l.count ?? 1 });
+  }
+  return [...byPair.values()];
+}
+
+/**
+ * This function gives the room of each zoom level of a tree of sections. The indices of the nodes of the tree are the indices of `nodes`.
+ * The far levels open first, and each nearer level keeps their growth.
+ *
+ * At each level, `roomDemand` measures the links of that level on the board of the level before it. Then the nodes move with `openGaps`.
+ * The nodes move by one monotone shift on each axis, so each level keeps the order and the alignment of the boxes.
+ * A nearer level only adds growth, so no gap of a far level gets narrower, and a box moves with its parent.
+ */
+export function levelRoom<T extends Boxed>(nodes: readonly T[], links: readonly RoomLink[], root: Section, options: LevelRoomOptions = {}): LevelRoom<T> {
+  const snap = options.snap ?? DEFAULT_SNAP;
+  const deepest = treeDepth(root);
+  const depths = new Set(options.depths ?? Array.from({ length: deepest }, (_, i) => i + 1));
+  if (options.nodes) depths.add(deepest + 1);
+  const indexOf = new Map(nodes.map((n, i) => [n.id, i]));
+  const levels: RoomLevel<T>[] = [];
+  let current: T[] = [...nodes];
+  // The edges of the bends join nodes, not the items of a level. So the bends get room on the board of the nodes, at the last level.
+  const { bends, ...room } = options;
+  for (let d = 0; d <= deepest + 1; d++) {
+    let gaps: Gap[] = [];
+    let cut = levelCut(current, root, d);
+    const pairs = levelPairs(cut.items, cut.owner, indexOf, links);
+    if (depths.has(d) && pairs.length > 0) {
+      gaps = roomDemand(cut.items, pairs, room);
+      // The shift of each gap applies to the nodes, so a node moves with its item, and the items of a far level stay apart.
+      if (gaps.some((g) => g.need > g.width)) {
+        current = openGaps(current, gaps, snap);
+        cut = levelCut(current, root, d);
+      }
+    }
+    if (bends && d === deepest + 1) {
+      const bent = withBends(current, links, boardGaps(current, snap), bends, snap);
+      if (bent.some((g) => g.need > g.width)) {
+        current = openGaps(current, bent, snap);
+        cut = levelCut(current, root, d);
+      }
+    }
+    levels.push({ depth: d, items: cut.items, pairs, gaps, nodes: current });
+  }
+  const shared = (options.board ?? "shared") === "shared";
+  const out = shared ? levels.map((l) => ({ ...l, items: levelCut(current, root, l.depth).items, nodes: current })) : levels;
+  return { levels: out, gaps: nodeGaps(nodes, current, levels, snap), items: current };
+}
+
+/**
+ * This function gives the gaps of the board of the nodes that move each node from `from` to `to`.
+ * The growth of a gap is the shift of the nodes after it, less the shift of the nodes before it. Its lanes are the most lanes of a level gap there.
+ */
+function nodeGaps<T extends Boxed>(from: readonly T[], to: readonly T[], levels: readonly RoomLevel<T>[], snap: number): Gap[] {
+  const indexOf = new Map(from.map((n, i) => [n.id, i]));
+  const gaps = boardGaps(from, snap);
+  const shift = (id: string, axis: "x" | "y"): number => {
+    const i = indexOf.get(id)!;
+    return to[i]!.box[axis] - from[i]!.box[axis];
+  };
+  // The lanes of each level gap go to the gap of the nodes at the left (or top) edge of its first item after it.
+  const lanes = new Map<number, number>();
+  const boundaryOf = new Map<string, number>();
+  gaps.forEach((g, k) => {
+    for (const id of g.after) boundaryOf.set(`${g.axis} ${id}`, k);
+  });
+  for (const level of levels) {
+    const byId = new Map(level.items.map((i) => [i.id, i]));
+    for (const g of level.gaps) {
+      if (g.lanes === 0) continue;
+      for (const id of g.after) {
+        const item = byId.get(id);
+        if (!item) continue;
+        // The first node of the item on the axis of the gap starts the item.
+        let first = item.nodes[0]!;
+        for (const n of item.nodes) if (from[indexOf.get(n)!]!.box[g.axis] < from[indexOf.get(first)!]!.box[g.axis]) first = n;
+        const k = boundaryOf.get(`${g.axis} ${first}`);
+        if (k !== undefined) lanes.set(k, Math.max(lanes.get(k) ?? 0, g.lanes));
+      }
+    }
+  }
+  const last: Record<"x" | "y", number> = { x: 0, y: 0 };
+  return gaps.map((g, k) => {
+    let s = Infinity;
+    for (const id of g.after) s = Math.min(s, shift(id, g.axis));
+    const growth = Math.max(0, s - last[g.axis]);
+    last[g.axis] = Math.max(last[g.axis], s);
+    return { ...g, lanes: lanes.get(k) ?? 0, need: g.width + growth };
+  });
+}