@mark1russell7/highways 0.0.0-stage → 0.1.0

package/src/routers/sections.ts

@@ -0,0 +1,236 @@
+import { center, dist, polylineLength, type Box, type Point } from "../geom.ts";
+import {
+  nodeIndex,
+  type Graph,
+  type Level,
+  type LevelItem,
+  type LevelLink,
+  type Node,
+  type Result,
+  type Route,
+  type Router,
+  type SharedRun,
+} from "../model.ts";
+import { placePlug } from "../plugs.ts";
+import { allSections, buildSections, treeDepth, type Section, type SectionOptions } from "../sections.ts";
+import { orderLanes } from "../segments.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/** The options of the router with sections. */
+export interface SectionsOptions extends WayOptions, SectionOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
+   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   */
+  readonly hubs?: number;
+  /** A way through the hubs can be at most this many times as long as the line between its plugs. Else the edge goes directly. The default is 2. */
+  readonly stretch?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+
+const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
+
+/**
+ * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+ * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+ * Each way from hub to hub is found one time, so all the edges on it share its points.
+ * The edges in one section of the lowest level go straight around the nodes. The result gives one zoom level for each depth of the tree.
+ */
+export function sectionsRouter(options: SectionsOptions): Router {
+  const router: Router = {
+    name: options.name,
+    route(graph: Graph): Result {
+      const stretch = options.stretch ?? 2;
+      const byId = nodeIndex(graph);
+      const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+      const ways = new WayFinder(graph.nodes, options);
+      const corners = ways.corners;
+      const root = buildSections(graph.nodes, options);
+      const parent = new Map<Section, Section>();
+      const leafOf: Section[] = [];
+      for (const s of allSections(root)) {
+        for (const c of s.children) parent.set(c, s);
+        if (s.children.length === 0) for (const i of s.nodes) leafOf[i] = s;
+      }
+      const hubs = new Map<Section, Point>();
+      const hub = (s: Section): Point => {
+        let h = hubs.get(s);
+        if (!h) {
+          let x = 0;
+          let y = 0;
+          for (const i of s.nodes) {
+            const c = center(graph.nodes[i]!.box);
+            x += c.x;
+            y += c.y;
+          }
+          const c = { x: x / Math.max(1, s.nodes.length), y: y / Math.max(1, s.nodes.length) };
+          const j = corners.nearest(c);
+          h = j >= 0 ? corners.points[j]! : c;
+          hubs.set(s, h);
+        }
+        return h;
+      };
+      const up = (s: Section): Section[] => {
+        const out: Section[] = [];
+        for (let x: Section | undefined = s; x; x = parent.get(x)) out.push(x);
+        return out;
+      };
+
+      // The ways between two places, found one time. A place is a hub or a free point.
+      const pieces = new Map<string, Point[]>();
+      const users = new Map<string, string[]>();
+      const piece = (ka: string, a: Point, kb: string, b: Point, used: string[]): Point[] => {
+        const forward = ka <= kb;
+        const key = forward ? `${ka}>${kb}` : `${kb}>${ka}`;
+        let p = pieces.get(key);
+        if (!p) {
+          const [from, to] = forward ? [a, b] : [b, a];
+          const way = corners.path(from, to);
+          p = dedupe(way ? corners.pull(way) : [from, to]);
+          pieces.set(key, p);
+        }
+        if (!used.includes(key)) used.push(key);
+        return forward ? p : [...p].reverse();
+      };
+      const at = (p: Point): string => `${p.x},${p.y}`;
+
+      const routes: Route[] = [];
+      // The index in the route of each hub that the route passes, by section.
+      const marks = new Map<string, Map<Section, number>>();
+      for (const e of graph.edges) {
+        const s = byId.get(e.source.node);
+        const t = byId.get(e.target.node);
+        const iu = indexOfNode.get(e.source.node);
+        const iv = indexOfNode.get(e.target.node);
+        if (!s || !t || iu === undefined || iv === undefined) continue;
+        const ps = placePlug(s, e.source, center(t.box));
+        const pt = placePlug(t, e.target, center(s.box));
+        const lu = leafOf[iu]!;
+        const lv = leafOf[iv]!;
+        if (lu === lv) {
+          routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+          continue;
+        }
+        const a = up(lu);
+        const b = up(lv);
+        const common = new Set(b);
+        const lca = a.find((x) => common.has(x))!;
+        const keep = options.hubs ?? Infinity;
+        const side = (list: Section[]): Section[] => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
+        const chain = [...side(a), ...side(b).reverse()];
+        const out: Point[] = [ps.point];
+        const mark = new Map<Section, number>();
+        const append = (p: readonly Point[]): void => {
+          for (const q of p) if (dist(q, out[out.length - 1]!) > 1e-9) out.push(q);
+        };
+        const used: string[] = [];
+        const start = ways.out(ps);
+        append(piece(at(start), start, chain[0]!.id, hub(chain[0]!), used));
+        mark.set(chain[0]!, out.length - 1);
+        for (let i = 1; i < chain.length; i++) {
+          append(piece(chain[i - 1]!.id, hub(chain[i - 1]!), chain[i]!.id, hub(chain[i]!), used));
+          mark.set(chain[i]!, out.length - 1);
+        }
+        const end = ways.out(pt);
+        append(piece(chain[chain.length - 1]!.id, hub(chain[chain.length - 1]!), at(end), end, used));
+        append([pt.point]);
+        // A way through the hubs that is too long gives way to the direct way.
+        if (polylineLength(out) > stretch * dist(ps.point, pt.point) + 4 * ways.margin) {
+          routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+          continue;
+        }
+        for (const key of used) {
+          const list = users.get(key);
+          if (list) list.push(e.id);
+          else users.set(key, [e.id]);
+        }
+        routes.push({ edge: e.id, points: out });
+        marks.set(e.id, mark);
+      }
+
+      const routeOf = new Map(routes.map((r) => [r.edge, r]));
+      const runs: SharedRun[] = [];
+      for (const [key, p] of pieces) {
+        const list = users.get(key) ?? [];
+        if (list.length < 2 || p.length < 2) continue;
+        runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!)) });
+      }
+      return { routes, runs, levels: makeLevels(graph, root, routeOf, marks) };
+    },
+  };
+  return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
+}
+
+/**
+ * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
+ * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
+ * Its points are the part of the route of its first edge between the two items.
+ */
+function makeLevels(
+  graph: Graph,
+  root: Section,
+  routeOf: ReadonlyMap<string, Route>,
+  marks: ReadonlyMap<string, ReadonlyMap<Section, number>>,
+): Level[] {
+  const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
+  const levels: Level[] = [];
+  const deepest = treeDepth(root);
+  for (let d = 0; d <= deepest + 1; d++) {
+    const items: LevelItem[] = [];
+    const itemOf: (Section | number)[] = [];
+    const boxOf = (list: readonly number[]): Box => {
+      let x0 = Infinity;
+      let y0 = Infinity;
+      let x1 = -Infinity;
+      let y1 = -Infinity;
+      for (const i of list) {
+        const b = graph.nodes[i]!.box;
+        x0 = Math.min(x0, b.x);
+        y0 = Math.min(y0, b.y);
+        x1 = Math.max(x1, b.x + b.w);
+        y1 = Math.max(y1, b.y + b.h);
+      }
+      return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+    };
+    const visit = (s: Section): void => {
+      if (s.depth >= d) {
+        items.push({ id: s.id, box: boxOf(s.nodes), nodes: s.nodes.map((i) => graph.nodes[i]!.id) });
+        for (const i of s.nodes) itemOf[i] = s;
+      } else if (s.children.length > 0) for (const c of s.children) visit(c);
+      else
+        for (const i of s.nodes) {
+          const n = graph.nodes[i]!;
+          items.push({ id: n.id, box: n.box, nodes: [n.id] });
+          itemOf[i] = i;
+        }
+    };
+    if (graph.nodes.length > 0) visit(root);
+    const links = new Map<string, { source: string; target: string; count: number; points: readonly Point[] }>();
+    for (const e of graph.edges) {
+      const iu = indexOfNode.get(e.source.node);
+      const iv = indexOfNode.get(e.target.node);
+      if (iu === undefined || iv === undefined) continue;
+      const a = itemOf[iu]!;
+      const b = itemOf[iv]!;
+      if (a === b) continue;
+      const ida = typeof a === "number" ? graph.nodes[a]!.id : a.id;
+      const idb = typeof b === "number" ? graph.nodes[b]!.id : b.id;
+      const key = `${ida}\u0000${idb}`;
+      const link = links.get(key);
+      if (link) {
+        link.count++;
+        continue;
+      }
+      const route = routeOf.get(e.id)?.points ?? [];
+      const mark = marks.get(e.id);
+      const from = typeof a === "number" ? 0 : (mark?.get(a) ?? 0);
+      const to = typeof b === "number" ? route.length - 1 : (mark?.get(b) ?? route.length - 1);
+      links.set(key, { source: ida, target: idb, count: 1, points: route.slice(from, to + 1) });
+    }
+    levels.push({ depth: d, items, links: [...links.values()] as LevelLink[] });
+  }
+  return levels;
+}

