@mark1russell7/highways 0.4.2 → 0.5.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -30,7 +30,9 @@
   },
   "devDependencies": {
     "@mark1russell7/cue": "github:mark1russell7/cue",
+    "@mark1russell7/layout-contract": "github:mark1russell7/layout-contract#69933a61b0270c5915b82ab563d24908ade708af&path:/packages/layout-contract",
     "@types/node": "^26.6.4",
+    "highs": "^1.15.4",
     "typescript": "^7.0.2",
     "vitest": "^5.0.3"
   },

package/src/bench/exact/index.ts

@@ -0,0 +1,197 @@
+import { dist, type Point } from "../../geom.ts";
+import { edgePlugs, sharedStretches, type KeyedWay } from "../../highways/stretches.ts";
+import type { HighwayPlan } from "../../highways/model.ts";
+import type { Graph } from "../../model.ts";
+import { byCollection } from "../../routers/trunks.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+
+/** The edges that can share a link: all the edges, or only the edges of one collection, as with the rule `byCollection`. */
+export type ExactRule = "all" | "collection";
+
+/** The options of the exact model of fixed-charge network design (HWY-040). */
+export interface ExactOptions extends WayOptions {
+  /** The way of each edge is this value times its shortest way or shorter. */
+  readonly stretch: number;
+  /** The edges that can share a link. */
+  readonly rule: ExactRule;
+  /** The cost of each unit of length of each way, as a share of the cost of the ink. A small value removes needless loops. The default is 0.001. */
+  readonly epsilon?: number;
+}
+
+/** A model of fixed-charge network design as the text of a mixed integer program (CPLEX LP format), and the function that reads its solution. */
+export interface ExactModel {
+  /** The text of the program in the CPLEX LP format. */
+  readonly lp: string;
+  /** The number of binary variables. */
+  readonly columns: number;
+  /** The number of constraints. */
+  readonly rows: number;
+  /** The number of edges in the model. An edge without a way in the stretch limit is not in the model. */
+  readonly edges: number;
+  /** This function gives the plan of a solution. `value` gives the value of a variable by its name. */
+  decode(value: (name: string) => number): HighwayPlan;
+}
+
+interface Arc {
+  readonly from: number;
+  readonly to: number;
+  readonly link: number;
+  readonly len: number;
+}
+
+/** This function gives the shortest distance from `start` to each node, with Dijkstra on an adjacency list. */
+function distances(adj: readonly (readonly { to: number; len: number }[])[], start: number): Float64Array {
+  const d = new Float64Array(adj.length).fill(Infinity);
+  d[start] = 0;
+  const done = new Uint8Array(adj.length);
+  // The boards of the model are small, so a scan for the smallest open node is fast enough.
+  for (;;) {
+    let u = -1;
+    for (let i = 0; i < adj.length; i++) if (!done[i] && d[i]! < Infinity && (u < 0 || d[i]! < d[u]!)) u = i;
+    if (u < 0) return d;
+    done[u] = 1;
+    for (const { to, len } of adj[u]!) if (d[u]! + len < d[to]!) d[to] = d[u]! + len;
+  }
+}
+
+/**
+ * This function gives the model of fixed-charge network design (Magnanti and Wong 1984) for the edges of a graph (HWY-040).
+ * The network is the corner graph, plus the point out of each plug. Each link costs its length once for each key that uses it.
+ * Each edge goes one way between the points out of its two plugs. The way is `stretch` times its shortest way or shorter.
+ * The optimum has the least ink for the stretch limit. The ways of the solution give highways with `sharedStretches`.
+ */
+export function exactModel(graph: Graph, o: Readonly<ExactOptions>): ExactModel {
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const corners = finder.corners;
+  const k = o.k ?? 8;
+  const pad = finder.margin / 2;
+  const points: Point[] = [...corners.points];
+  const ids = new Map<string, number>();
+  const nodeOf = (p: Point): number => {
+    const key = `${p.x},${p.y}`;
+    let id = ids.get(key);
+    if (id === undefined) {
+      id = points.length;
+      points.push(p);
+      ids.set(key, id);
+    }
+    return id;
+  };
+  corners.points.forEach((p, i) => ids.set(`${p.x},${p.y}`, i));
+  const plugs = edgePlugs(graph);
+  const ends = plugs.map(({ edge, ps, pt }) => ({ edge: edge.id, key: o.rule === "all" ? "*" : (byCollection(edge) ?? `\u0000${edge.id}`), a: nodeOf(finder.out(ps)), b: nodeOf(finder.out(pt)) }));
+
+  // The links: each corner to its k nearest visible corners, as in the corner graph, and each end point to its 2k nearest visible corners.
+  const linkIds = new Map<string, number>();
+  const links: { u: number; v: number; len: number }[] = [];
+  const addLink = (u: number, v: number): void => {
+    if (u === v) return;
+    const key = u < v ? `${u},${v}` : `${v},${u}`;
+    if (linkIds.has(key)) return;
+    linkIds.set(key, links.length);
+    links.push({ u: Math.min(u, v), v: Math.max(u, v), len: dist(points[u]!, points[v]!) });
+  };
+  for (let i = 0; i < corners.points.length; i++) for (const j of corners.nearestVisible(corners.points[i]!, k, i)) addLink(i, j);
+  for (let t = corners.points.length; t < points.length; t++) for (const j of corners.nearestVisible(points[t]!, 2 * k)) addLink(t, j);
+  for (const e of ends) if (finder.obstacles.clear(points[e.a]!, points[e.b]!, pad)) addLink(e.a, e.b);
+  const adj: { to: number; len: number }[][] = points.map(() => []);
+  for (const l of links) {
+    adj[l.u]!.push({ to: l.v, len: l.len });
+    adj[l.v]!.push({ to: l.u, len: l.len });
+  }
+
+  // The arcs of each edge: the arcs on some way within the stretch limit.
+  const eps = o.epsilon ?? 0.001;
+  const objective: string[] = [];
+  const rows: string[] = [];
+  const binaries: string[] = [];
+  const keys = [...new Set(ends.map((e) => e.key))];
+  const used = new Map<string, Set<number>>();
+  const arcsOf: { e: number; arcs: Arc[] }[] = [];
+  ends.forEach((e, ei) => {
+    const da = distances(adj, e.a);
+    const db = distances(adj, e.b);
+    const best = da[e.b]!;
+    if (!Number.isFinite(best) || e.a === e.b) return;
+    const limit = o.stretch * best + 1e-9;
+    const arcs: Arc[] = [];
+    links.forEach((l, li) => {
+      if (da[l.u]! + l.len + db[l.v]! <= limit) arcs.push({ from: l.u, to: l.v, link: li, len: l.len });
+      if (da[l.v]! + l.len + db[l.u]! <= limit) arcs.push({ from: l.v, to: l.u, link: li, len: l.len });
+    });
+    arcsOf.push({ e: ei, arcs });
+    let set = used.get(e.key);
+    if (!set) used.set(e.key, (set = new Set()));
+    for (const a of arcs) set.add(a.link);
+    // Flow: one unit leaves `a` and arrives at `b`.
+    const flow = new Map<number, string[]>();
+    const term = (n: number, s: string): void => {
+      const list = flow.get(n);
+      if (list) list.push(s);
+      else flow.set(n, [s]);
+    };
+    const stretch: string[] = [];
+    for (const a of arcs) {
+      const x = `x${ei}_${a.link}_${a.from < a.to ? 0 : 1}`;
+      binaries.push(x);
+      objective.push(`${(eps * a.len).toFixed(6)} ${x}`);
+      term(a.from, `+ ${x}`);
+      term(a.to, `- ${x}`);
+      stretch.push(`${a.len.toFixed(6)} ${x}`);
+    }
+    for (const [n, list] of flow) rows.push(`f${ei}_${n}: ${list.join(" ")} = ${n === e.a ? 1 : n === e.b ? -1 : 0}`);
+    rows.push(`s${ei}: ${stretch.join(" + ")} <= ${limit.toFixed(6)}`);
+    // An arc needs its link open for the key of the edge.
+    const byLink = new Map<number, string[]>();
+    for (const a of arcs) {
+      const list = byLink.get(a.link);
+      const x = `x${ei}_${a.link}_${a.from < a.to ? 0 : 1}`;
+      if (list) list.push(x);
+      else byLink.set(a.link, [x]);
+    }
+    const ki = keys.indexOf(e.key);
+    for (const [li, xs] of byLink) rows.push(`o${ei}_${li}: ${xs.join(" + ")} - y${ki}_${li} <= 0`);
+  });
+  keys.forEach((key, ki) => {
+    for (const li of used.get(key) ?? []) {
+      const y = `y${ki}_${li}`;
+      binaries.push(y);
+      objective.push(`${links[li]!.len.toFixed(6)} ${y}`);
+    }
+  });
+  const wrap = (terms: readonly string[]): string => {
+    const out: string[] = [];
+    for (let i = 0; i < terms.length; i += 8) out.push(terms.slice(i, i + 8).join(" + "));
+    return out.join("\n + ");
+  };
+  const lp = [
+    "Minimize",
+    ` obj: ${objective.length > 0 ? wrap(objective) : "0 dummy"}`,
+    "Subject To",
+    ...rows.map((r) => ` ${r.replace(/((?:\S+\s+){24})/g, "$1\n ")}`),
+    "Binary",
+    ...Array.from({ length: Math.ceil(binaries.length / 8) }, (_, i) => ` ${binaries.slice(i * 8, i * 8 + 8).join(" ")}`),
+    "End",
+    "",
+  ].join("\n");
+
+  const decode = (value: (name: string) => number): HighwayPlan => {
+    const ways: KeyedWay[] = [];
+    for (const { e: ei, arcs } of arcsOf) {
+      const e = ends[ei]!;
+      const next = new Map<number, number>();
+      for (const a of arcs) if (value(`x${ei}_${a.link}_${a.from < a.to ? 0 : 1}`) > 0.5) next.set(a.from, a.to);
+      const seq: Point[] = [points[e.a]!];
+      let at = e.a;
+      for (let guard = 0; at !== e.b && guard <= points.length; guard++) {
+        const to = next.get(at);
+        if (to === undefined) break;
+        seq.push(points[to]!);
+        at = to;
+      }
+      if (at === e.b) ways.push({ edge: e.edge, key: e.key, points: seq });
+    }
+    return sharedStretches(ways, { minSize: 2 });
+  };
+  return { lp, columns: binaries.length, rows: rows.length, edges: arcsOf.length, decode };
+}

