@mark1russell7/highways 0.4.2 → 0.5.1

package/src/bench/screen/screen.ts

@@ -7,8 +7,11 @@ import { asRouter, createRegistry, getStrategy, listStrategies, register, STEPS,
 import { compareStep, type CompareRow, type CompareStep, type StepComparison } from "../compare.ts";
 import { bundledShare, bundleStretch, mergeAngle } from "../measures/bundles.ts";
 import { highwayEdits } from "../measures/highways.ts";
+import { laneArea, laneCrossings, laneFidelity, lanesThrough, occupiedArea, openLanes, orthogonality, routeSeparation, runProfile } from "../measures/lanes.ts";
+import { linkAgreement } from "../measures/levels.ts";
 import { orderFragility } from "../measures/order.ts";
 import { paretoFront, type Objective } from "../measures/pareto.ts";
+import { boardUnit } from "../measures/routes.ts";
 import { routeStability } from "../measures/stability.ts";
 import { quantile } from "../measures/stats.ts";
 import { checkLevels, checkProperties, TOLERANCE } from "../properties.ts";
@@ -16,6 +19,10 @@ import { measureQuality } from "../quality.ts";
 import { sameData } from "../run.ts";
 import { FRONT_OBJECTIVES } from "../suite.ts";
 import { inputGraph, jsonSafe, type LayoutInput, type LayoutPrediction, type LayoutRecord, type PredictionOp } from "./forms.ts";
+import { curvesHash, resultHash, type MoveCounter } from "./exercise.ts";
+import { outputHash } from "./activation.ts";
+import { RECORD_EPS } from "./hash.ts";
+import { formatGap, gapBaselines, gapValues, optimumKey, summarizeGap, type ExactOptimum, type GapRule, type GapSummary } from "./gap.ts";
 import { measureByName, measureName, namedObjectives } from "./measures.ts";
 import { SCREEN_V1, screenInputs, type ScreenSet } from "./set.ts";
 
@@ -95,6 +102,16 @@ export interface ScreenOptions {
   readonly commit?: string;
   /** The predictions of the run. Each record names the first prediction with its strategy, its set and its input. */
   readonly predictions?: readonly LayoutPrediction[];
+  /**
+   * The exact optima of the inputs, from the file of the optima of a set (MEAS2). The steps `router` and `highway` read them.
+   * Each run on an input with optima gets the largest B3 and the gap closed of each rule (B10). The summary then gets the gap table.
+   */
+  readonly optima?: readonly ExactOptimum[];
+  /**
+   * This function gives the own move counts of a strategy on an input (ACTIVATION), for example `{ "move.powerEdge": 3 }`.
+   * Each record of a strategy with counts gets them as the trace measures of its step. The default is no counts.
+   */
+  readonly moves?: MoveCounter;
   /** This function gets one line of progress for each input. */
   readonly log?: (line: string) => void;
 }
@@ -151,6 +168,8 @@ export interface ScreenSummary {
   /** The strategies with a break over the floor, without a run or with two different outputs of one input. They do not enter the front. */
   readonly excluded: readonly string[];
   readonly predictions: readonly PredictionCheck[];
+  /** The gap closed of each strategy and rule, when the screen has optima. */
+  readonly gap?: readonly GapSummary[];
 }
 
 /** The result of `screen`: one record for each strategy and input, and the summary. */
@@ -208,6 +227,8 @@ const givesRoutes = (step: ScreenStep): step is "router" | "highway" => step ===
 /**
  * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
  * A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
+ * It also gets the measures of MEAS3A: R12, R14, B5, B7, B8, B9, M1 and M4. The lane measures open each shared segment at `MEASURE_LANE_WIDTH`.
+ * A result with zoom levels also gets the link agreement (Z9), for a router and for a grouping rule.
  */
 function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () => readonly Route[]): Record<string, number> {
   const values: Record<string, number> = { ...row.values };
@@ -224,6 +245,27 @@ function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () =>
     values["B3.median"] = st.median;
     values["B3.q95"] = st.q95;
     values["B6.max"] = mergeAngle(row.result.routes);
+    const routes = row.result.routes;
+    const open = openLanes(row.result);
+    values["R12.share"] = routeSeparation(routes);
+    values["R14.share"] = orthogonality(routes);
+    values["B5.crossings"] = laneCrossings(open.graph);
+    values["B7.ratio"] = occupiedArea(routes, boardUnit(graph));
+    const runs = runProfile(open.graph);
+    values["B8.runs"] = runs.runs;
+    values["B8.median"] = runs.median;
+    values["B8.max"] = runs.max;
+    const lf = laneFidelity(routes, open);
+    if (lf) {
+      values["B9.median"] = lf.median;
+      values["B9.max"] = lf.max;
+    }
+    values["M1.area"] = laneArea(graph, open);
+    values["M4.laneThrough"] = lanesThrough(graph, open);
+  }
+  if ((givesRoutes(step) || step === "group") && row.result?.levels) {
+    const la = linkAgreement(graph, row.result.levels, row.result.routes, boardUnit(graph));
+    if (la !== undefined) values["Z9.mean"] = la;
   }
   return values;
 }