package/src/routers/shared.ts

@@ -0,0 +1,223 @@
+import { center, dist, type Point } from "../geom.ts";
+import { nodeIndex, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/** The options of the router with shared ways. */
+export interface SharedOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The edges with one key share their ways. Without a rule, all edges share. An edge without a key shares with no edge. */
+  readonly rule?: GroupRule;
+  /** The cost of a link that an edge with the same key uses already, as a share of its length. The default is 0.5. */
+  readonly discount?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+
+interface Way {
+  readonly edge: Edge;
+  readonly key: string;
+  readonly ps: Plug;
+  readonly pt: Plug;
+  /** The way through the corner graph, from the point out of the source plug to the point out of the target plug. */
+  seq: Point[];
+  /** The index of each point of `seq` in the corner graph. The two ends get an index after the corners, one for each place. */
+  ids: number[];
+  found: boolean;
+}
+
+interface Run {
+  readonly key: string;
+  readonly first: number;
+  readonly last: number;
+  /** The points from the corner `first` to the corner `last`, without the needless corners. */
+  readonly points: Point[];
+  readonly ways: Way[];
+}
+
+const byText = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
+
+/** The angle, from -π to π, of the turn at `base` from the direction `from` → `base` to the point `to`. */
+function turn(from: Point, base: Point, to: Point): number {
+  const dx = base.x - from.x;
+  const dy = base.y - from.y;
+  const vx = to.x - base.x;
+  const vy = to.y - base.y;
+  return Math.atan2(dx * vy - dy * vx, dx * vx + dy * vy);
+}
+
+/**
+ * This function makes a router where edges share their ways (after Pupyrev, Nachmanson, Bereg and Holroyd, "Edge routing with ordered bundles").
+ * The edges go one by one through the corner graph. A link that an edge with the same key uses already costs less.
+ * Thus the edges of a key come together on common ways. Each stretch that several edges share has the same points in each route.
+ * The result gives each stretch as a run, with the order of its lanes.
+ */
+export function sharedRouter(options: SharedOptions): Router {
+  const discount = Math.min(1, Math.max(0.05, options.discount ?? 0.5));
+  const keyOf = (e: Edge): string => {
+    if (!options.rule) return "*";
+    return options.rule(e) ?? `\u0000${e.id}`;
+  };
+  const router: Router = {
+    name: options.name,
+    route(graph: Graph): Result {
+      const byId = nodeIndex(graph);
+      const ways = new WayFinder(graph.nodes, options);
+      const corners = ways.corners;
+      const index = new Map<Point, number>();
+      corners.points.forEach((p, i) => index.set(p, i));
+      const M = corners.points.length + 1;
+      const link = (i: number, j: number): number => (i < j ? i * M + j : j * M + i);
+      const ends = new Map<string, number>();
+      const endId = (p: Point): number => {
+        const k = `${p.x},${p.y}`;
+        let id = ends.get(k);
+        if (id === undefined) ends.set(k, (id = corners.points.length + ends.size));
+        return id;
+      };
+
+      const all: Way[] = [];
+      for (const e of graph.edges) {
+        const s = byId.get(e.source.node);
+        const t = byId.get(e.target.node);
+        if (!s || !t) continue;
+        const ps = placePlug(s, e.source, center(t.box));
+        const pt = placePlug(t, e.target, center(s.box));
+        all.push({ edge: e, key: keyOf(e), ps, pt, seq: [], ids: [], found: false });
+      }
+
+      // The edges of one key go one after the other, the longest first, so that the short edges join the long ways.
+      const discounted = new Map<string, Map<number, string[]>>();
+      const order = [...all].sort(
+        (p, q) => byText(p.key, q.key) || dist(q.ps.point, q.pt.point) - dist(p.ps.point, p.pt.point) || byText(p.edge.id, q.edge.id),
+      );
+      for (const w of order) {
+        let used = discounted.get(w.key);
+        if (!used) discounted.set(w.key, (used = new Map()));
+        const mine = used;
+        const way = corners.path(ways.out(w.ps), ways.out(w.pt), (i, j, d) => (mine.has(link(i, j)) ? d * discount : d), discount);
+        if (!way) continue;
+        w.found = true;
+        w.seq = way;
+        w.ids = way.map((p, i) => (i === 0 || i === way.length - 1 ? endId(p) : index.get(p)!));
+        for (let i = 1; i < w.ids.length; i++) {
+          const a = w.ids[i - 1]!;
+          const b = w.ids[i]!;
+          if (a >= corners.points.length || b >= corners.points.length) continue;
+          const list = mine.get(link(a, b));
+          if (list) list.push(w.edge.id);
+          else mine.set(link(a, b), [w.edge.id]);
+        }
+      }
+
+      // The users of each link, with the links to the ends. Two edges from one plug share the link from it.
+      const users = new Map<string, Map<string, string[]>>();
+      for (const w of order) {
+        if (!w.found) continue;
+        let mine = users.get(w.key);
+        if (!mine) users.set(w.key, (mine = new Map()));
+        for (let i = 1; i < w.ids.length; i++) {
+          const a = w.ids[i - 1]!;
+          const b = w.ids[i]!;
+          const k = a < b ? `${a}:${b}` : `${b}:${a}`;
+          const list = mine.get(k);
+          if (list) list.push(w.edge.id);
+          else mine.set(k, [w.edge.id]);
+        }
+      }
+
+      // Each way breaks into stretches where the set of edges on the links stays the same.
+      // A shared stretch loses its needless corners one time, so it has the same points in each of its routes.
+      const runs = new Map<string, Run>();
+      const points = new Map<string, Point[]>();
+      for (const w of all) {
+        if (!w.found) continue;
+        const used = users.get(w.key)!;
+        const sig = (i: number): string => {
+          const a = w.ids[i]!;
+          const b = w.ids[i + 1]!;
+          const list = used.get(a < b ? `${a}:${b}` : `${b}:${a}`)!;
+          return list.length < 2 ? "" : [...list].sort(byText).join("\u0001");
+        };
+        const out: Point[] = [w.ps.point];
+        const append = (piece: readonly Point[]): void => {
+          for (const p of piece) if (dist(p, out[out.length - 1]!) > 1e-9) out.push(p);
+        };
+        let start = 0;
+        for (let i = 0; i < w.seq.length - 1; i++) {
+          const s = sig(i);
+          if (i + 1 < w.seq.length - 1 && sig(i + 1) === s) continue;
+          const raw = w.seq.slice(start, i + 2);
+          if (s === "") append(corners.pull(raw));
+          else {
+            const a = w.ids[start]!;
+            const b = w.ids[i + 1]!;
+            const id = `${s}\u0002${Math.min(a, b)}\u0002${Math.max(a, b)}`;
+            let run = runs.get(id);
+            if (!run) {
+              run = { key: w.key, first: Math.min(a, b), last: Math.max(a, b), points: corners.pull(a < b ? raw : [...raw].reverse()), ways: [] };
+              runs.set(id, run);
+            }
+            run.ways.push(w);
+            append(a < b ? run.points : [...run.points].reverse());
+          }
+          start = i + 1;
+        }
+        append([w.pt.point]);
+        points.set(w.edge.id, out);
+      }
+
+      const routes: Route[] = [];
+      for (const w of all) routes.push({ edge: w.edge.id, points: points.get(w.edge.id) ?? [w.ps.point, w.pt.point] });
+      const shared: SharedRun[] = [];
+      for (const run of runs.values()) {
+        shared.push({ id: `r${shared.length}`, key: run.key, points: run.points, edges: laneOrderOfRun(run) });
+      }
+      return { routes, runs: shared };
+    },
+  };
+  return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
+}
+
+/**
+ * This function gives the lane order of a run (metro-line order). Two edges of the run go together past its last corner
+ * until they part. The edge that turns more to the left there gets the lane more to the left.
+ * Two edges can part only before the first corner. Then the edge that comes from more to the left gets the lane more to the left.
+ */
+function laneOrderOfRun(run: Run): string[] {
+  const oriented = new Map<Way, { seq: Point[]; ids: number[]; s: number; e: number }>();
+  for (const w of run.ways) {
+    const s0 = w.ids.indexOf(run.first);
+    const e0 = w.ids.indexOf(run.last);
+    if (s0 < e0) oriented.set(w, { seq: w.seq, ids: w.ids, s: s0, e: e0 });
+    else oriented.set(w, { seq: [...w.seq].reverse(), ids: [...w.ids].reverse(), s: w.seq.length - 1 - s0, e: w.seq.length - 1 - e0 });
+  }
+  const compare = (p: Way, q: Way): number => {
+    const P = oriented.get(p)!;
+    const Q = oriented.get(q)!;
+    for (let j = 1; ; j++) {
+      const a = P.seq[P.e + j];
+      const b = Q.seq[Q.e + j];
+      if (a === undefined || b === undefined) break;
+      if (P.ids[P.e + j] !== Q.ids[Q.e + j]) {
+        const d = turn(P.seq[P.e + j - 2]!, P.seq[P.e + j - 1]!, a) - turn(P.seq[P.e + j - 2]!, P.seq[P.e + j - 1]!, b);
+        if (d !== 0) return d;
+        break;
+      }
+    }
+    for (let j = 1; ; j++) {
+      const a = P.seq[P.s - j];
+      const b = Q.seq[Q.s - j];
+      if (a === undefined || b === undefined) break;
+      if (P.ids[P.s - j] !== Q.ids[Q.s - j]) {
+        // Seen backward, the left side is the right side. Thus the order turns around.
+        const d = turn(P.seq[P.s - j + 2]!, P.seq[P.s - j + 1]!, b) - turn(P.seq[P.s - j + 2]!, P.seq[P.s - j + 1]!, a);
+        if (d !== 0) return d;
+        break;
+      }
+    }
+    return byText(p.edge.id, q.edge.id);
+  };
+  return [...run.ways].sort(compare).map((w) => w.edge.id);
+}

package/src/routers/straight.ts

@@ -0,0 +1,37 @@
+import { center, type Box, type Point } from "../geom.ts";
+import { fixedPortPoint, nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+
+/** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
+export function boxExit(box: Box, toward: Point): Point {
+  const c = center(box);
+  const dx = toward.x - c.x;
+  const dy = toward.y - c.y;
+  if (dx === 0 && dy === 0) return c;
+  const tx = dx === 0 ? Infinity : box.w / 2 / Math.abs(dx);
+  const ty = dy === 0 ? Infinity : box.h / 2 / Math.abs(dy);
+  const t = Math.min(tx, ty);
+  return { x: c.x + dx * t, y: c.y + dy * t };
+}
+
+/**
+ * The control of the benchmark: each edge is one straight line between its plugs.
+ * A free plug goes where the line between the two centers leaves the box.
+ */
+export const straightRouter: Router = {
+  name: "straight",
+  route(graph: Graph): Result {
+    const byId = nodeIndex(graph);
+    const routes: Route[] = [];
+    for (const e of graph.edges) {
+      const s = byId.get(e.source.node);
+      const t = byId.get(e.target.node);
+      if (!s || !t) continue;
+      const fs = fixedPortPoint(s, e.source);
+      const ft = fixedPortPoint(t, e.target);
+      const a = fs ?? boxExit(s.box, ft ?? center(t.box));
+      const b = ft ?? boxExit(t.box, fs ?? center(s.box));
+      routes.push({ edge: e.id, points: [a, b] });
+    }
+    return { routes };
+  },
+};

package/src/routers/trunks.ts

@@ -0,0 +1,134 @@
+import { center, dist, type Point } from "../geom.ts";
+import { nodeIndex, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/** The options of the trunk router. */
+export interface TrunksOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The grouping rule. The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule;
+  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
+  readonly split?: number;
+  /** A group with fewer edges stays unbundled. The default is 2. */
+  readonly minSize?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+
+/** The rule that groups the edges by the collection of their target, in `data.collection`. */
+export const byCollection: GroupRule = (e) => {
+  const c = e.data?.["collection"];
+  return typeof c === "string" ? c : undefined;
+};
+
+/**
+ * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
+ * A group with fewer than `minSize` edges does not appear.
+ */
+export function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize = 2): Map<string, Edge[]> {
+  const all = new Map<string, Edge[]>();
+  for (const e of edges) {
+    const key = rule(e);
+    if (key === undefined) continue;
+    const id = `${e.source.node}\u0000${e.source.port ?? ""}\u0000${key}`;
+    const list = all.get(id);
+    if (list) list.push(e);
+    else all.set(id, [e]);
+  }
+  for (const [id, list] of all) if (list.length < minSize) all.delete(id);
+  return all;
+}
+
+/**
+ * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
+ * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
+ */
+export function laneOrder(dir: Point, from: Point, branches: readonly { readonly edge: string; readonly next: Point }[]): string[] {
+  const angle = (p: Point): number => {
+    const vx = p.x - from.x;
+    const vy = p.y - from.y;
+    return Math.atan2(dir.x * vy - dir.y * vx, dir.x * vx + dir.y * vy);
+  };
+  return branches
+    .map((b) => ({ edge: b.edge, a: angle(b.next) }))
+    .sort((p, q) => p.a - q.a || (p.edge < q.edge ? -1 : p.edge > q.edge ? 1 : 0))
+    .map((x) => x.edge);
+}
+
+/**
+ * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
+ * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
+ */
+export function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point {
+  if (targets.length === 0) return start;
+  const c = { x: targets.reduce((s, p) => s + p.x, 0) / targets.length, y: targets.reduce((s, p) => s + p.y, 0) / targets.length };
+  const L = dist(start, c);
+  if (L === 0) return start;
+  let d = Math.min(split * L, 0.5 * Math.min(...targets.map((p) => dist(start, p))));
+  const at = (t: number): Point => ({ x: start.x + ((c.x - start.x) * t) / L, y: start.y + ((c.y - start.y) * t) / L });
+  while (d > 0 && !free(at(d))) d -= step;
+  return d > 0 ? at(d) : start;
+}
+
+const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || dist(q, p[i - 1]!) > 1e-9);
+
+/**
+ * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
+ * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
+ * The edges outside the groups go as in the corner router.
+ */
+export function trunksRouter(options: TrunksOptions): Router {
+  const router: Router = {
+    name: options.name,
+    route(graph: Graph): Result {
+      const byId = nodeIndex(graph);
+      const ways = new WayFinder(graph.nodes, options);
+      const points = new Map<string, Point[]>();
+      const bundles: Bundle[] = [];
+      for (const [id, group] of groupEdges(graph.edges, options.rule, options.minSize ?? 2)) {
+        const first = group[0]!;
+        const s = byId.get(first.source.node);
+        const targets = group.map((e) => byId.get(e.target.node));
+        if (!s || targets.some((t) => !t)) continue;
+        const centers = targets.map((t) => center(t!.box));
+        const c = { x: centers.reduce((a, p) => a + p.x, 0) / centers.length, y: centers.reduce((a, p) => a + p.y, 0) / centers.length };
+        const plug: Plug = placePlug(s, first.source, c);
+        const start = ways.out(plug);
+        const split = splitPoint(start, centers, options.split ?? 0.5, (p) => !ways.obstacles.inside(p, ways.margin), ways.margin);
+        const way = ways.fromPlug(plug, split);
+        if (!way) continue;
+        const trunk = dedupe(way);
+        const end = trunk[trunk.length - 1]!;
+        const prev = trunk.length >= 2 ? trunk[trunk.length - 2]! : plug.point;
+        const len = dist(prev, end);
+        const dir = len > 0 ? { x: (end.x - prev.x) / len, y: (end.y - prev.y) / len } : plug.normal;
+        const branches: { edge: string; next: Point }[] = [];
+        group.forEach((e, i) => {
+          const pt = placePlug(targets[i]!, e.target, end);
+          const branch = dedupe(ways.toPlug(end, pt) ?? [end, pt.point]);
+          points.set(e.id, dedupe([...trunk, ...branch.slice(1)]));
+          branches.push({ edge: e.id, next: branch[1] ?? pt.point });
+        });
+        bundles.push({ id: `b${bundles.length}`, key: id.split("\u0000")[2]!, node: s.id, edges: laneOrder(dir, end, branches), trunk });
+      }
+      const routes: Route[] = [];
+      for (const e of graph.edges) {
+        const s = byId.get(e.source.node);
+        const t = byId.get(e.target.node);
+        if (!s || !t) continue;
+        const known = points.get(e.id);
+        if (known) {
+          routes.push({ edge: e.id, points: known });
+          continue;
+        }
+        const ps = placePlug(s, e.source, center(t.box));
+        const pt = placePlug(t, e.target, center(s.box));
+        routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
+      }
+      return { routes, bundles };
+    },
+  };
+  return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
+}