@mark1russell7/highways 0.9.2 → 0.9.4

package/src/families/index.ts

@@ -1,12 +1,14 @@
 // The corpus families of highways on the shared registry of `@mark1russell7/layout-contract` (CORPUS-GEN, L45).
 import { createFamilyRegistry, type FamilyRegistry } from "@mark1russell7/layout-contract";
 import { HUB_CHAIN, MANY_GROUPS, PACKED_GRID } from "./cases.ts";
+import { COVERAGE_FAMILIES } from "./coverage.ts";
 import { DENSE_GROUPS, SMALL_CLUSTERED, TINY_UNIFORM } from "./fixtures.ts";
 import type { HighwaysBoard, HighwaysFamily } from "./model.ts";
 
 export * from "./model.ts";
 export { DENSE_GROUPS, FIXTURE_LAYOUTS, FIXTURE_LOCALITY, fixtureParams, fixtureSpecOf, SMALL_CLUSTERED, TINY_UNIFORM } from "./fixtures.ts";
 export { HUB_CHAIN, MANY_GROUPS, PACKED_GRID } from "./cases.ts";
+export { BIPARTITE, BIPARTITE_LAYOUTS, COVERAGE_FAMILIES, FAN_OUT, FRAME_ROWS, LOCAL_MESH, PIPELINE, SPARSE_LONG, THIN_BARS, TWO_HUBS, UNEVEN_SIZES } from "./coverage.ts";
 // The parts of the shared registry that a host of the families uses. The site imports only `@mark1russell7/highways`.
 export {
   createFamilyRegistry,
@@ -26,9 +28,10 @@ export {
 
 /**
  * The corpus families of highways, in the order of the screen sets. Each family at its defaults makes the board of its screen family.
+ * The first 6 families are the families of `screen-v1` and `screen-v2`. The 9 families of `COVERAGE_FAMILIES` follow them (CORPUS-FAMILIES).
  * An import registers nothing. A host makes a registry with `createFamilyRegistry(HIGHWAYS_FAMILIES)`, or with the lists of other engines too.
  */
-export const HIGHWAYS_FAMILIES: readonly HighwaysFamily[] = Object.freeze([TINY_UNIFORM, SMALL_CLUSTERED, DENSE_GROUPS, HUB_CHAIN, MANY_GROUPS, PACKED_GRID]);
+export const HIGHWAYS_FAMILIES: readonly HighwaysFamily[] = Object.freeze([TINY_UNIFORM, SMALL_CLUSTERED, DENSE_GROUPS, HUB_CHAIN, MANY_GROUPS, PACKED_GRID, ...COVERAGE_FAMILIES]);
 
 /** This function gives a new registry of `HIGHWAYS_FAMILIES`. */
 export function highwaysRegistry(): FamilyRegistry<HighwaysBoard> {

package/src/highways/bronchial/index.ts

@@ -0,0 +1,144 @@
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+import { rootOf } from "../knee/root.ts";
+
+/** The rule that splits the targets of a tip in two: by count, by weight, or at the widest gap of the angles. */
+export type BronchialSplit = "count" | "weight" | "gap";
+
+/** The values of `BronchialSplit`. */
+export const BRONCHIAL_SPLITS: readonly BronchialSplit[] = Object.freeze(["count", "weight", "gap"]);
+
+/** The options of the highway strategy `bronchial` (NAT-019 of the nature notes). */
+export interface BronchialOptions {
+  /**
+   * The rule of the split. With `count`, each half gets half of the targets. With `weight`, the two halves get near-equal sums of the distances from the tip.
+   * With `gap`, the cut goes at the widest gap between the angles of the targets. The default is `count`.
+   */
+  readonly split: BronchialSplit;
+  /** The share of the distance to the center of the targets that a branch grows, from 0.3 to 0.7. The default is 0.5. */
+  readonly share: number;
+  /** A set with this number of targets or fewer stops the splits, from 1 to 3. Each of its targets gets its own way from the tip. The default is 1. */
+  readonly smallest: number;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `bronchial`. */
+export const BRONCHIAL_DEFAULTS: Readonly<BronchialOptions> = Object.freeze({ split: "count", share: 0.5, smallest: 1, detour: 1.5, minSize: 2 });
+
+/**
+ * This function gives the diamond angle of the direction `(dx, dy)`: a value from 0 to 4 that grows with the angle, with no trigonometry.
+ * The value 0 is the direction of the positive x axis.
+ */
+export function diamondAngle(dx: number, dy: number): number {
+  const s = Math.abs(dx) + Math.abs(dy);
+  if (s <= 1e-12) return 0;
+  if (dy >= 0) return dx >= 0 ? dy / s : 1 - dx / s;
+  return dx < 0 ? 2 - dy / s : 3 + dx / s;
+}
+
+/**
+ * This function splits the targets of a tip in two halves (NAT-019). The targets go in the order of their angles around the tip.
+ * The order starts after the widest gap of the angles, so each half is a sector. The rule of `split` then cuts the order in two.
+ */
+export function splitTargets(tip: Point, targets: readonly Point[], ids: readonly number[], split: BronchialSplit): [number[], number[]] {
+  const sorted = [...ids].sort((a, b) => diamondAngle(targets[a]!.x - tip.x, targets[a]!.y - tip.y) - diamondAngle(targets[b]!.x - tip.x, targets[b]!.y - tip.y) || a - b);
+  const angle = (i: number): number => diamondAngle(targets[sorted[i]!]!.x - tip.x, targets[sorted[i]!]!.y - tip.y);
+  const n = sorted.length;
+  // The gap after each target, to the next target around the circle.
+  const gaps = sorted.map((_, i) => (i === n - 1 ? angle(0) + 4 - angle(i) : angle(i + 1) - angle(i)));
+  let widest = 0;
+  for (let i = 1; i < n; i++) if (gaps[i]! > gaps[widest]! + 1e-12) widest = i;
+  const order = [...sorted.slice(widest + 1), ...sorted.slice(0, widest + 1)];
+  let cut = Math.floor(n / 2);
+  if (split === "weight") {
+    const w = order.map((i) => dist(tip, targets[i]!));
+    const total = w.reduce((s, x) => s + x, 0);
+    let run = 0;
+    let best = Infinity;
+    for (let c = 1; c < n; c++) {
+      run += w[c - 1]!;
+      const off = Math.abs(2 * run - total);
+      if (off < best - 1e-9) [best, cut] = [off, c];
+    }
+  } else if (split === "gap") {
+    let best = -Infinity;
+    const at = (k: number): number => diamondAngle(targets[order[k]!]!.x - tip.x, targets[order[k]!]!.y - tip.y);
+    for (let c = 1; c < n; c++) {
+      const g = (at(c) - at(c - 1) + 4) % 4;
+      if (g > best + 1e-12) [best, cut] = [g, c];
+    }
+  }
+  return [order.slice(0, cut), order.slice(cut)];
+}
+
+/**
+ * This function gives the highways of the bronchial trees (NAT-019, after Kitaoka and others, 1999). The edges from one source node get one tree.
+ * The root of a tree is the out point of the plug nearest the center of the targets.
+ * From the tip, the tree grows a share of the way to the center of its targets. Then it splits the targets in two and grows a branch for each half.
+ * A branch that hits a box grows half as far, or not at all. A small set of targets gets its own ways from the tip, through the corner graph.
+ * Each edge takes its path in the tree when that path is short enough, and the stretches that two edges or more share become highways.
+ */
+export function bronchialPlan(input: HighwayInput, o: Readonly<BronchialOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const pad = finder.margin / 2;
+  const first = firstRoutes(input);
+  const groups = new Map<string, { edge: string; key: string; s: Point; t: Point; base: number }[]>();
+  for (const p of edgePlugs(input.graph)) {
+    const s = finder.out(p.ps);
+    const t = finder.out(p.pt);
+    const route = first.get(p.edge.id);
+    const group = p.edge.source.node;
+    const list = groups.get(group) ?? [];
+    list.push({ edge: p.edge.id, key: p.edge.source.node, s, t, base: route ? polylineLength(route) : dist(s, t) });
+    groups.set(group, list);
+  }
+  const share = Math.min(0.7, Math.max(0.3, o.share));
+  const smallest = Math.min(3, Math.max(1, Math.floor(o.smallest)));
+  const ways: KeyedWay[] = [];
+  for (const group of [...groups.keys()].sort()) {
+    const list = groups.get(group)!;
+    if (list.length < 2) continue;
+    const goals = list.map((e) => e.t);
+    const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+    const paths: (Point[] | undefined)[] = list.map(() => undefined);
+    const grow = (trunk: readonly Point[], ids: readonly number[]): void => {
+      const tip = trunk[trunk.length - 1]!;
+      if (ids.length <= smallest) {
+        for (const i of ids) {
+          const way = finder.corners.path(tip, goals[i]!);
+          if (way) paths[i] = [...trunk, ...finder.corners.pull(way).slice(1)];
+        }
+        return;
+      }
+      const c = { x: ids.reduce((s, i) => s + goals[i]!.x, 0) / ids.length, y: ids.reduce((s, i) => s + goals[i]!.y, 0) / ids.length };
+      let next = trunk;
+      for (let f = share; f > share / 8; f /= 2) {
+        const p = { x: tip.x + f * (c.x - tip.x), y: tip.y + f * (c.y - tip.y) };
+        if (dist(p, tip) <= 1e-6) break;
+        if (!finder.obstacles.inside(p, pad) && finder.obstacles.clearPath([tip, p], pad)) {
+          next = [...trunk, p];
+          break;
+        }
+      }
+      const [a, b] = splitTargets(next[next.length - 1]!, goals, ids, o.split);
+      grow(next, a);
+      grow(next, b);
+    };
+    grow([root], list.map((_, i) => i));
+    list.forEach((e, i) => {
+      const tail = paths[i];
+      const lead = leads[i];
+      if (!tail || !lead) return;
+      const points = [...lead, ...tail.slice(1)];
+      if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+      ways.push({ edge: e.edge, key: e.key, points });
+    });
+  }
+  return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}

package/src/highways/index.ts

@@ -102,6 +102,8 @@ export { oneSteiner, spanningTree, STEINER_DEFAULTS, STEINER_GROUPS, STEINER_MET
 export { GAP_DEFAULTS, gapPlan, type GapOptions } from "./gaps/index.ts";
 export { STREET_DEFAULTS, streetPlan, type StreetOptions } from "./streets/index.ts";
 export { SEARCH_DEFAULTS, SEARCH_MOVES, searchPlan, searchScore, type SearchMove, type SearchOptions } from "./search/index.ts";
+export { KNEE_DEFAULTS, KNEE_RULES, kneeOf, kneePlan, type KneeOptions, type KneeRule, type KneeTree } from "./knee/index.ts";
+export { BRONCHIAL_DEFAULTS, BRONCHIAL_SPLITS, bronchialPlan, diamondAngle, splitTargets, type BronchialOptions, type BronchialSplit } from "./bronchial/index.ts";
 export { INTERCHANGE_BASES, INTERCHANGE_DEFAULTS, interchangeCandidates, interchangePlan, type Interchange, type InterchangeBase, type InterchangeOptions } from "./interchanges/index.ts";
 export { SCALE_SPACE_DEFAULTS, scaleClusters, scaleSpaceGroups, scaleSpacePlan, type ScaleCluster, type ScaleSpaceOptions } from "./scale-space/index.ts";
 export * from "./gates/index.ts";

package/src/highways/knee/index.ts

@@ -0,0 +1,154 @@
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { balancedFan, fanPath, type Fan } from "../../routers/fan.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../stretches.ts";
+import { rootOf } from "./root.ts";
+
+/** The rule that picks one tree on the front: the knee of the chord, or the least weighted sum. */
+export type KneeRule = "chord" | "weights";
+
+/** The values of `KneeRule`. */
+export const KNEE_RULES: readonly KneeRule[] = Object.freeze(["chord", "weights"]);
+
+/** The options of the highway strategy `knee` (NAT-018 of the nature notes, on the trees of NAT-017). */
+export interface KneeOptions {
+  /** The number of points of the sweep of the balancing factor, from 5 to 21. The default is 11. */
+  readonly sweep: number;
+  /** The rule that picks one tree on the front. The default is `chord`. */
+  readonly rule: KneeRule;
+  /** The weight of the ink in the rule `weights`, from 0 to 1. The rest of the weight goes to the path length. The default is 0.5. */
+  readonly ink: number;
+  /** An edge rides the tree only when its path in the tree is this many times its first route or less. The default is 1.5. */
+  readonly detour: number;
+  /** A stretch of a tree with fewer edges than this number is not a highway. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `knee`. */
+export const KNEE_DEFAULTS: Readonly<KneeOptions> = Object.freeze({ sweep: 11, rule: "chord", ink: 0.5, detour: 1.5, minSize: 2 });
+
+/** One tree of the sweep: its balancing factor, its ink `L`, the sum of its path lengths `S`, and the tree. */
+export interface KneeTree {
+  readonly bf: number;
+  readonly ink: number;
+  readonly paths: number;
+  readonly fan: Fan;
+}
+
+/** This function gives the ink of a fan: the sum of the lengths of its links. */
+function fanInk(fan: Fan): number {
+  let sum = 0;
+  for (const p of fan.points) if (p.parent >= 0) sum += dist(p.point, fan.points[p.parent]!.point);
+  return sum;
+}
+
+/**
+ * This function adds a stub point at `stub` from the end of the last link of a way. The tree of NAT-017 joins a new branch only at an open point or on a link to one.
+ * The last point of a way is not open, so without the stub no branch joins the last link.
+ */
+function withStub(way: Point[], stub: number): Point[] {
+  if (way.length < 2) return way;
+  const a = way[way.length - 2]!;
+  const b = way[way.length - 1]!;
+  const d = dist(a, b);
+  if (d <= 2 * stub) return way;
+  return [...way.slice(0, -1), { x: b.x + ((a.x - b.x) * stub) / d, y: b.y + ((a.y - b.y) * stub) / d }, b];
+}
+
+/**
+ * This function gives the index of the tree that the rule picks on the front of the trees (NAT-018).
+ * The front holds the trees that no other tree beats on the ink and on the path lengths. The two values go to the range from 0 to 1.
+ * With `chord`, the pick is the tree of the front farthest from the line between the two ends of the front.
+ * With `weights`, the pick is the tree with the least `ink × L + (1 - ink) × S`. A tie goes to the earlier tree.
+ */
+export function kneeOf(trees: readonly Pick<KneeTree, "ink" | "paths">[], rule: KneeRule, ink: number): number {
+  if (trees.length === 0) return -1;
+  const front = trees.map((_, i) => i).filter((i) => !trees.some((q, j) => j !== i && q.ink <= trees[i]!.ink && q.paths <= trees[i]!.paths && (q.ink < trees[i]!.ink || q.paths < trees[i]!.paths)));
+  const lo = { x: Math.min(...front.map((i) => trees[i]!.ink)), y: Math.min(...front.map((i) => trees[i]!.paths)) };
+  const hi = { x: Math.max(...front.map((i) => trees[i]!.ink)), y: Math.max(...front.map((i) => trees[i]!.paths)) };
+  const norm = (i: number): Point => ({
+    x: hi.x - lo.x > 1e-9 ? (trees[i]!.ink - lo.x) / (hi.x - lo.x) : 0,
+    y: hi.y - lo.y > 1e-9 ? (trees[i]!.paths - lo.y) / (hi.y - lo.y) : 0,
+  });
+  let best = front[0]!;
+  let score = rule === "chord" ? -Infinity : Infinity;
+  if (rule === "weights") {
+    const w = Math.min(1, Math.max(0, ink));
+    for (const i of front) {
+      const p = norm(i);
+      const s = w * p.x + (1 - w) * p.y;
+      if (s < score - 1e-12) [best, score] = [i, s];
+    }
+    return best;
+  }
+  // The ends of the front: the tree with the least ink, and the tree with the least path lengths.
+  const a = front.reduce((u, i) => (trees[i]!.ink < trees[u]!.ink || (trees[i]!.ink === trees[u]!.ink && trees[i]!.paths < trees[u]!.paths) ? i : u));
+  const b = front.reduce((u, i) => (trees[i]!.paths < trees[u]!.paths || (trees[i]!.paths === trees[u]!.paths && trees[i]!.ink < trees[u]!.ink) ? i : u));
+  const A = norm(a);
+  const B = norm(b);
+  const len = dist(A, B);
+  if (len <= 1e-12) return a;
+  for (const i of front) {
+    const p = norm(i);
+    const s = Math.abs((B.x - A.x) * (A.y - p.y) - (A.x - p.x) * (B.y - A.y)) / len;
+    if (s > score + 1e-12) [best, score] = [i, s];
+  }
+  return best;
+}
+
+/**
+ * This function gives the highways of the knee trees (NAT-018). The edges from one source node get one tree. Its root is the out point of the plug nearest the center of the targets.
+ * A sweep of the balancing factor of NAT-017 gives trees from the least ink to the most direct paths.
+ * The tree at the knee of the front of ink and path lengths is the pick. Each edge takes its path in the tree, when that path is short enough.
+ * The stretches of the tree that two edges or more share become highways.
+ */
+export function kneePlan(input: HighwayInput, o: Readonly<KneeOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes);
+  const first = firstRoutes(input);
+  const groups = new Map<string, { edge: string; key: string; s: Point; t: Point; base: number }[]>();
+  for (const p of edgePlugs(input.graph)) {
+    const s = finder.out(p.ps);
+    const t = finder.out(p.pt);
+    const route = first.get(p.edge.id);
+    const group = p.edge.source.node;
+    const list = groups.get(group) ?? [];
+    list.push({ edge: p.edge.id, key: p.edge.source.node, s, t, base: route ? polylineLength(route) : dist(s, t) });
+    groups.set(group, list);
+  }
+  const sweep = Math.min(21, Math.max(2, Math.floor(o.sweep)));
+  const ways: KeyedWay[] = [];
+  for (const group of [...groups.keys()].sort()) {
+    const list = groups.get(group)!;
+    if (list.length < 2) continue;
+    const goals = list.map((e) => e.t);
+    const { root, leads } = rootOf(finder, list.map((e) => e.s), goals);
+    const lost = new Set<number>();
+    const branch = (from: Point, t: number): Point[] => {
+      const way = finder.corners.path(from, goals[t]!);
+      if (way) return withStub(finder.corners.pull(way), finder.margin);
+      lost.add(t);
+      return [from, goals[t]!];
+    };
+    // The sweep: the cost `a L + (1 - a) S` for `a` from `1 / sweep` to 1, as the balancing factor `bf = (1 - a) / a`.
+    const trees: KneeTree[] = [];
+    for (let k = 0; k < sweep; k++) {
+      const a = (k + 1) / sweep;
+      const bf = (1 - a) / a;
+      const fan = balancedFan(root, goals, bf, branch);
+      let paths = 0;
+      for (const leaf of fan.leaf) paths += fan.points[leaf]!.pl;
+      trees.push({ bf, ink: fanInk(fan), paths, fan });
+    }
+    const pick = trees[kneeOf(trees, o.rule, o.ink)]!;
+    list.forEach((e, t) => {
+      const lead = leads[t];
+      if (lost.has(t) || !lead) return;
+      const points = [...lead, ...fanPath(pick.fan, pick.fan.leaf[t]!).slice(1)];
+      if (points.length < 2 || polylineLength(points) > o.detour * e.base) return;
+      ways.push({ edge: e.edge, key: e.key, points });
+    });
+  }
+  return sharedStretches(ways, { minSize: Math.max(2, Math.floor(o.minSize)) });
+}

package/src/highways/knee/root.ts

@@ -0,0 +1,19 @@
+import { dist, type Point } from "../../geom.ts";
+import type { WayFinder } from "../../ways.ts";
+
+/**
+ * This function gives the root of the tree of one source node (NAT-018, NAT-019): the start point nearest the center of the targets.
+ * It also gives the lead of each edge, the way from its own start point to the root. A lead is `undefined` when the corner graph has no way.
+ */
+export function rootOf(finder: WayFinder, starts: readonly Point[], goals: readonly Point[]): { root: Point; leads: (Point[] | undefined)[] } {
+  const c = { x: goals.reduce((s, p) => s + p.x, 0) / goals.length, y: goals.reduce((s, p) => s + p.y, 0) / goals.length };
+  let root = starts[0]!;
+  for (const s of starts) if (dist(s, c) < dist(root, c) - 1e-9) root = s;
+  const leads = starts.map((s) => {
+    if (dist(s, root) <= 1e-9) return [root];
+    if (finder.obstacles.clearPath([s, root], finder.margin / 2)) return [s, root];
+    const way = finder.corners.path(s, root);
+    return way ? finder.corners.pull(way) : undefined;
+  });
+  return { root, leads };
+}

package/src/index.ts

@@ -18,8 +18,12 @@ export * from "./room/index.ts";
 export * from "./room/lanes.ts";
 export * from "./room/levels/index.ts";
 export * from "./plugs/facing/index.ts";
+export * from "./plugs/spread/index.ts";
+export * from "./plugs/fix.ts";
 export * from "./levels/depths/index.ts";
 export * from "./whole/pipeline/index.ts";
+export * from "./levels/venation/index.ts";
+export * from "./whole/portfolio/index.ts";
 export * from "./bench/properties.ts";
 export * from "./bench/quality.ts";
 export * from "./bench/links.ts";

package/src/levels/venation/index.ts

@@ -0,0 +1,191 @@
+import { center, dist, polylineLength, type Box, type Point } from "../../geom.ts";
+import { levelLinks, type ItemPair } from "../../levels.ts";
+import type { Level, LevelItem, LevelLink } from "../../model.ts";
+import type { LevelInput } from "../../strategies/model.ts";
+import { depthLevels, type DepthLevelOptions } from "../depths/index.ts";
+
+/** The graph of the backbone of a level: the relative neighbourhood graph, or the Gabriel graph of the centers of the items. */
+export type VenationBackbone = "rng" | "gabriel";
+
+/** The values of `VenationBackbone`. */
+export const VENATION_BACKBONES: readonly VenationBackbone[] = Object.freeze(["rng", "gabriel"]);
+
+/** The options of the level strategy `venation` (NAT-016 of the nature notes): the options of `depths`, and the options of the backbone. */
+export interface VenationOptions extends DepthLevelOptions {
+  /** The graph of the backbone. The relative neighbourhood graph has fewer links than the Gabriel graph. The default is `rng`. */
+  readonly backbone: VenationBackbone;
+  /** A later level link saves this share of the cost of a backbone link that an earlier level link uses, from 0 to 0.8. The default is 0.4. */
+  readonly discount: number;
+  /** A level link takes its way on the backbone only when that way is this many times its direct link or less. The default is 1.5. */
+  readonly detour: number;
+  /** A level with more items than this number keeps the links of `depths`. The default is 400. */
+  readonly maxItems: number;
+}
+
+/** The default options of the level strategy `venation`. */
+export const VENATION_DEFAULTS: Readonly<VenationOptions> = Object.freeze({ backbone: "rng", discount: 0.4, detour: 1.5, maxItems: 400 });
+
+/**
+ * This function gives the links of the backbone of the points, as pairs of indices `i < j` (NAT-016).
+ * With `rng`, the link `p q` exists when no third point `r` has `max(d(p, r), d(q, r)) < d(p, q)`.
+ * With `gabriel`, the link exists when no third point is inside the circle with the diameter `p q`.
+ */
+export function backboneLinks(points: readonly Point[], backbone: VenationBackbone): [number, number][] {
+  const out: [number, number][] = [];
+  const n = points.length;
+  const d2 = (a: Point, b: Point): number => (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const pq = d2(points[i]!, points[j]!);
+      let keep = true;
+      for (let r = 0; r < n && keep; r++) {
+        if (r === i || r === j) continue;
+        const pr = d2(points[i]!, points[r]!);
+        const qr = d2(points[j]!, points[r]!);
+        if (backbone === "rng" ? Math.max(pr, qr) < pq - 1e-9 : pr + qr < pq - 1e-9) keep = false;
+      }
+      if (keep) out.push([i, j]);
+    }
+  }
+  return out;
+}
+
+/**
+ * This function gives a way around the box `b`, inflated by `m`, from the point `a` to the point `c` of its boundary.
+ * The way goes along the shorter side of the inflated box. It holds the two points at `m` out from `a` and `c`, and the corners between them.
+ */
+export function aroundBox(b: Box, m: number, a: Point, c: Point): Point[] {
+  const x0 = b.x - m;
+  const y0 = b.y - m;
+  const x1 = b.x + b.w + m;
+  const y1 = b.y + b.h + m;
+  const w = x1 - x0;
+  const h = y1 - y0;
+  const per = 2 * (w + h);
+  // The point on the boundary of the inflated box nearest to `p`, and its place along the boundary, clockwise from the top left corner.
+  const onBoundary = (p: Point): { p: Point; t: number } => {
+    const cx = Math.min(x1, Math.max(x0, p.x));
+    const cy = Math.min(y1, Math.max(y0, p.y));
+    const dl = cx - x0;
+    const dr = x1 - cx;
+    const dt = cy - y0;
+    const db = y1 - cy;
+    const least = Math.min(dl, dr, dt, db);
+    if (least === dt) return { p: { x: cx, y: y0 }, t: cx - x0 };
+    if (least === dr) return { p: { x: x1, y: cy }, t: w + (cy - y0) };
+    if (least === db) return { p: { x: cx, y: y1 }, t: w + h + (x1 - cx) };
+    return { p: { x: x0, y: cy }, t: 2 * w + h + (y1 - cy) };
+  };
+  const corners: { p: Point; t: number }[] = [
+    { p: { x: x0, y: y0 }, t: 0 },
+    { p: { x: x1, y: y0 }, t: w },
+    { p: { x: x1, y: y1 }, t: w + h },
+    { p: { x: x0, y: y1 }, t: 2 * w + h },
+  ];
+  const A = onBoundary(a);
+  const C = onBoundary(c);
+  const ahead = (C.t - A.t + per) % per;
+  const out: Point[] = [A.p];
+  if (ahead <= per / 2) {
+    const list = corners.map((k) => ({ ...k, s: (k.t - A.t + per) % per })).filter((k) => k.s > 1e-9 && k.s < ahead - 1e-9);
+    for (const k of list.sort((p, q) => p.s - q.s)) out.push(k.p);
+  } else {
+    const back = per - ahead;
+    const list = corners.map((k) => ({ ...k, s: (A.t - k.t + per) % per })).filter((k) => k.s > 1e-9 && k.s < back - 1e-9);
+    for (const k of list.sort((p, q) => p.s - q.s)) out.push(k.p);
+  }
+  out.push(C.p);
+  return out.filter((p, i) => i === 0 || dist(p, out[i - 1]!) > 1e-9);
+}
+
+/**
+ * This function gives the links of one level along a closed venation backbone (NAT-016, after Runions and others, 2005).
+ * The backbone links the items by their relative neighbourhood graph or their Gabriel graph. Each backbone link goes around the other items.
+ * The level links go in the order of their counts, the largest first. Each one takes the cheapest way on the backbone, with the cost `L (1 - discount)` for a used backbone link.
+ * The way goes around each item between its two ends. A way longer than `detour` times the direct link, or a direct backbone link, keeps the direct link.
+ */
+export function venationLinks(items: readonly LevelItem[], direct: readonly LevelLink[], o: Readonly<VenationOptions>): LevelLink[] {
+  if (direct.length < 2 || items.length < 3 || items.length > o.maxItems) return [...direct];
+  const index = new Map(items.map((it, i) => [it.id, i]));
+  const links = backboneLinks(items.map((it) => center(it.box)), o.backbone);
+  const pairs: ItemPair[] = links.map(([i, j]) => ({ source: items[i]!.id, target: items[j]!.id, count: 1 }));
+  const routed = levelLinks(items, pairs, o);
+  const n = items.length;
+  const next: { to: number; link: number }[][] = Array.from({ length: n }, () => []);
+  const cost = routed.map((l) => polylineLength(l.points));
+  routed.forEach((l, k) => {
+    const i = index.get(l.source)!;
+    const j = index.get(l.target)!;
+    next[i]!.push({ to: j, link: k });
+    next[j]!.push({ to: i, link: k });
+  });
+  const direct2 = new Set(links.map(([i, j]) => `${i},${j}`));
+  const used = new Uint8Array(routed.length);
+  const share = 1 - Math.min(0.8, Math.max(0, o.discount));
+  const order = direct.map((_, k) => k).sort((p, q) => direct[q]!.count - direct[p]!.count || direct[p]!.source.localeCompare(direct[q]!.source) || direct[p]!.target.localeCompare(direct[q]!.target));
+  const margin = o.margin ?? 5;
+  const out = [...direct];
+  for (const k of order) {
+    const l = direct[k]!;
+    const s = index.get(l.source);
+    const t = index.get(l.target);
+    if (s === undefined || t === undefined) continue;
+    if (direct2.has(`${Math.min(s, t)},${Math.max(s, t)}`)) {
+      const at = next[s]!.find((x) => x.to === t);
+      if (at) used[at.link] = 1;
+      continue;
+    }
+    // Dijkstra on the backbone. The graph is small, so a scan for the least open item is enough.
+    const best = new Float64Array(n).fill(Infinity);
+    const from = new Int32Array(n).fill(-1);
+    const via = new Int32Array(n).fill(-1);
+    const done = new Uint8Array(n);
+    best[s] = 0;
+    for (;;) {
+      let u = -1;
+      for (let i = 0; i < n; i++) if (!done[i] && best[i]! < Infinity && (u < 0 || best[i]! < best[u]!)) u = i;
+      if (u < 0 || u === t) break;
+      done[u] = 1;
+      for (const x of next[u]!) {
+        const c = best[u]! + cost[x.link]! * (used[x.link] ? share : 1);
+        if (c < best[x.to]! - 1e-9) {
+          best[x.to] = c;
+          from[x.to] = u;
+          via[x.to] = x.link;
+        }
+      }
+    }
+    if (from[t]! < 0) continue;
+    const hops: { link: number; forward: boolean }[] = [];
+    for (let v = t; v !== s; v = from[v]!) hops.push({ link: via[v]!, forward: routed[via[v]!]!.target === items[v]!.id });
+    hops.reverse();
+    const points: Point[] = [];
+    hops.forEach((h, i) => {
+      const p = routed[h.link]!.points;
+      const seq = h.forward ? [...p] : [...p].reverse();
+      if (i > 0) {
+        // The way goes around the item between the end of the hop before and the start of this hop.
+        const item = items[index.get(h.forward ? routed[h.link]!.source : routed[h.link]!.target)!]!;
+        const around = aroundBox(item.box, margin, points[points.length - 1]!, seq[0]!);
+        // The first point stays: it is on the box of the source. A link between two items that touch has no length, so its two points are one point.
+        if (points.length > 1) points.pop();
+        points.push(...around);
+        seq.shift();
+      }
+      for (const q of seq) if (points.length === 0 || dist(q, points[points.length - 1]!) > 1e-9) points.push(q);
+    });
+    if (points.length < 2 || polylineLength(points) > o.detour * polylineLength(l.points)) continue;
+    for (const h of hops) used[h.link] = 1;
+    out[k] = { ...l, points };
+  }
+  return out;
+}
+
+/**
+ * This function gives the zoom levels of the level strategy `venation` (NAT-016). The levels and their items are the levels of `depths`.
+ * In each level with groups, the links take their ways along a closed venation backbone (`venationLinks`). The last level stays as in `depths`.
+ */
+export function venationLevels(input: LevelInput, options: Readonly<VenationOptions>): Level[] {
+  const levels = depthLevels(input, options);
+  return levels.map((level, i) => (i === levels.length - 1 ? level : { ...level, links: venationLinks(level.items, level.links, options) }));
+}