@@ -246,6 +288,27 @@ function rowRules(step: ScreenStep, graph: Graph, row: CompareRow, again: Compar
   return { hard: { ...countRules(rules, []), "same-twice": deterministic ? 0 : 1 }, deterministic };
 }
 
+/**
+ * This function gives the output hash of a row of `compareStep` (ACTIVATION), or `undefined` for a row without output.
+ * A router hashes its result with `resultHash`. The step `group` hashes its tree and its result, and the step `curve` hashes its curves.
+ */
+function rowHash(row: CompareRow): string | undefined {
+  try {
+    return rowHashOf(row);
+  } catch (e) {
+    // An output with NaN or an infinite number has no hash. The record then has no `outputHash`, and the script `screen` names it.
+    if (!(e instanceof RangeError)) throw e;
+    return undefined;
+  }
+}
+
+/** This function gives the output hash of a row. It throws a `RangeError` for an output with a number that is not finite. */
+function rowHashOf(row: CompareRow): string | undefined {
+  if (row.step === "curve") return row.curves && row.edges ? curvesHash(row.edges, row.curves) : undefined;
+  if (row.step === "group") return row.result || row.tree ? outputHash({ tree: row.tree, result: row.result }, { grid: RECORD_EPS }) : undefined;
+  return row.result ? resultHash(row.result) : undefined;
+}
+
 /** This function adds the router `<name>+<w>` for each router of the registry and each wrapper `w`. It gives the new registry and the new names. */
 function wrapRouters(registry: Registry, wraps: readonly ScreenWrap[]): { registry: Registry; added: string[] } {
   const routers = listStrategies(registry, "router");
@@ -313,6 +376,8 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
   const comparisons: StepComparison[] = [];
   const kept = new Map<string, { graph: Graph; results: Map<string, Result> }>();
   const variants: { record: (typeof records)[number]; base: string; result: Result }[] = [];
+  const optima = givesRoutes(step) && options.optima ? new Map(options.optima.map((o) => [optimumKey(o.input, o.rule, o.cap), o])) : undefined;
+  const withOptima = new Set(options.optima?.map((o) => o.input));
 
   for (const input of inputs) {
     const graph = inputGraph(input);
@@ -326,6 +391,9 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
     let cornersRoutes: readonly Route[] | undefined;
     const cornersBase = (): readonly Route[] =>
       (cornersRoutes ??= (cmp.rows.find((r) => r.strategy === "corners" && r.result)?.result ?? asRouter(getStrategy(STRATEGIES, "router", "corners")).route(graph)).routes);
+    // The B1 of the baseline of each rule of the gap closed, for an input with optima.
+    let baselines: Record<GapRule, number> | undefined;
+    const gapBase = (): Record<GapRule, number> => (baselines ??= gapBaselines(graph));
     cmp.rows.forEach((row, i) => {
       const strategy = byName.get(row.strategy)!;
       const head = {
@@ -350,6 +418,9 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
       }
       const { hard, deterministic } = rowRules(step, graph, row, again?.rows[i]);
       const values = rowValues(step, graph, row, cornersBase);
+      // Z2 is the count of the hard rule `link-ends`, as a measure. The steps `router`, `highway` and `group` check the rule.
+      if (hard["link-ends"] !== undefined) values["Z2.linkEnds"] = hard["link-ends"];
+      if (optima && withOptima.has(input.id) && row.result) Object.assign(values, gapValues(input, graph, row.result, cornersBase(), gapBase(), optima));
       if (shuffles > 0 && row.result) {
         const router = asRouter(strategy as Strategy<"router">, own[row.strategy]);
         const f = orderFragility(graph, (g) => router.route(g), { orders: shuffles, seed, base: row.result });
@@ -360,7 +431,10 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
         const z = highwayEdits(graph, plan, own[row.strategy], edits, seed);
         Object.assign(values, { "Z10.edits.mean": z.mean, "Z10.edits.moved": z.moved, "Z10.churn": z.churn, "Z10.ids": z.ids });
       }
-      const record = { ...head, measures: named(values), hard, tolerance: { through: TOLERANCE }, deterministic, ms: row.ms, ...tail };
+      const output = rowHash(row);
+      const counts = row.result ? options.moves?.(row.strategy, graph) : undefined;
+      const facts = { ...(output === undefined ? {} : { outputHash: output }), ...(counts === undefined ? {} : { trace: [{ id: head.step, measures: { ...counts } }] }) };
+      const record = { ...head, measures: named(values), hard, tolerance: { through: TOLERANCE }, deterministic, ms: row.ms, ...tail, ...facts };
       records.push(record);
       if (givesRoutes(step) && input.base !== undefined && row.result) variants.push({ record, base: input.base, result: row.result });
     });
@@ -375,7 +449,8 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
     Object.assign(v.record.measures, named({ "Z10.base.mean": s.mean, "Z10.base.max": s.max, "Z10.base.moved": s.moved }));
   }
 
-  return { records, summary: summarizeScreen(records, comparisons, { set: set.id, step, candidates, ...(options.predictions ? { predictions: options.predictions } : {}) }) };
+  const summary = summarizeScreen(records, comparisons, { set: set.id, step, candidates, ...(options.predictions ? { predictions: options.predictions } : {}) });
+  return { records, summary: optima ? { ...summary, gap: summarizeGap(records) } : summary };
 }
 
 /** This function gives the summary of the records of a screen. */
