@mark1russell7/highways 0.4.1 → 0.5.0

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.4.1",
+  "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/highways.ts

@@ -0,0 +1,93 @@
+import { follow } from "../../highways/follow.ts";
+import { commonEdges, matchHighways } from "../../highways/gates/model.ts";
+import type { HighwayPlan } from "../../highways/model.ts";
+import { wayOptionsOf } from "../../highways/router.ts";
+import type { Graph } from "../../model.ts";
+import type { Strategy } from "../../strategies/model.ts";
+import { changeGraph, routeStability } from "./stability.ts";
+
+/**
+ * This function gives the churn of the highways over one edit (Z10 for highways, from HWY-046). Two edges are a pair when they share a highway.
+ * The churn is the share of the pairs that come or go: `|P ∆ P'| / |P ∪ P'|`. Only the edges of `edges` count, for example the edges of both graphs.
+ * Two plans without pairs give 0. The scale is 0 to 1, and lower is better.
+ */
+export function highwayChurn(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): number {
+  const pairs = (plan: HighwayPlan): Set<string> => {
+    const out = new Set<string>();
+    for (const h of plan.highways) {
+      const list = [...new Set(h.members.map((m) => m.edge).filter((e) => edges.has(e)))].sort();
+      for (let i = 0; i < list.length; i++) for (let j = i + 1; j < list.length; j++) out.add(`${list[i]}\u0000${list[j]}`);
+    }
+    return out;
+  };
+  const a = pairs(before);
+  const b = pairs(after);
+  let common = 0;
+  for (const p of a) if (b.has(p)) common++;
+  const all = a.size + b.size - common;
+  return all === 0 ? 0 : (all - common) / all;
+}
+
+/** The match of the highways over one edit. */
+export interface HighwayIdKeep {
+  /** The number of new highways with a match in the old plan: a Jaccard index of their edges of 0.5 or more. */
+  readonly matched: number;
+  /** The number of matched highways that keep the id of their match. */
+  readonly kept: number;
+  /** `kept / matched`, or `NaN` without a match. The scale is 0 to 1, and higher is better. */
+  readonly share: number;
+}
+
+/**
+ * This function tells how many highways keep their id over one edit (HWY-054). It matches the new highways with the old ones by `matchHighways`, with the index 0.5.
+ * A matched highway keeps its id when its id is the id of its match. Only the edges of `edges` count.
+ */
+export function highwayIdKeep(before: HighwayPlan, after: HighwayPlan, edges: ReadonlySet<string>): HighwayIdKeep {
+  const match = matchHighways(before, after, 0.5, edges);
+  let kept = 0;
+  for (const [i, i0] of match) if (after.highways[i]!.id === before.highways[i0]!.id) kept++;
+  return { matched: match.size, kept, share: match.size === 0 ? Number.NaN : kept / match.size };
+}
+
+/** The stability of a highway strategy over a seeded sequence of edits. Each value is the mean over the edits. */
+export interface HighwayEdits {
+  /** The mean Fréchet distance of the routes over one edit, in units of the board (Z10). */
+  readonly mean: number;
+  /** The share of the routes that move over one edit (Z10). */
+  readonly moved: number;
+  /** The churn of the highways over one edit (`highwayChurn`). */
+  readonly churn: number;
+  /** The share of the matched highways that keep their id over one edit (`highwayIdKeep`), or `NaN` without a match. */
+  readonly ids: number;
+}
+
+/**
+ * This function measures a highway strategy over a sequence of `edits` seeded edits. Each edit is the small change of `changeGraph` with the seed `seed + i`.
+ * The strategy gets the graph and its plan before the edit as `previous`, so a strategy with memory can keep its highways.
+ * `follow` routes each plan with the way options of the strategy. The same graph, strategy, options and seed give the same values.
+ */
+export function highwayEdits(graph: Graph, strategy: Strategy<"highway", object>, options: object | undefined, edits: number, seed = 1): HighwayEdits {
+  const way = wayOptionsOf({ ...strategy.defaults, ...options });
+  let g = graph;
+  let plan = strategy.run({ graph: g }, options);
+  let routes = follow(g, plan, way);
+  const mean: number[] = [];
+  const moved: number[] = [];
+  const churn: number[] = [];
+  const ids: number[] = [];
+  for (let i = 0; i < edits; i++) {
+    const next = changeGraph(g, seed + i).graph;
+    const p = strategy.run({ graph: next, previous: { graph: g, plan } }, options);
+    const r = follow(next, p, way);
+    const s = routeStability(g, routes, r, { seed });
+    const edges = commonEdges(g, next);
+    mean.push(s.mean);
+    moved.push(s.moved);
+    churn.push(highwayChurn(plan, p, edges));
+    const keep = highwayIdKeep(plan, p, edges);
+    if (keep.matched > 0) ids.push(keep.share);
+    [g, plan, routes] = [next, p, r];
+  }
+  const avg = (v: readonly number[]): number => (v.length === 0 ? Number.NaN : v.reduce((a, b) => a + b, 0) / v.length);
+  return { mean: avg(mean), moved: avg(moved), churn: avg(churn), ids: avg(ids) };
+}

package/src/bench/measures/index.ts

@@ -8,3 +8,5 @@ export * from "./stability.ts";
 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;
+}