@mark1russell7/highways 0.5.0 → 0.6.0

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}` } }))),
+};

package/src/highways/consensus/index.ts

@@ -0,0 +1,129 @@
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { candidatePlan, type CandidateSource } from "../select/index.ts";
+import { edgeEnds, labelGroups } from "../spectral/index.ts";
+
+/** The linkage of the clusters of the vote matrix: `average` (the mean distance of the pairs) or `single` (the nearest pair). */
+export type ConsensusLinkage = "average" | "single";
+
+/** The values of `ConsensusLinkage`. */
+export const CONSENSUS_LINKAGES: readonly ConsensusLinkage[] = Object.freeze(["average", "single"]);
+
+/** The options of the highway strategy `consensus` (HWY-035 of the note on highways). */
+export interface ConsensusOptions {
+  /** The finders that vote. The default is `corridors`, `quickbundles`, `wspd` and `road-classes`. */
+  readonly members: readonly CandidateSource[];
+  /** Two clusters join while their distance `1 - A` is below this value. The default is 0.5: more than half of the votes. */
+  readonly cut: number;
+  /** The linkage of the clusters. The default is `average`. */
+  readonly linkage: ConsensusLinkage;
+  /** A cluster with this number of edges or more gets highways. The default is 2. */
+  readonly minSize: number;
+  /** The spine of each cluster. The default is `shared`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `consensus`. */
+export const CONSENSUS_DEFAULTS: Readonly<ConsensusOptions> = Object.freeze({
+  members: Object.freeze(["corridors", "quickbundles", "wspd", "road-classes"] as CandidateSource[]),
+  cut: 0.5,
+  linkage: "average",
+  minSize: 2,
+  spine: "shared",
+});
+
+/**
+ * This function gives the co-association matrix of the plans (Fred and Jain 2005). `A[e][f]` is the share of the plans with a highway that holds both `e` and `f`.
+ * The edges are in the order of `edges`. An edge of no plan has no pair.
+ */
+export function coAssociation(edges: readonly string[], plans: readonly HighwayPlan[]): Float64Array {
+  const n = edges.length;
+  const index = new Map(edges.map((e, i) => [e, i] as const));
+  const a = new Float64Array(n * n);
+  if (plans.length === 0) return a;
+  const share = 1 / plans.length;
+  for (const plan of plans) {
+    const pairs = new Set<number>();
+    for (const h of plan.highways) {
+      const list = [...new Set(h.members.map((m) => index.get(m.edge)).filter((i): i is number => i !== undefined))].sort((x, y) => x - y);
+      for (let x = 0; x < list.length; x++) for (let y = x + 1; y < list.length; y++) pairs.add(list[x]! * n + list[y]!);
+    }
+    for (const p of pairs) {
+      const i = Math.floor(p / n);
+      const j = p % n;
+      a[i * n + j] = a[i * n + j]! + share;
+      a[j * n + i] = a[j * n + i]! + share;
+    }
+  }
+  return a;
+}
+
+/**
+ * This function gives the clusters of the agglomerative linkage on the distance `1 - A`. Two clusters join while their distance is below `cut`.
+ * The linkage `average` uses the mean of the distances of the pairs, and `single` the smallest distance.
+ * The result is the cluster of each edge, and -1 for an edge that stays alone.
+ */
+export function consensusLabels(n: number, a: Float64Array, cut: number, linkage: ConsensusLinkage): Int32Array {
+  const d = new Float64Array(n * n);
+  for (let i = 0; i < n * n; i++) d[i] = 1 - a[i]!;
+  const size = new Int32Array(n).fill(1);
+  const alive = new Uint8Array(n).fill(1);
+  const owner = new Int32Array(n);
+  for (let i = 0; i < n; i++) owner[i] = i;
+  for (;;) {
+    let bi = -1;
+    let bj = -1;
+    let best = cut;
+    for (let i = 0; i < n; i++) {
+      if (!alive[i]) continue;
+      for (let j = i + 1; j < n; j++) {
+        if (!alive[j]) continue;
+        const v = d[i * n + j]!;
+        if (v < best - 1e-12) [best, bi, bj] = [v, i, j];
+      }
+    }
+    if (bi < 0) break;
+    // The cluster `bj` joins the cluster `bi` (the formula of Lance and Williams).
+    for (let k = 0; k < n; k++) {
+      if (!alive[k] || k === bi || k === bj) continue;
+      const v =
+        linkage === "single"
+          ? Math.min(d[bi * n + k]!, d[bj * n + k]!)
+          : (size[bi]! * d[bi * n + k]! + size[bj]! * d[bj * n + k]!) / (size[bi]! + size[bj]!);
+      d[bi * n + k] = v;
+      d[k * n + bi] = v;
+    }
+    size[bi] = size[bi]! + size[bj]!;
+    alive[bj] = 0;
+    for (let k = 0; k < n; k++) if (owner[k] === bj) owner[k] = bi;
+  }
+  const labels = new Int32Array(n).fill(-1);
+  const count = new Int32Array(n);
+  for (let k = 0; k < n; k++) count[owner[k]!]!++;
+  for (let k = 0; k < n; k++) if (count[owner[k]!]! > 1) labels[k] = owner[k]!;
+  return labels;
+}
+
+/** This function gives the edge groups of the consensus of the plans of the finders `members` (HWY-035). */
+export function consensusGroups(input: HighwayInput, o: Readonly<ConsensusOptions>): Map<string, EdgeGroup> {
+  const plans = [...new Set(o.members)].map((m) => candidatePlan(input, m));
+  // Only the edges on a highway of a plan get votes.
+  const voted = new Set(plans.flatMap((p) => p.highways.flatMap((h) => h.members.map((m) => m.edge))));
+  const ends = edgeEnds(input).filter((e) => voted.has(e.edge));
+  const a = coAssociation(
+    ends.map((e) => e.edge),
+    plans,
+  );
+  const labels = consensusLabels(ends.length, a, Math.max(0, Math.min(1, o.cut)), o.linkage);
+  const groups = new Map<string, EdgeGroup>();
+  labelGroups(ends, labels, "c", groups);
+  return groups;
+}
+
+/**
+ * This function gives the highways of the consensus of clusterings (HWY-035). Each finder of `members` votes for the pairs of edges that share one of its highways.
+ * The clusters of the vote matrix with `minSize` edges or more get highways. A small edit changes few votes, so the clusters are stable.
+ */
+export function consensusPlan(input: HighwayInput, o: Readonly<ConsensusOptions>): HighwayPlan {
+  return groupedPlan(input, consensusGroups(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minSize)) });
+}

package/src/highways/crossbars/index.ts

@@ -0,0 +1,184 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import type { WayOptions } from "../../ways.ts";
+import { arcPlace, basePlan, planRoutes, routeIndex, tidyPlan, type HighwayBase } from "../base.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { nearestOnLine } from "../sbeb/index.ts";
+import { snapPlan, type SnapLine } from "../snap.ts";
+
+/** The options of the highway strategy `crossbars` (HWY-022 of the notes). */
+export interface CrossbarOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that gets the bundled crossings. Only the edges outside its highways can be on a crossbar. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** Two segments are parallel when the angle between them is this value or less, in degrees. The default is 15. */
+  readonly tolerance: number;
+  /** Each side of a crossbar has this number of edges or more. The default is 2. */
+  readonly minBar: number;
+  /** The crossings of one crossbar are this distance or nearer to its first crossing, as a multiple of `boardUnit`. The default is 3. */
+  readonly reach: number;
+}
+
+/** The default options of the strategy `crossbars`. */
+export const CROSSBAR_DEFAULTS: Readonly<Required<Omit<CrossbarOptions, "margin" | "k">>> = Object.freeze({
+  from: "shared-ways",
+  tolerance: 15,
+  minBar: 2,
+  reach: 3,
+});
+
+/** One crossing of two routes: the edges, the point and the unit directions of the two segments there. */
+export interface RouteCrossing {
+  readonly e: string;
+  readonly f: string;
+  readonly p: Point;
+  readonly de: Point;
+  readonly df: Point;
+}
+
+/** This function gives the unit direction from `a` to `b`. */
+const unit = (a: Point, b: Point): Point => {
+  const l = dist(a, b);
+  return l > 1e-12 ? { x: (b.x - a.x) / l, y: (b.y - a.y) / l } : { x: 1, y: 0 };
+};
+
+/** This function gives the point where the segments `a b` and `c d` cross inside both, or `undefined`. Segments that only touch at an end do not cross. */
+function crossPoint(a: Point, b: Point, c: Point, d: Point): Point | undefined {
+  const rx = b.x - a.x;
+  const ry = b.y - a.y;
+  const sx = d.x - c.x;
+  const sy = d.y - c.y;
+  const den = rx * sy - ry * sx;
+  if (Math.abs(den) < 1e-12) return undefined;
+  const t = ((c.x - a.x) * sy - (c.y - a.y) * sx) / den;
+  const u = ((c.x - a.x) * ry - (c.y - a.y) * rx) / den;
+  const eps = 1e-9;
+  return t > eps && t < 1 - eps && u > eps && u < 1 - eps ? { x: a.x + t * rx, y: a.y + t * ry } : undefined;
+}
+
+/** This function gives each crossing of two routes of the list, in the order of the list. */
+export function routeCrossings(routes: readonly { readonly edge: string; readonly points: readonly Point[] }[]): RouteCrossing[] {
+  const segs = routes.flatMap((r) =>
+    r.points.slice(1).map((b, i) => {
+      const a = r.points[i]!;
+      return { edge: r.edge, a, b, x0: Math.min(a.x, b.x), x1: Math.max(a.x, b.x), y0: Math.min(a.y, b.y), y1: Math.max(a.y, b.y) };
+    }),
+  );
+  const out: RouteCrossing[] = [];
+  for (let i = 0; i < segs.length; i++) {
+    const s = segs[i]!;
+    for (let j = i + 1; j < segs.length; j++) {
+      const t = segs[j]!;
+      if (t.edge === s.edge || t.x0 > s.x1 || t.x1 < s.x0 || t.y0 > s.y1 || t.y1 < s.y0) continue;
+      const p = crossPoint(s.a, s.b, t.a, t.b);
+      if (p) out.push({ e: s.edge, f: t.edge, p, de: unit(s.a, s.b), df: unit(t.a, t.b) });
+    }
+  }
+  return out;
+}
+
+/** This function tells if two unit directions are parallel within the angle `tol` in radians, in either sense. */
+const parallel = (u: Point, v: Point, tol: number): boolean => Math.abs(u.x * v.x + u.y * v.y) >= Math.cos(tol);
+
+/** A crossbar: two sets of edges, with a crossing of each edge of `p` with each edge of `q` near one place. */
+export interface Crossbar {
+  readonly p: readonly string[];
+  readonly q: readonly string[];
+  /** The mean point of the crossings of the crossbar. */
+  readonly at: Point;
+  /** The mean direction of the side `p`, and of the side `q`. */
+  readonly dp: Point;
+  readonly dq: Point;
+}
+
+/**
+ * This function gives the crossbars of a greedy search (HWY-022, after Fink, Hershberger, Suri and Verbeek 2016).
+ * The search starts at each crossing in order. It grows the two sides while each new edge crosses each edge of the other side near the start, at the same angles.
+ * A crossbar with `minBar` edges or more on each side is kept. Each edge is on one crossbar at most.
+ */
+export function greedyCrossbars(crossings: readonly RouteCrossing[], reach: number, tolDeg: number, minBar: number): Crossbar[] {
+  const tol = (Math.max(0, tolDeg) * Math.PI) / 180;
+  const used = new Set<string>();
+  const out: Crossbar[] = [];
+  for (const x of crossings) {
+    if (used.has(x.e) || used.has(x.f)) continue;
+    // The crossings near the start whose two segments are parallel to the two sides, as pairs (an edge of P, an edge of Q).
+    const near = new Map<string, RouteCrossing & { pe: string; qe: string }>();
+    for (const y of crossings) {
+      if (dist(y.p, x.p) > reach || used.has(y.e) || used.has(y.f)) continue;
+      if (parallel(y.de, x.de, tol) && parallel(y.df, x.df, tol)) near.set(`${y.e}\u0000${y.f}`, { ...y, pe: y.e, qe: y.f });
+      else if (parallel(y.df, x.de, tol) && parallel(y.de, x.df, tol)) near.set(`${y.f}\u0000${y.e}`, { ...y, pe: y.f, qe: y.e, de: y.df, df: y.de });
+    }
+    const crosses = (pe: string, qe: string): boolean => near.has(`${pe}\u0000${qe}`);
+    const P = [x.e];
+    const Q = [x.f];
+    const candP = [...new Set([...near.values()].map((c) => c.pe))].sort();
+    const candQ = [...new Set([...near.values()].map((c) => c.qe))].sort();
+    for (let grown = true; grown; ) {
+      grown = false;
+      for (const pe of candP)
+        if (!P.includes(pe) && !Q.includes(pe) && Q.every((qe) => crosses(pe, qe))) {
+          P.push(pe);
+          grown = true;
+        }
+      for (const qe of candQ)
+        if (!Q.includes(qe) && !P.includes(qe) && P.every((pe) => crosses(pe, qe))) {
+          Q.push(qe);
+          grown = true;
+        }
+    }
+    if (P.length < Math.max(1, minBar) || Q.length < Math.max(1, minBar)) continue;
+    const parts = P.flatMap((pe) => Q.map((qe) => near.get(`${pe}\u0000${qe}`)!));
+    const at = { x: parts.reduce((s, c) => s + c.p.x, 0) / parts.length, y: parts.reduce((s, c) => s + c.p.y, 0) / parts.length };
+    // The mean directions, each turned to the sense of the first crossing.
+    const mean = (pick: (c: RouteCrossing) => Point, ref: Point): Point => {
+      let sx = 0;
+      let sy = 0;
+      for (const c of parts) {
+        const d = pick(c);
+        const s = d.x * ref.x + d.y * ref.y >= 0 ? 1 : -1;
+        sx += s * d.x;
+        sy += s * d.y;
+      }
+      return unit({ x: 0, y: 0 }, { x: sx, y: sy });
+    };
+    out.push({ p: P, q: Q, at, dp: mean((c) => c.de, x.de), dq: mean((c) => c.df, x.df) });
+    for (const e of [...P, ...Q]) used.add(e);
+  }
+  return out;
+}
+
+/**
+ * This function gives the highways of the bundled crossings (HWY-022). The edges outside the highways of the plan `from` keep their routes after `follow`.
+ * Each crossbar of those routes gives two highways, one for each side. Each spine is a line through the mean crossing, along the mean direction of its side.
+ * It is `2 reach` long, and it goes through the corner graph. So each side crosses the other side at one place, as a bundle.
+ * An edge joins the spine near the point of its route nearest to one end of the line. It leaves the spine near the other end.
+ */
+export function crossbarPlan(input: HighwayInput, o: Readonly<CrossbarOptions>): HighwayPlan {
+  const way: WayOptions = { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) };
+  const base = basePlan(input, o.from);
+  const inPlan = new Set(base.highways.flatMap((h) => h.members.map((m) => m.edge)));
+  const routes = routeIndex(planRoutes(input.graph, base).routes);
+  const free = input.graph.edges.filter((e) => !inPlan.has(e.id) && routes.has(e.id)).map((e) => ({ edge: e.id, points: routes.get(e.id)!.slice(1, -1) }));
+  const reach = Math.max(1e-3, o.reach * boardUnit(input.graph));
+  const bars = greedyCrossbars(routeCrossings(free), reach, o.tolerance, o.minBar);
+  const lines: SnapLine[] = [];
+  bars.forEach((bar, i) => {
+    for (const [side, d] of [
+      [bar.p, bar.dp],
+      [bar.q, bar.dq],
+    ] as const) {
+      const a = { x: bar.at.x - reach * d.x, y: bar.at.y - reach * d.y };
+      const b = { x: bar.at.x + reach * d.x, y: bar.at.y + reach * d.y };
+      const members = side.map((edge) => {
+        const r = routes.get(edge)!;
+        const from = nearestOnLine(r, a);
+        const to = nearestOnLine(r, b);
+        const total = arcPlace(r, r[r.length - 1]!);
+        return { edge, from, to, at: total > 0 ? arcPlace(r, from) / total : 0 };
+      });
+      lines.push({ key: `x${i}`, a, b, members });
+    }
+  });
+  const bars2 = snapPlan(input, lines, { ...way, minSize: 2 });
+  return tidyPlan({ highways: [...base.highways, ...bars2.highways] });
+}

package/src/highways/cubu/index.ts

@@ -0,0 +1,26 @@
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { densityPlan, KDEEB_DEFAULTS, type DensityKernel, type KdeebOptions } from "../kdeeb/index.ts";
+
+/** The options of the highway strategy `cubu` (HWY-007 of the notes). */
+export interface CubuOptions extends KdeebOptions {
+  /** The way to compute the density: `separable` (CUBu) or `fft` (FFTEB). The default is `separable`. */
+  readonly kernel: Exclude<DensityKernel, "direct">;
+  /** The spacing of the sample points after each step, in units of the board. The value 0 keeps the points. The default is 8. */
+  readonly resample: number;
+}
+
+/** The default options of the strategy `cubu`. */
+export const CUBU_DEFAULTS: Readonly<Required<Omit<CubuOptions, "margin" | "k">>> = Object.freeze({
+  ...KDEEB_DEFAULTS,
+  kernel: "separable",
+  resample: 8,
+});
+
+/**
+ * This function gives the highways of the fast density bundling (HWY-007: CUBu of van der Zwan, Codreanu and Telea 2016, and FFTEB of Lhuillier, Hurter and Telea 2017).
+ * The steps are those of `kdeeb`, with the mask of the boxes. The density comes from the counts of the cells, blurred by a separable kernel or by a Fourier transform.
+ * The sample points of each edge are spaced again after each step.
+ */
+export function cubuPlan(input: HighwayInput, o: Readonly<CubuOptions>): HighwayPlan {
+  return densityPlan(input, o, { kernel: o.kernel, resample: o.resample }, "cubu");
+}

package/src/highways/divided/index.ts

@@ -0,0 +1,111 @@
+import type { Point } from "../../geom.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { basePlan, tidyPlan, type HighwayBase } from "../base.ts";
+import { pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The side of the road that the traffic keeps to. */
+export type TrafficRule = "right" | "left";
+
+/** The values of `TrafficRule`. */
+export const TRAFFIC_RULES: readonly TrafficRule[] = Object.freeze(["right", "left"]);
+
+/** The options of the highway strategy `divided` (HWY-011 of the notes). */
+export interface DividedOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The plan that the strategy divides. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The side of the road of the traffic. With `right`, the edges of each direction keep to the right of the spine. The default is `right`. */
+  readonly rule: TrafficRule;
+  /** The gap between the two carriageways, in lanes. The default is 1. */
+  readonly gap: number;
+  /** The width of one lane, in units of the board. The default is 4. */
+  readonly laneWidth: number;
+  /** A highway divides only when each direction has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `divided`. */
+export const DIVIDED_DEFAULTS: Readonly<Required<Omit<DividedOptions, "margin" | "k">>> = Object.freeze({
+  from: "shared-ways",
+  rule: "right",
+  gap: 1,
+  laneWidth: 4,
+  minSize: 2,
+});
+
+/** The largest length of a miter, as a multiple of the offset. A sharper corner gets a shorter miter. */
+const MITER = 2;
+
+/**
+ * This function gives the polyline at the distance `offset` from `line`, with the same number of points. A positive offset is on the right of the line.
+ * The y axis points down, so the right of the direction `(dx, dy)` is `(-dy, dx)`. Each inner point moves along the bisector of its two legs (a miter join).
+ */
+export function offsetLine(line: readonly Point[], offset: number): Point[] {
+  const n = line.length;
+  const normals: Point[] = [];
+  for (let i = 1; i < n; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const l = Math.hypot(b.x - a.x, b.y - a.y);
+    normals.push(l > 1e-12 ? { x: -(b.y - a.y) / l, y: (b.x - a.x) / l } : { x: 0, y: 0 });
+  }
+  return line.map((p, i) => {
+    const before = normals[i - 1] ?? normals[i]!;
+    const after = normals[i] ?? normals[i - 1]!;
+    let mx = before.x + after.x;
+    let my = before.y + after.y;
+    const ml = Math.hypot(mx, my);
+    if (ml < 1e-12) {
+      mx = after.x;
+      my = after.y;
+    } else {
+      mx /= ml;
+      my /= ml;
+    }
+    const cos = mx * after.x + my * after.y;
+    const scale = Math.min(MITER, 1 / Math.max(1e-6, cos));
+    return { x: p.x + mx * offset * scale, y: p.y + my * offset * scale };
+  });
+}
+
+/** This function gives a highway with a new spine and the members in `members`. The merge points and split points move to the new spine. */
+function carriageway(h: Highway, spine: readonly Point[], members: readonly HighwayMember[], suffix: string): Highway {
+  const moved = members.map((m) => ({ ...m, merge: pointAt(spine, m.on), split: pointAt(spine, m.off) }));
+  return { id: `${h.id}${suffix}`, key: h.key, spine, lanes: moved.map((m) => m.edge), members: moved };
+}
+
+/**
+ * This function divides one highway into two carriageways, one for each direction (HWY-011, divided edge bundling of Selassie, Heller and Heer 2011).
+ * Each carriageway is a copy of the spine at an offset to the side of its traffic. The offset is half the lanes of that side plus half the gap.
+ * When an offset spine is not clear of the boxes, the function tries one half and one quarter of the offset. It gives `undefined` when none fits.
+ */
+export function divideHighway(h: Highway, finder: WayFinder, o: Readonly<Omit<DividedOptions, "from" | "margin" | "k">>): Highway[] | undefined {
+  const forward = h.members.filter((m) => m.on < m.off);
+  const backward = h.members.filter((m) => m.on > m.off);
+  const size = Math.max(1, o.minSize);
+  if (forward.length < size || backward.length < size) return undefined;
+  const sign = o.rule === "left" ? -1 : 1;
+  const lane = Math.max(0, o.laneWidth);
+  const gap = Math.max(0, o.gap);
+  const pad = finder.margin / 4;
+  const wanted = (count: number): number => lane * (count / 2 + gap / 2);
+  for (const share of [1, 0.5, 0.25]) {
+    const right = offsetLine(h.spine, sign * share * wanted(forward.length));
+    const left = offsetLine(h.spine, -sign * share * wanted(backward.length));
+    if (!finder.obstacles.clearPath(right, pad) || !finder.obstacles.clearPath(left, pad)) continue;
+    return [carriageway(h, right, forward, "a"), carriageway(h, left, backward, "b")];
+  }
+  return undefined;
+}
+
+/**
+ * This function gives the highways of the plan `from`, with each highway of two-way traffic divided into two carriageways (HWY-011).
+ * The edges of each direction get their own spine on the side of the rule `rule`. Thus the two directions do not cross in the lanes.
+ * A highway with fewer than `minSize` edges in one direction, or without the room for the offsets, stays as it is.
+ */
+export function dividedPlan(input: HighwayInput, o: Readonly<DividedOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const base = basePlan(input, o.from);
+  const highways: Highway[] = [];
+  for (const h of base.highways) highways.push(...(divideHighway(h, finder, o) ?? [h]));
+  return tidyPlan({ highways });
+}