@@ -464,5 +539,6 @@ export function formatScreen(summary: ScreenSummary): string {
     for (const p of summary.predictions)
       lines.push(`| ${p.id} | ${p.strategy} | ${p.input ?? "median"} | ${p.measure} | ${p.op} ${fmt(p.expected)} | ${fmt(p.measured)} | ${p.met === undefined ? "-" : p.met ? "yes" : "no"} | ${p.reason} |`);
   }
+  if (summary.gap) lines.push(formatGap(summary.gap).trimEnd());
   return lines.join("\n") + "\n";
 }

package/src/bench/screen/set.ts

@@ -2,6 +2,7 @@ import { hubChainBoard, manyGroupsBoard, packedGridBoard } from "../../cases.ts"
 import { FIXTURES, makeFixture, type FixtureSpec } from "../../fixtures.ts";
 import type { Graph } from "../../model.ts";
 import { familySeed } from "../suite.ts";
+import { EXACT_V1, EXACT_V1_BOUNDS } from "./exact-set.ts";
 import { graphInput, type LayoutCell, type LayoutGenerator, type LayoutInput } from "./forms.ts";
 
 /** A family of boards of a screen set. The member `k` of the family has the seed `k`. */
@@ -85,8 +86,8 @@ export const SCREEN_V1: ScreenSet = {
   ],
 };
 
