@mark1russell7/highways 0.1.5 → 0.3.0

package/src/groups/keys/index.ts

@@ -0,0 +1,81 @@
+import type { Box } from "../../geom.ts";
+import type { Graph, Node } from "../../model.ts";
+import { buildSections, type Section, type SectionOptions } from "../../sections.ts";
+
+/** A key rule gives the key of the group of a node. A node without a key is a group alone. */
+export type NodeKey = (node: Node, index: number) => string | undefined;
+
+/** The options of the grouping rule `keys`. */
+export interface KeyOptions {
+  /** This function gives the key of the group of each node. The default is `byDataGroup`. */
+  readonly key?: NodeKey;
+  /**
+   * With this value, a group with more nodes than its `cap` splits into the cells of a quadtree, as `buildSections` does.
+   * Without it, each group is one leaf. The default is no split.
+   */
+  readonly split?: SectionOptions;
+}
+
+/** This key rule gives the string `data.group` of the node, or `undefined` when the node has no such string. */
+export const byDataGroup: NodeKey = (node) => {
+  const group = node.data?.["group"];
+  return typeof group === "string" ? group : undefined;
+};
+
+/** This function gives the bounding box of the boxes of the nodes of the list. */
+function boundsOf(nodes: readonly Node[], list: readonly number[]): Box {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const i of list) {
+    const b = nodes[i]!.box;
+    x0 = Math.min(x0, b.x);
+    y0 = Math.min(y0, b.y);
+    x1 = Math.max(x1, b.x + b.w);
+    y1 = Math.max(y1, b.y + b.h);
+  }
+  return list.length ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : { x: 0, y: 0, w: 0, h: 0 };
+}
+
+/**
+ * This function gives the tree of sections of the grouping rule `keys`. The root holds each node. Each child of the root holds the nodes of one key,
+ * in the order of their first node. The id of a group is `s:` and its key. A node without a key is a group alone, with the id `s#` and its index.
+ * Thus the far view of the router `sections` shows one item for each group.
+ */
+export function keyedSections(nodes: readonly Node[], options: KeyOptions = {}): Section {
+  const key = options.key ?? byDataGroup;
+  const groups = new Map<string, number[]>();
+  nodes.forEach((n, i) => {
+    const k = key(n, i);
+    const id = k === undefined ? `s#${i}` : `s:${k}`;
+    const list = groups.get(id);
+    if (list) list.push(i);
+    else groups.set(id, [i]);
+  });
+  const children = [...groups].map(([id, list]) => group(nodes, id, list, options.split));
+  return { id: "s", depth: 0, cell: boundsOf(nodes, nodes.map((_, i) => i)), nodes: nodes.map((_, i) => i), children };
+}
+
+/** This function gives the section of one group at depth 1. With `split`, the section has the quadtree of its nodes below it. */
+function group(nodes: readonly Node[], id: string, list: readonly number[], split: SectionOptions | undefined): Section {
+  if (!split) return { id, depth: 1, cell: boundsOf(nodes, list), nodes: list, children: [] };
+  const tree = buildSections(
+    list.map((i) => nodes[i]!),
+    split,
+  );
+  // The quadtree numbers the nodes of the group from 0. Each section gets the indices of the graph, one more level and the id of the group before its path.
+  const rebase = (s: Section): Section => ({
+    id: s.id === "s" ? id : `${id}/${s.id.slice(1)}`,
+    depth: s.depth + 1,
+    cell: s.cell,
+    nodes: s.nodes.map((j) => list[j]!),
+    children: s.children.map(rebase),
+  });
+  return rebase(tree);
+}
+
+/** This function gives the tree of sections of the grouping rule `keys` for a graph. */
+export function keyGroups(graph: Graph, options: KeyOptions = {}): Section {
+  return keyedSections(graph.nodes, options);
+}

package/src/groups/quadtree/index.ts

@@ -0,0 +1,10 @@
+import type { Graph } from "../../model.ts";
+import { buildSections, type Section, type SectionOptions } from "../../sections.ts";
+
+/**
+ * This function gives the tree of sections of the grouping rule `quadtree`: the cells of a quadtree of the plane (`buildSections`).
+ * It is the default grouping rule of the router `sections`.
+ */
+export function quadtreeGroups(graph: Graph, options: SectionOptions = {}): Section {
+  return buildSections(graph.nodes, options);
+}