package/src/bench/measures/index.ts

@@ -9,3 +9,4 @@ export * from "./room.ts";
 export * from "./pareto.ts";
 export * from "./order.ts";
 export * from "./highways.ts";
+export * from "./lanes.ts";

package/src/bench/measures/lanes.ts

@@ -0,0 +1,304 @@
+import { dist, frechet, pointSegmentDistance, segmentsCross, type Point } from "../../geom.ts";
+import { Grid } from "../../grid.ts";
+import type { Graph, Result, Route } from "../../model.ts";
+import { laneRoutes, runKey, segmentsOf, type SegmentGraph } from "../../segments.ts";
+import { measureRouteFaults } from "../links.ts";
+import { segmentKey } from "./routes.ts";
+import { quantile } from "./stats.ts";
+
+/**
+ * The lane width of the lane measures, in units of the board. The room bench opens the lanes at the same width (`spacing` of `measureBoard`).
+ * R12 also uses it as the smallest correct distance between two parallel legs.
+ */
+export const MEASURE_LANE_WIDTH = 4;
+
+/** The routes of a result with each shared segment open: one lane for each edge. */
+export interface OpenLanes {
+  /** The segments of the result. The shared segments are the runs and the trunks of the bundles. */
+  readonly graph: SegmentGraph;
+  /** The lane route of each edge, from `laneRoutes`. Without a shared segment, the lane routes are the routes. */
+  readonly lanes: readonly Route[];
+  /** The distance between two lanes. */
+  readonly width: number;
+}
+
+/** This function opens each shared segment of a result: each edge of a run or of a trunk gets its own lane, `width` apart. */
+export function openLanes(result: Result, width: number = MEASURE_LANE_WIDTH): OpenLanes {
+  const graph = segmentsOf(result);
+  const open = new Set(graph.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  return { graph, lanes: laneRoutes(graph, open, width), width };
+}
+
+/** One drawn segment and the sorted ids of the edges that draw it. */
+interface Leg {
+  readonly a: Point;
+  readonly b: Point;
+  readonly edges: string;
+}
+
+/** This function gives each drawn segment of the routes one time, with the edges that draw it. A segment shorter than the grain of `segmentKey` is not a leg. */
+function legsOf(routes: readonly Route[]): Leg[] {
+  const byKey = new Map<string, { a: Point; b: Point; edges: Set<string> }>();
+  for (const r of routes) {
+    for (let i = 1; i < r.points.length; i++) {
+      const a = r.points[i - 1]!;
+      const b = r.points[i]!;
+      const k = segmentKey(a, b);
+      if (k === undefined) continue;
+      const leg = byKey.get(k);
+      if (leg) leg.edges.add(r.edge);
+      else byKey.set(k, { a, b, edges: new Set([r.edge]) });
+    }
+  }
+  return [...byKey.values()].map((l) => ({ a: l.a, b: l.b, edges: [...l.edges].sort().join("\u0000") }));
+}
+
+/** This function gives the distance between the segments `ab` and `cd`. It is 0 when they cross or touch. */
+function segmentDistance(a: Point, b: Point, c: Point, d: Point): number {
+  if (segmentsCross(a, b, c, d)) return 0;
+  return Math.min(pointSegmentDistance(a, c, d), pointSegmentDistance(b, c, d), pointSegmentDistance(c, a, b), pointSegmentDistance(d, a, b));
+}
+
+/** This function gives the length of the union of intervals. */
+function unionLength(intervals: [number, number][]): number {
+  intervals.sort((p, q) => p[0] - q[0]);
+  let sum = 0;
+  let lo = Number.NEGATIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const [a, b] of intervals) {
+    if (a > hi) {
+      if (hi > lo) sum += hi - lo;
+      lo = a;
+      hi = b;
+    } else hi = Math.max(hi, b);
+  }
+  if (hi > lo) sum += hi - lo;
+  return sum;
+}
+
+/**
+ * This function gives the lane separation of the routes (R12 of MEAS0): the share of the ink that runs too near a parallel leg of other edges.
+ *
+ * A leg is a drawn segment of `S`, and a leg that several routes share counts one time, as in B1. Two legs are near when four things are true.
+ * The sets of their edges are different. They are within `maxAngle` degrees of parallel. Their projections overlap. Their distance is less than `near`.
+ *
+ * `ns = Σ_s length(the part of s that the projections of its near legs cover) / ink(S)`. Each part counts one time, so the scale is 0 to 1.
+ * Lower is better. Routes without ink give 0. A grid of buckets finds the near legs, so the cost is `n log n` for an even density.
+ */
+export function routeSeparation(routes: readonly Route[], near: number = MEASURE_LANE_WIDTH, maxAngle = 5): number {
+  const legs = legsOf(routes);
+  let ink = 0;
+  for (const l of legs) ink += dist(l.a, l.b);
+  if (ink <= 0) return 0;
+  const grid = new Grid<number>(Math.max(16, 4 * near));
+  legs.forEach((l, i) => grid.addSegment(i, l.a, l.b));
+  const sin = Math.sin((maxAngle * Math.PI) / 180);
+  let close = 0;
+  legs.forEach((s, i) => {
+    const length = dist(s.a, s.b);
+    const ux = (s.b.x - s.a.x) / length;
+    const uy = (s.b.y - s.a.y) / length;
+    const cover: [number, number][] = [];
+    grid.querySegment(s.a, s.b, near, (j) => {
+      const t = legs[j]!;
+      if (j === i || t.edges === s.edges) return;
+      const tx = t.b.x - t.a.x;
+      const ty = t.b.y - t.a.y;
+      const tl = Math.hypot(tx, ty);
+      if (Math.abs(ux * ty - uy * tx) > sin * tl) return;
+      const p = (t.a.x - s.a.x) * ux + (t.a.y - s.a.y) * uy;
+      const q = (t.b.x - s.a.x) * ux + (t.b.y - s.a.y) * uy;
+      const lo = Math.max(0, Math.min(p, q));
+      const hi = Math.min(length, Math.max(p, q));
+      if (hi - lo <= 1e-9 || segmentDistance(s.a, s.b, t.a, t.b) >= near) return;
+      cover.push([lo, hi]);
+    });
+    close += unionLength(cover);
+  });
+  return Math.min(1, close / ink);
+}
+
+/**
+ * This function gives the orthogonality of the routes (R14 of MEAS0): `orth = Σ L(legs within maxAngle degrees of an axis) / Σ_e L(r_e)`.
+ * Each route counts its own legs, also on a shared segment. The scale is 0 to 1, and higher is better for an orthogonal style.
+ * Routes without length give 1. The cost is linear.
+ */
+export function orthogonality(routes: readonly Route[], maxAngle = 1): number {
+  const tan = Math.tan((maxAngle * Math.PI) / 180);
+  let total = 0;
+  let straight = 0;
+  for (const r of routes) {
+    for (let i = 1; i < r.points.length; i++) {
+      const dx = Math.abs(r.points[i]!.x - r.points[i - 1]!.x);
+      const dy = Math.abs(r.points[i]!.y - r.points[i - 1]!.y);
+      const l = Math.hypot(dx, dy);
+      total += l;
+      if (Math.min(dx, dy) <= tan * Math.max(dx, dy)) straight += l;
+    }
+  }
+  return total > 0 ? straight / total : 1;
+}
+
+/**
+ * This function counts the lane crossings of the segments of a result (B5 of MEAS0): the pairs of edges whose lane order flips.
+ * Along the route of each edge `e`, it takes the shared segments in order. On each one, another edge `f` is on the left or on the right of `e`, in the way of `e`.
+ *
+ * A pair `(e, f)` counts one time when the side of `f` changes from one shared segment of both edges to the next one.
+ * Lower is better. A result without shared segments gives 0. The cost is the sum of the squares of the edge counts of the shared segments.
+ */
+export function laneCrossings(graph: SegmentGraph): number {
+  const shared = new Map(graph.segments.filter((s) => s.count > 1).map((s) => [s.id, s] as const));
+  const flipped = new Set<string>();
+  for (const path of graph.paths) {
+    const side = new Map<string, number>();
+    for (const ref of path.segments) {
+      const s = shared.get(ref.segment);
+      if (!s) continue;
+      s.edges.forEach((f, lane) => {
+        if (f === path.edge) return;
+        const now = Math.sign(lane - ref.lane) * (ref.reverse ? -1 : 1);
+        const before = side.get(f);
+        if (before !== undefined && before !== now) flipped.add(path.edge < f ? `${path.edge}\u0000${f}` : `${f}\u0000${path.edge}`);
+        side.set(f, now);
+      });
+    }
+  }
+  return flipped.size;
+}
+
+/** This function adds the key of each cell of side `u` that the segment `ab` touches, with an exact walk over the cells (Amanatides and Woo, 1987). */
+function touchCells(a: Point, b: Point, u: number, cells: Set<string>): void {
+  let i = Math.floor(a.x / u);
+  let j = Math.floor(a.y / u);
+  const iEnd = Math.floor(b.x / u);
+  const jEnd = Math.floor(b.y / u);
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const sx = Math.sign(dx);
+  const sy = Math.sign(dy);
+  const deltaX = dx !== 0 ? u / Math.abs(dx) : Number.POSITIVE_INFINITY;
+  const deltaY = dy !== 0 ? u / Math.abs(dy) : Number.POSITIVE_INFINITY;
+  let maxX = dx !== 0 ? ((sx > 0 ? (i + 1) * u : i * u) - a.x) / dx : Number.POSITIVE_INFINITY;
+  let maxY = dy !== 0 ? ((sy > 0 ? (j + 1) * u : j * u) - a.y) / dy : Number.POSITIVE_INFINITY;
+  cells.add(`${i},${j}`);
+  while (i !== iEnd || j !== jEnd) {
+    // At a corner of four cells, the walk steps on both axes, so it does not touch the two side cells.
+    const moveX = j === jEnd || (i !== iEnd && maxX <= maxY);
+    const moveY = i === iEnd || (j !== jEnd && maxY <= maxX);
+    if (moveX) {
+      i += sx;
+      maxX += deltaX;
+    }
+    if (moveY) {
+      j += sy;
+      maxY += deltaY;
+    }
+    cells.add(`${i},${j}`);
+  }
+}
+
+/**
+ * This function gives the occupied area of the routes (B7 of MEAS0): `moa = cells that S touches / cells that the straight lines touch`.
+ * The cells are squares of side `unit` from the origin, and `unit` is `u` of the board (`boardUnit`). The straight line of an edge joins the two ends of its route.
+ * The scale is a ratio, and lower is better. Routes without a straight line give 1. The cost is linear in the cells.
+ */
+export function occupiedArea(routes: readonly Route[], unit: number): number {
+  const u = unit > 0 ? unit : 1;
+  const drawn = new Set<string>();
+  const straight = new Set<string>();
+  for (const r of routes) {
+    const p = r.points;
+    if (p.length < 2) continue;
+    for (let i = 1; i < p.length; i++) touchCells(p[i - 1]!, p[i]!, u, drawn);
+    touchCells(p[0]!, p[p.length - 1]!, u, straight);
+  }
+  return straight.size > 0 ? drawn.size / straight.size : 1;
+}
+
+/** The run profile of a result (B8 of MEAS0). */
+export interface RunProfile {
+  /** The number of shared segments: the runs and the trunks of the bundles with two edges or more. */
+  readonly runs: number;
+  /** The median of the edges of each shared segment. It is 0 without a shared segment. */
+  readonly median: number;
+  /** The most edges of one shared segment. It is 0 without a shared segment. */
+  readonly max: number;
+}
+
+/** This function gives the run profile of a result (B8 of MEAS0): the shared segments, and the median and the most edges of each. The cost is linear. */
+export function runProfile(graph: SegmentGraph): RunProfile {
+  const counts = graph.segments.filter((s) => s.count > 1).map((s) => s.count);
+  if (counts.length === 0) return { runs: 0, median: 0, max: 0 };
+  return { runs: counts.length, median: quantile(counts, 0.5), max: Math.max(...counts) };
+}
+
+/** The lane fidelity of a result (B9 of MEAS0). */
+export interface LaneFidelity {
+  /** The median of `lf(e)` over the edges with a shared segment. */
+  readonly median: number;
+  /** The largest `lf(e)`. */
+  readonly max: number;
+  /** The number of edges with a shared segment. */
+  readonly edges: number;
+}
+
+/**
+ * This function gives the lane fidelity (B9 of MEAS0): `lf(e) = frechet(lane(e), r_e) / (width · k / 2)` for each edge `e` with a shared segment.
+ * `lane(e)` is the lane route of `openLanes`, `r_e` is the route, and `k` is the edge count of the widest shared segment of `e`.
+ * `frechet` is the discrete Fréchet distance of the points. A value of 1 or less is correct, and lower is better.
+ * It gives `undefined` when no edge has a shared segment. The cost is quadratic in the points of each route.
+ */
+export function laneFidelity(routes: readonly Route[], open: OpenLanes): LaneFidelity | undefined {
+  const count = new Map(open.graph.segments.map((s) => [s.id, s.count] as const));
+  const lanes = new Map(open.lanes.map((r) => [r.edge, r.points] as const));
+  const own = new Map(routes.map((r) => [r.edge, r.points] as const));
+  const values: number[] = [];
+  for (const path of open.graph.paths) {
+    let k = 0;
+    for (const ref of path.segments) k = Math.max(k, count.get(ref.segment) ?? 0);
+    const lane = lanes.get(path.edge);
+    const route = own.get(path.edge);
+    if (k < 2 || !lane || !route || open.width <= 0) continue;
+    values.push(frechet(lane, route) / ((open.width * k) / 2));
+  }
+  if (values.length === 0) return undefined;
+  return { median: quantile(values, 0.5), max: Math.max(...values), edges: values.length };
+}
+
+/**
+ * This function counts the lane routes that go through a box that is not one of their ends (M4 of MEAS0).
+ * It is the count `laneThrough` of the room bench (`measureBoard`), for the lanes of any result. Lower is better. The cost is `n log n`.
+ */
+export function lanesThrough(graph: Graph, open: OpenLanes): number {
+  return measureRouteFaults(graph, { routes: open.lanes }).through;
+}
+
+/**
+ * This function gives the area of a result (M1 of MEAS0) for a router: the growth of the board that the open lanes need.
+ * The value is the area of the bounding box of the boxes and the lane routes. The function divides it by the area of the bounding box of the boxes.
+ *
+ * It is the room form `area(open) / area(packed)` with the boxes as they are. The scale is a ratio of 1 or more, and lower is better.
+ * A board without area gives 1. The cost is linear.
+ */
+export function laneArea(graph: Graph, open: OpenLanes): number {
+  let x0 = Number.POSITIVE_INFINITY;
+  let y0 = Number.POSITIVE_INFINITY;
+  let x1 = Number.NEGATIVE_INFINITY;
+  let y1 = Number.NEGATIVE_INFINITY;
+  for (const n of graph.nodes) {
+    x0 = Math.min(x0, n.box.x);
+    y0 = Math.min(y0, n.box.y);
+    x1 = Math.max(x1, n.box.x + n.box.w);
+    y1 = Math.max(y1, n.box.y + n.box.h);
+  }
+  const packed = (x1 - x0) * (y1 - y0);
+  if (!(packed > 0)) return 1;
+  for (const r of open.lanes)
+    for (const p of r.points) {
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+  return ((x1 - x0) * (y1 - y0)) / packed;
+}

package/src/bench/measures/levels.ts

@@ -1,5 +1,5 @@
-import { center, dist } from "../../geom.ts";
-import type { Graph, Level } from "../../model.ts";
+import { center, dist, pointBoxDistance, polylineLength, type Box, type Point } from "../../geom.ts";
+import type { Graph, Level, Route } from "../../model.ts";
 import { kendallTau } from "./stats.ts";
 
 /** This function gives the levels in the order of their depth, from the far view to the near view. */
@@ -101,3 +101,87 @@ export function orderStability(graph: Graph, levels: readonly Level[]): number {
   }
   return n ? sum / n : 1;
 }