-/** The screen sets by id. */
-export const SCREEN_SETS: Readonly<Record<string, ScreenSet>> = { [SCREEN_V1.id]: SCREEN_V1 };
+/** The screen sets by id: `screen-v1`, the small boards with a known optimum `exact-v1` (MEAS2), and the larger boards with bounds `exact-v1-bounds` (EXACT-BOUNDS). */
+export const SCREEN_SETS: Readonly<Record<string, ScreenSet>> = { [SCREEN_V1.id]: SCREEN_V1, [EXACT_V1.id]: EXACT_V1, [EXACT_V1_BOUNDS.id]: EXACT_V1_BOUNDS };
 
 /** This function gives the id of the member `seed` of a family of a set: `<set>/<family>/s<seed>`. */
 export function inputId(set: string, family: string, seed: number): string {

package/src/channels.ts

@@ -0,0 +1,56 @@
+import { dist, type Box, type Point } from "./geom.ts";
+import type { Obstacles } from "./visibility.ts";
+
+/** The largest distance that `channelWidth` looks on each side of a link. A wider channel counts as this width on that side. */
+export const CHANNEL_REACH = 64;
+
+/**
+ * This function gives the distance from `p` along the unit direction `d` to the box, or `Infinity` when the ray does not meet the box.
+ * A point inside the box gives 0. The function uses the slab test.
+ */
+export function rayToBox(p: Point, d: Point, box: Box): number {
+  let lo = 0;
+  let hi = Infinity;
+  for (const [o, v, min, max] of [
+    [p.x, d.x, box.x, box.x + box.w],
+    [p.y, d.y, box.y, box.y + box.h],
+  ] as const) {
+    if (Math.abs(v) < 1e-12) {
+      if (o < min || o > max) return Infinity;
+      continue;
+    }
+    const t1 = (min - o) / v;
+    const t2 = (max - o) / v;
+    lo = Math.max(lo, Math.min(t1, t2));
+    hi = Math.min(hi, Math.max(t1, t2));
+    if (lo > hi) return Infinity;
+  }
+  return lo;
+}
+
+/** This function gives the free distance from `p` along the unit direction `d` to the nearest box, up to `reach`. */
+function freeRay(obstacles: Obstacles, p: Point, d: Point, reach: number): number {
+  const q = { x: p.x + d.x * reach, y: p.y + d.y * reach };
+  let best = reach;
+  obstacles.query({ x: Math.min(p.x, q.x), y: Math.min(p.y, q.y), w: Math.abs(q.x - p.x), h: Math.abs(q.y - p.y) }, (n) => {
+    best = Math.min(best, rayToBox(p, d, n.box));
+  });
+  return best;
+}
+
+/**
+ * This function gives the width of the channel of the link from `a` to `b`. The width is the free space between the nearest boxes on the two sides.
+ * It measures the width at five points of the link, and gives the smallest. Each side counts up to `reach`.
+ * A link of length 0 gives the free space across the x axis at its point.
+ */
+export function channelWidth(obstacles: Obstacles, a: Point, b: Point, reach: number = CHANNEL_REACH): number {
+  const len = dist(a, b);
+  const n = len > 1e-9 ? { x: -(b.y - a.y) / len, y: (b.x - a.x) / len } : { x: 0, y: 1 };
+  const back = { x: -n.x, y: -n.y };
+  let width = Infinity;
+  for (const u of [0.1, 0.3, 0.5, 0.7, 0.9]) {
+    const p = { x: a.x + (b.x - a.x) * u, y: a.y + (b.y - a.y) * u };
+    width = Math.min(width, freeRay(obstacles, p, n, reach) + freeRay(obstacles, p, back, reach));
+  }
+  return width;
+}

package/src/highways/areas/index.ts

@@ -0,0 +1,160 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import type { DensitySource } from "../kdeeb/index.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { bigGroups, firstLines, nearestOnLine, shapeSkeleton, skeletonGroups, type ShapeSkeleton, type SkeletonGroups } from "../sbeb/index.ts";
+import { snapPlan, type SnapLine, type SnapMember } from "../snap.ts";
+
+/** The rule of the half width of an area: the spread of the edges of the group, or the number of its lanes. */
+export type AreaWidth = "spread" | "count";
+
+/** The values of `AreaWidth`. */
+export const AREA_WIDTHS: readonly AreaWidth[] = Object.freeze(["spread", "count"]);
+
+/** The options of the highway strategy `areas` (HWY-010 of the notes). */
+export interface AreaOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The lines of the edges that make the shape: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The rule of the half width of the area. The default is `spread`. */
+  readonly width: AreaWidth;
+  /** The width of one lane for the rule `count`, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** The side of a cell of the image of the shape, in units of the board. The default is 4. */
+  readonly cell: number;
+  /** A highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `areas`. */
+export const AREA_DEFAULTS: Readonly<Required<Omit<AreaOptions, "margin" | "k">>> = Object.freeze({
+  group: "quickbundles",
+  source: "lines",
+  radius: 1.5,
+  width: "spread",
+  laneWidth: 4,
+  cell: 4,
+  minSize: 2,
+});
+
+/**
+ * This function gives the longest path of the largest part of a skeleton, as the middles of its cells. The neighbours of a cell are its 8 neighbours.
+ * The function finds the cell farthest from a first cell, then the cell farthest from that cell. A skeleton without cells gives an empty list.
+ */
+export function skeletonPath(s: ShapeSkeleton): Point[] {
+  const { grid: g, skeleton } = s;
+  const n = g.w * g.h;
+  const part = new Int32Array(n).fill(-1);
+  const sizes: number[] = [];
+  const neighbours = (i: number): number[] => {
+    const x = i % g.w;
+    const y = (i - x) / g.w;
+    const out: number[] = [];
+    for (let dy = -1; dy <= 1; dy++)
+      for (let dx = -1; dx <= 1; dx++) {
+        if (dx === 0 && dy === 0) continue;
+        const u = x + dx;
+        const v = y + dy;
+        if (u >= 0 && v >= 0 && u < g.w && v < g.h && skeleton[v * g.w + u]) out.push(v * g.w + u);
+      }
+    return out;
+  };
+  for (let i = 0; i < n; i++) {
+    if (!skeleton[i] || part[i]! >= 0) continue;
+    const id = sizes.length;
+    let size = 0;
+    const stack = [i];
+    part[i] = id;
+    while (stack.length > 0) {
+      const c = stack.pop()!;
+      size++;
+      for (const j of neighbours(c))
+        if (part[j]! < 0) {
+          part[j] = id;
+          stack.push(j);
+        }
+    }
+    sizes.push(size);
+  }
+  if (sizes.length === 0) return [];
+  const big = sizes.indexOf(Math.max(...sizes));
+  const bfs = (from: number): { far: number; prev: Int32Array } => {
+    const prev = new Int32Array(n).fill(-2);
+    prev[from] = -1;
+    const queue = [from];
+    let far = from;
+    for (let q = 0; q < queue.length; q++) {
+      const c = queue[q]!;
+      far = c;
+      for (const j of neighbours(c))
+        if (prev[j] === -2) {
+          prev[j] = c;
+          queue.push(j);
+        }
+    }
+    return { far, prev };
+  };
+  let first = -1;
+  for (let i = 0; i < n && first < 0; i++) if (part[i] === big) first = i;
+  const a = bfs(first).far;
+  const { far: b, prev } = bfs(a);
+  const path: Point[] = [];
+  for (let c = b; c >= 0; c = prev[c]!) {
+    const x = c % g.w;
+    const y = (c - x) / g.w;
+    path.push({ x: g.x0 + (x + 0.5) * g.cell, y: g.y0 + (y + 0.5) * g.cell });
+  }
+  return path;
+}
+
+/** This function gives the value at the share `q` of the sorted list, with a linear mix between two values. An empty list gives 0. */
+function quantileOf(values: readonly number[], q: number): number {
+  if (values.length === 0) return 0;
+  const s = [...values].sort((a, b) => a - b);
+  const at = Math.max(0, Math.min(s.length - 1, q * (s.length - 1)));
+  const i = Math.floor(at);
+  const u = at - i;
+  return i + 1 < s.length ? s[i]! * (1 - u) + s[i + 1]! * u : s[i]!;
+}
+
+/**
+ * This function gives the highways of the image-based edge bundles (HWY-010, Telea and Ersoy 2010). Each group of edges is one area with one spine.
+ * The spine goes through the corner graph between the two ends of the longest path of the skeleton of the shape of the group.
+ * The area is the skeleton path with a half width. With `spread`, the half width is the 90th percentile of the distances of the points to the path.
+ * With `count`, it is the number of lanes times half of `laneWidth`. The half width is at least the margin.
+ * An edge joins the spine where its line first goes into the area. It leaves the spine where its line last comes out of the area.
+ */
+export function areaPlan(input: HighwayInput, o: Readonly<AreaOptions>): HighwayPlan {
+  const way: WayOptions = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  const finder = new WayFinder(input.graph.nodes, way);
+  const radius = Math.max(1e-3, o.radius * boardUnit(input.graph));
+  const lines = firstLines(input, finder, o.source, Math.max(4, 2 * o.cell));
+  const snapLines: SnapLine[] = [];
+  for (const g of bigGroups(skeletonGroups(input, o.group), o.minSize)) {
+    const own = g.edges.filter((m) => lines.has(m.edge));
+    if (own.length < Math.max(2, o.minSize)) continue;
+    const path = skeletonPath(shapeSkeleton(own.map((m) => lines.get(m.edge)!), finder, radius, o.cell));
+    if (path.length < 2 || dist(path[0]!, path[path.length - 1]!) <= finder.margin) continue;
+    const spread = own.flatMap((m) => lines.get(m.edge)!.map((p) => dist(p, nearestOnLine(path, p))));
+    const half = Math.max(finder.margin, o.width === "count" ? (own.length * o.laneWidth) / 2 : quantileOf(spread, 0.9));
+    const members: SnapMember[] = [];
+    for (const m of own) {
+      const l = lines.get(m.edge)!;
+      let first = -1;
+      let last = -1;
+      l.forEach((p, i) => {
+        if (dist(p, nearestOnLine(path, p)) > half) return;
+        if (first < 0) first = i;
+        last = i;
+      });
+      if (first < 0 || last <= first) continue;
+      members.push({ edge: m.edge, from: l[first]!, to: l[last]!, at: first / Math.max(1, l.length - 1) });
+    }
+    snapLines.push({ key: g.key, a: path[0]!, b: path[path.length - 1]!, members });
+  }
+  return snapPlan(input, snapLines, { ...way, minSize: o.minSize });
+}

package/src/highways/confluent/index.ts

@@ -0,0 +1,154 @@
+import type { Graph } from "../../model.ts";
+import { byCollection } from "../../routers/trunks.ts";
+import type { WayOptions } from "../../ways.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The edges that one group can hold: the edges of one collection, or each edge. */
+export type GroupScope = "collection" | "all";
+
+/** The values of `GroupScope`. */
+export const GROUP_SCOPES: readonly GroupScope[] = Object.freeze(["collection", "all"]);
+
+/** The options of the highway strategy `confluent` (HWY-013 of the notes). */
+export interface ConfluentOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** A biclique `K(A, B)` becomes a track when `|A| |B|` is this value or more. The default is 4. */
+  readonly minBiclique: number;
+  /** The edges of one track. With `collection`, a track holds the edges of one collection, and an edge without a collection is on no track. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each track. The default is `trunk`: one trunk from the merge junction to the split junction. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+
+/** The default options of the strategy `confluent`. */
+export const CONFLUENT_DEFAULTS: Readonly<Required<Omit<ConfluentOptions, "margin" | "k">>> = Object.freeze({
+  minBiclique: 4,
+  scope: "all",
+  spine: "trunk",
+  legMax: 1,
+});
+
+/** The edges between pairs of nodes of one scope: for each node, its neighbours and the edges to each of them. */
+export interface NodeLinks {
+  /** The key of the scope. */
+  readonly key: string;
+  /** For each node, the edges to each neighbour, by the id of the neighbour. */
+  readonly links: Map<string, Map<string, string[]>>;
+}
+
+/** This function gives the links of each scope. A loop (an edge from a node to itself) is not a link. The order of the maps follows the order of the edges. */
+export function nodeLinks(graph: Graph, scope: GroupScope): NodeLinks[] {
+  const byKey = new Map<string, Map<string, Map<string, string[]>>>();
+  const nodes = new Set(graph.nodes.map((n) => n.id));
+  for (const e of graph.edges) {
+    const s = e.source.node;
+    const t = e.target.node;
+    if (s === t || !nodes.has(s) || !nodes.has(t)) continue;
+    const key = scope === "all" ? "" : byCollection(e);
+    if (key === undefined) continue;
+    let links = byKey.get(key);
+    if (!links) byKey.set(key, (links = new Map()));
+    for (const [u, v] of [
+      [s, t],
+      [t, s],
+    ] as const) {
+      let m = links.get(u);
+      if (!m) links.set(u, (m = new Map()));
+      const list = m.get(v);
+      if (list) list.push(e.id);
+      else m.set(v, [e.id]);
+    }
+  }
+  return [...byKey].map(([key, links]) => ({ key, links }));
+}
+
+/** A biclique: the two sets of nodes, with a link from each node of `a` to each node of `b`. */
+export interface Biclique {
+  readonly a: readonly string[];
+  readonly b: readonly string[];
+}
+
+/**
+ * This function gives the bicliques of a greedy search (HWY-013). Each search starts at one node `x` with `A = {x}` and `B` its neighbours.
+ * It then adds to `A` the node that gives the largest `|A| |B|`, with `B` cut to the common neighbours, while the product grows.
+ * The best biclique of all starts with `|A| |B| >= min` becomes a track, its links go away, and the search repeats.
+ * The nodes of `A` and `B` are apart. The largest set is `b`.
+ */
+export function greedyBicliques(links: Map<string, Map<string, string[]>>, min: number): Biclique[] {
+  const live = new Map<string, Set<string>>();
+  for (const [u, m] of links) live.set(u, new Set(m.keys()));
+  const out: Biclique[] = [];
+  const order = [...live.keys()].sort();
+  for (;;) {
+    let best: { a: string[]; b: Set<string>; size: number } | undefined;
+    for (const x of order) {
+      const nx = live.get(x)!;
+      if (nx.size === 0) continue;
+      const a = [x];
+      let b = new Set(nx);
+      for (;;) {
+        // The candidates: the other neighbours of the nodes of B, outside A and B.
+        let pick: { y: string; b: Set<string> } | undefined;
+        let pickSize = a.length * b.size;
+        const seen = new Set<string>();
+        for (const v of [...b].sort())
+          for (const y of [...live.get(v)!].sort()) {
+            if (seen.has(y) || a.includes(y) || b.has(y)) continue;
+            seen.add(y);
+            const ny = live.get(y)!;
+            const common = new Set([...b].filter((z) => ny.has(z)));
+            const size = (a.length + 1) * common.size;
+            if (size > pickSize) [pick, pickSize] = [{ y, b: common }, size];
+          }
+        if (!pick) break;
+        a.push(pick.y);
+        b = pick.b;
+      }
+      const size = a.length * b.size;
+      if (size >= min && (!best || size > best.size)) best = { a: [...a], b, size };
+    }
+    if (!best) break;
+    const a = [...best.a].sort();
+    const b = [...best.b].sort();
+    out.push(a.length > b.length ? { a: b, b: a } : { a, b });
+    for (const u of a)
+      for (const v of b) {
+        live.get(u)!.delete(v);
+        live.get(v)!.delete(u);
+      }
+  }
+  return out;
+}
+
+/**
+ * This function gives the group of each edge of a set of bicliques. The edges of one biclique are one group, with the key `<prefix><scope>/<index>`.
+ * An edge from a node of `b` to a node of `a` has `flip`. Thus each trunk goes from the side `a` to the side `b`.
+ */
+export function bicliqueGroups(graph: Graph, scope: NodeLinks, bicliques: readonly Biclique[], prefix: string, into: Map<string, EdgeGroup>): void {
+  const sourceOf = new Map(graph.edges.map((e) => [e.id, e.source.node] as const));
+  bicliques.forEach((bc, i) => {
+    const key = `${prefix}${scope.key}/${i}`;
+    const inA = new Set(bc.a);
+    for (const u of bc.a)
+      for (const v of bc.b) for (const edge of scope.links.get(u)?.get(v) ?? []) if (!into.has(edge)) into.set(edge, { key, flip: !inA.has(sourceOf.get(edge)!) });
+  });
+}
+
+/**
+ * This function gives the highways of the confluent drawing (HWY-013, Dickerson, Eppstein, Goodrich and Meng 2005).
+ * Each biclique `K(A, B)` of the greedy search is one track. The track merges the edges near the side `A` and splits them near the side `B`.
+ * The junctions are the Weber points of the ends, as in the spine `trunk` of `groupedPlan`.
+ */
+export function confluentPlan(input: HighwayInput, o: Readonly<ConfluentOptions>): HighwayPlan {
+  const groups = new Map<string, EdgeGroup>();
+  for (const scope of nodeLinks(input.graph, o.scope)) bicliqueGroups(input.graph, scope, greedyBicliques(scope.links, Math.max(2, o.minBiclique)), "c", groups);
+  return groupedPlan(input, groups, {
+    ...(o.margin === undefined ? {} : { margin: o.margin }),
+    ...(o.k === undefined ? {} : { k: o.k }),
+    spine: o.spine,
+    minSize: 2,
+    legMax: o.legMax,
+  });
+}

package/src/highways/confluent/k23.test-util.ts

@@ -0,0 +1,8 @@
+import type { Graph } from "../../model.ts";
+import { box } from "../fixtures.test-util.ts";
+
+/** A complete biclique K(2, 3): two nodes on the left, three on the right, and an edge from each left node to each right node. */
+export const k23: Graph = {
+  nodes: [...[0, 1].map((i) => ({ id: `a${i}`, box: box(0, 200 * i) })), ...[0, 1, 2].map((i) => ({ id: `b${i}`, box: box(700, 150 * i) }))],
+  edges: [0, 1].flatMap((i) => [0, 1, 2].map((j) => ({ id: `e${i}${j}`, source: { node: `a${i}` }, target: { node: `b${j}` } }))),
+};