package/src/index.ts

@@ -10,13 +10,20 @@ export * from "./visibility.ts";
 export * from "./ways.ts";
 export * from "./segments.ts";
 export * from "./sections.ts";
+export * from "./groups/index.ts";
+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";
 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,18 +27,54 @@ 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 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;
+/** The options of the links of a level: the options of the ways, and two limits of the level links. */
+export interface LevelLinkOptions extends WayOptions {
+  /**
+   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
+   * The second graph uses the smaller of this value and `margin`. The default is 1.
+   */
+  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 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;
@@ -60,12 +97,13 @@ function tidy(p: readonly Point[]): Point[] {
  * A link starts on the boundary of the box of its source and ends on the boundary of the box of its target.
  * It goes around the boxes of the other items. Where there is space, its legs are parallel to the axes.
  */
-export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair[], options: WayOptions = {}): LevelLink[] {
+export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair[], options: LevelLinkOptions = {}): LevelLink[] {
   if (pairs.length === 0) return [];
   const nodes: Node[] = items.map((i) => ({ id: i.id, box: i.box }));
   const byId = new Map(nodes.map((n) => [n.id, n]));
   const ways = levelWays(nodes, options);
-  const inset = Math.min(6, ways.margin);
+  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);
@@ -78,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;
 }
 
 /**
@@ -101,7 +148,7 @@ function sideWay(ways: LevelWays, s: Node, t: Node, inset: number): Point[] {
  * 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): LevelWays {
+function levelWays(nodes: readonly Node[], options: LevelLinkOptions): LevelWays {
   const margin = options.margin ?? 5;
   const k = options.k ?? 8;
   let size = 0;
@@ -110,8 +157,130 @@ function levelWays(nodes: readonly Node[], options: WayOptions): LevelWays {
   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() };
+  const tightGraph = (): CornerGraph => (tight ??= new CornerGraph(nodes, obstacles, { margin: Math.min(margin, options.tightMargin ?? LEVEL_LINK_DEFAULTS.tightMargin), k, cones: true }));
+  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/model.ts

@@ -20,6 +20,8 @@ export interface Node {
   readonly id: string;
   readonly box: Box;
   readonly ports?: readonly Port[];
+  /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
+  readonly data?: Readonly<Record<string, unknown>>;
 }
 
 /** One end of an edge: a node, and optionally one plug of that node. */

package/src/pick.ts

@@ -0,0 +1,36 @@
+import type { Level } from "./model.ts";
+
+/** This function gives the median width of the shown items of each level, in units of the plane. */
+export function itemSizes(levels: readonly Level[]): number[] {
+  return levels.map((level) => {
+    const sizes = level.items.map((i) => Math.max(i.box.w, i.box.h)).sort((a, b) => a - b);
+    return sizes.length ? sizes[Math.floor(sizes.length / 2)]! : 0;
+  });
+}
+
+/** The far-view thresholds of `pickLevel`, in pixels on the screen. */
+export interface PickOptions {
+  /** When a node is at least this wide on the screen, the view shows each route. */
+  readonly routesAt: number;
+  /** A level is fine enough when its median item is at least this wide on the screen. */
+  readonly itemAt: number;
+}
+
+/** The default thresholds: a node of 22 pixels shows its routes, and a group of 120 pixels shows its parts. */
+export const PICK: PickOptions = Object.freeze({ routesAt: 22, itemAt: 120 });
+
+/**
+ * This function picks the level that a camera shows at a scale, in pixels for each unit of the plane. The sizes come from `itemSizes`.
+ * The value `sizes.length` stands for the routes of each edge. The last level holds the nodes alone.
+ * Each threshold that `options` does not give gets its value from `PICK`.
+ */
+export function pickLevel(sizes: readonly number[], scale: number, options: Partial<PickOptions> = PICK): number {
+  const routesAt = options.routesAt ?? PICK.routesAt;
+  const itemAt = options.itemAt ?? PICK.itemAt;
+  const n = sizes.length;
+  if (n === 0) return 0;
+  if (sizes[n - 1]! * scale >= routesAt) return n;
+  let pick = 0;
+  for (let d = 0; d < n - 1; d++) if (sizes[d]! * scale >= itemAt) pick = d;
+  return pick;
+}

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;