+
+/** This function gives the points of a polyline at most `step` apart: each vertex, and evenly spaced points on each longer segment. */
+function samplePolyline(p: readonly Point[], step: number): Point[] {
+  const out: Point[] = [];
+  for (let i = 0; i < p.length; i++) {
+    const b = p[i]!;
+    if (i > 0) {
+      const a = p[i - 1]!;
+      const n = Math.ceil(dist(a, b) / step);
+      for (let k = 1; k < n; k++) out.push({ x: a.x + ((b.x - a.x) * k) / n, y: a.y + ((b.y - a.y) * k) / n });
+    }
+    out.push(b);
+  }
+  return out;
+}
+
+/** This function gives the Hausdorff distance between two sets of points. Both sets have one point or more. */
+function hausdorff(a: readonly Point[], b: readonly Point[]): number {
+  const directed = (p: readonly Point[], q: readonly Point[]): number => {
+    let worst = 0;
+    for (const x of p) {
+      let best = Number.POSITIVE_INFINITY;
+      for (const y of q) best = Math.min(best, dist(x, y));
+      worst = Math.max(worst, best);
+    }
+    return worst;
+  };
+  return Math.max(directed(a, b), directed(b, a));
+}
+
+/** The number of points of the sample of one polyline for the link agreement, at most. */
+const AGREEMENT_SAMPLES = 64;
+
+/**
+ * This function gives the link agreement of the levels with groups (Z9 of MEAS0).
+ * `la = mean over links of hausdorff(link, routes of its edges outside the two items) / u`, with `u` the argument `unit`.
+ * The edges of a link are the edges between a node of one item and a node of the other item, in either direction.
+ *
+ * The function samples each polyline at points `u / 4` apart, with at most 64 points for each polyline. It keeps the points outside the boxes of the two items.
+ * A link without such points on both sides does not count. It gives `undefined` when no link counts.
+ * The value has no unit, and lower is better. The cost is quadratic in the points of each link.
+ */
+export function linkAgreement(graph: Graph, levels: readonly Level[], routes: readonly Route[], unit: number): number | undefined {
+  const u = unit > 0 ? unit : 1;
+  const endsOf = new Map(graph.edges.map((e) => [e.id, [e.source.node, e.target.node] as const]));
+  const sample = (p: readonly Point[], boxes: readonly Box[]): Point[] => {
+    const step = Math.max(u / 4, polylineLength(p) / AGREEMENT_SAMPLES);
+    return samplePolyline(p, step).filter((q) => boxes.every((b) => pointBoxDistance(q, b) > 0));
+  };
+  let sum = 0;
+  let n = 0;
+  for (const level of levels) {
+    if (!level.items.some((i) => i.nodes.length > 1)) continue;
+    const itemOf = itemIndex(level);
+    const indexOf = new Map(level.items.map((it, i) => [it.id, i] as const));
+    // The edges between each pair of items, by the key of the pair.
+    const between = new Map<string, Route[]>();
+    for (const r of routes) {
+      const ends = endsOf.get(r.edge);
+      if (!ends) continue;
+      const i = itemOf.get(ends[0]);
+      const j = itemOf.get(ends[1]);
+      if (i === undefined || j === undefined || i === j) continue;
+      const key = i < j ? `${i},${j}` : `${j},${i}`;
+      const list = between.get(key);
+      if (list) list.push(r);
+      else between.set(key, [r]);
+    }
+    for (const link of level.links) {
+      const i = indexOf.get(link.source);
+      const j = indexOf.get(link.target);
+      if (i === undefined || j === undefined || i === j) continue;
+      const mine = between.get(i < j ? `${i},${j}` : `${j},${i}`);
+      if (!mine) continue;
+      const boxes = [level.items[i]!.box, level.items[j]!.box];
+      const a = sample(link.points, boxes);
+      const b = mine.flatMap((r) => sample(r.points, boxes));
+      if (a.length === 0 || b.length === 0) continue;
+      sum += hausdorff(a, b) / u;
+      n++;
+    }
+  }
+  return n > 0 ? sum / n : undefined;
+}

package/src/bench/screen/forms.ts

@@ -47,8 +47,8 @@ export interface LayoutBox {
   readonly parent?: string;
   /** The group of the box. */
   readonly group?: string;
-  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. The router ignores it. */
-  readonly locked?: true;
+  /** This value is `true` when the box is an obstacle: the packer keeps its `x` and `y`. `false` is the same as no value. The router ignores it. */
+  readonly locked?: boolean;
   /** The reading order that the caller wants. The router ignores it. */
   readonly rank?: number;
   readonly ports?: readonly LayoutPort[];
@@ -87,7 +87,7 @@ export interface LayoutGenerator {
  * The packer reads the first six dimensions. The router reads the last four.
  */
 export interface LayoutCell {
-  readonly containerSize?: "fixed" | "freeWidth" | "freeAspect";
+  readonly containerSize?: "fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea";
   readonly containerShape?: "rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes";
   readonly obstacles?: "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
   readonly sizes?: "identical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect" | "nearIdentical";
@@ -291,19 +291,25 @@ export function regionBounds(region: Region): { x: number; y: number; w: number;
   return { x, y, w: Math.max(...xs) - x, h: Math.max(...ys) - y };
 }
 
+/**
+ * The fields of an input that `inputGraph` reads. A contract input, for example the result of `applyPack`, has these fields.
+ * Without `edges`, the input has no edges.
+ */
+export type RouteInput = Pick<LayoutInput, "id" | "boxes" | "obstacles"> & { readonly edges?: LayoutInput["edges"] };
+
 /**
  * This function reads the graph of the router from an input file. The router reads the positions, the ports, the edges and the data.
  * Each obstacle becomes a node without edges, with the bounding box of its region, after the boxes.
  * The router ignores the other fields of the packer: `container`, `gap`, `locked`, `rank`, the `shape` of a box and the `move` of an obstacle.
  * A box without `x` and `y` is an error.
  */
-export function inputGraph(input: LayoutInput): Graph {
+export function inputGraph(input: RouteInput): Graph {
   const nodes = input.boxes.map((b): Node => {
     if (b.x === undefined || b.y === undefined) throw new Error(`The box "${b.id}" of the input "${input.id}" has no position. The router needs a placed input.`);
     return { id: b.id, box: { x: b.x, y: b.y, w: b.w, h: b.h }, ...(b.ports ? { ports: b.ports.map(portToModel) } : {}), ...(b.data ? { data: b.data } : {}) };
   });
   for (const o of input.obstacles ?? []) nodes.push({ id: o.id, box: regionBounds(o.region) });
-  const edges = input.edges.map(
+  const edges = (input.edges ?? []).map(
     (e): Edge => ({
       id: e.id,
       source: { node: e.source, ...(e.sourcePort !== undefined ? { port: e.sourcePort } : {}) },