@mark1russell7/highways 0.0.0-stage → 0.1.1

package/src/geom.ts

@@ -0,0 +1,177 @@
+/** A point in the plane. */
+export interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+
+/** A box with its top-left corner at (`x`, `y`). */
+export interface Box {
+  readonly x: number;
+  readonly y: number;
+  readonly w: number;
+  readonly h: number;
+}
+
+/** This function gives the distance between two points. */
+export function dist(a: Point, b: Point): number {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/** This function gives the center of a box. */
+export function center(b: Box): Point {
+  return { x: b.x + b.w / 2, y: b.y + b.h / 2 };
+}
+
+/** This function gives a box that is larger by `m` on each side. A negative `m` makes the box smaller. */
+export function inflate(b: Box, m: number): Box {
+  return { x: b.x - m, y: b.y - m, w: Math.max(0, b.w + 2 * m), h: Math.max(0, b.h + 2 * m) };
+}
+
+/** This function gives the sum of the lengths of the segments of a polyline. */
+export function polylineLength(p: readonly Point[]): number {
+  let s = 0;
+  for (let i = 1; i < p.length; i++) s += dist(p[i - 1]!, p[i]!);
+  return s;
+}
+
+const orient = (a: Point, b: Point, c: Point): number => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+
+/**
+ * This function tells if the segments `ab` and `cd` cross at one point inside both of them.
+ * Segments that only touch at an end, or that are collinear, do not cross.
+ */
+export function segmentsCross(a: Point, b: Point, c: Point, d: Point): boolean {
+  const d1 = orient(c, d, a);
+  const d2 = orient(c, d, b);
+  const d3 = orient(a, b, c);
+  const d4 = orient(a, b, d);
+  return d1 * d2 < 0 && d3 * d4 < 0;
+}
+
+/**
+ * This function tells if the segment `ab` goes through the inside of the box.
+ * The function clips the segment to the box (Liang-Barsky) and asks for a part longer than `eps`.
+ */
+export function segmentHitsBox(a: Point, b: Point, box: Box, eps = 1e-6): boolean {
+  return segmentHitsRect(a, b, box.x, box.y, box.x + box.w, box.y + box.h, eps);
+}
+
+/** This function tells if the segment `ab` goes through the inside of the box from (`x0`, `y0`) to (`x1`, `y1`). */
+export function segmentHitsRect(a: Point, b: Point, x0: number, y0: number, x1: number, y1: number, eps = 1e-6): boolean {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let t0 = 0;
+  let t1 = 1;
+  if (dx === 0) {
+    if (a.x <= x0 || a.x >= x1) return false;
+  } else {
+    const ta = (x0 - a.x) / dx;
+    const tb = (x1 - a.x) / dx;
+    t0 = Math.max(t0, Math.min(ta, tb));
+    t1 = Math.min(t1, Math.max(ta, tb));
+    if (t0 > t1) return false;
+  }
+  if (dy === 0) {
+    if (a.y <= y0 || a.y >= y1) return false;
+  } else {
+    const ta = (y0 - a.y) / dy;
+    const tb = (y1 - a.y) / dy;
+    t0 = Math.max(t0, Math.min(ta, tb));
+    t1 = Math.min(t1, Math.max(ta, tb));
+    if (t0 > t1) return false;
+  }
+  return (t1 - t0) * Math.sqrt(dx * dx + dy * dy) > eps;
+}
+
+/** This function gives the distance from a point to a box. The distance is 0 when the point is in the box. */
+export function pointBoxDistance(p: Point, b: Box): number {
+  const qx = Math.max(b.x, Math.min(b.x + b.w, p.x));
+  const qy = Math.max(b.y, Math.min(b.y + b.h, p.y));
+  return Math.hypot(p.x - qx, p.y - qy);
+}
+
+/** This function gives the distance from a point to the segment `ab`. */
+export function pointSegmentDistance(p: Point, a: Point, b: Point): number {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const l2 = dx * dx + dy * dy;
+  const t = l2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+
+/** This function gives the distance from the segment `ab` to a box. The distance is 0 when they touch. */
+export function segmentBoxDistance(a: Point, b: Point, box: Box): number {
+  if (segmentHitsBox(a, b, box, 0) || pointBoxDistance(a, box) === 0 || pointBoxDistance(b, box) === 0) return 0;
+  const corners: Point[] = [
+    { x: box.x, y: box.y },
+    { x: box.x + box.w, y: box.y },
+    { x: box.x, y: box.y + box.h },
+    { x: box.x + box.w, y: box.y + box.h },
+  ];
+  let d = Math.min(pointBoxDistance(a, box), pointBoxDistance(b, box));
+  for (const c of corners) d = Math.min(d, pointSegmentDistance(c, a, b));
+  return d;
+}
+
+/**
+ * This function gives the turn at each inner vertex of a polyline, in radians, from -π to π.
+ * A positive turn is counterclockwise in a frame with the y axis up. The function skips segments shorter than `eps`.
+ */
+export function turns(p: readonly Point[], eps = 1e-9): number[] {
+  const q: Point[] = [];
+  for (const v of p) if (q.length === 0 || dist(q[q.length - 1]!, v) > eps) q.push(v);
+  const out: number[] = [];
+  for (let i = 1; i + 1 < q.length; i++) {
+    const a = q[i - 1]!;
+    const b = q[i]!;
+    const c = q[i + 1]!;
+    const cr = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+    const dt = (b.x - a.x) * (c.x - b.x) + (b.y - a.y) * (c.y - b.y);
+    out.push(Math.atan2(cr, dt));
+  }
+  return out;
+}
+
+/** This function counts the vertices of a polyline where the direction changes by more than `minTurn` radians. */
+export function bendCount(p: readonly Point[], minTurn = 0.05): number {
+  return turns(p).filter((t) => Math.abs(t) > minTurn).length;
+}
+
+/**
+ * This function counts the inflections of a polyline: the changes of the sign of the turn.
+ * A turn smaller than `minTurn` radians does not count. Thus a straight part between two turns keeps their signs.
+ */
+export function inflectionCount(p: readonly Point[], minTurn = 1e-3): number {
+  let n = 0;
+  let last = 0;
+  for (const t of turns(p)) {
+    if (Math.abs(t) <= minTurn) continue;
+    const s = Math.sign(t);
+    if (last !== 0 && s !== last) n++;
+    last = s;
+  }
+  return n;
+}
+
+/**
+ * This function gives the discrete Fréchet distance between two polylines (Eiter and Mannila, 1994).
+ * The cost is O(|p|·|q|) in time and O(|q|) in memory.
+ */
+export function frechet(p: readonly Point[], q: readonly Point[]): number {
+  if (p.length === 0 || q.length === 0) return p.length === q.length ? 0 : Infinity;
+  let prev = new Float64Array(q.length);
+  let cur = new Float64Array(q.length);
+  for (let i = 0; i < p.length; i++) {
+    for (let j = 0; j < q.length; j++) {
+      const d = dist(p[i]!, q[j]!);
+      if (i === 0 && j === 0) cur[j] = d;
+      else if (i === 0) cur[j] = Math.max(cur[j - 1]!, d);
+      else if (j === 0) cur[j] = Math.max(prev[j]!, d);
+      else cur[j] = Math.max(Math.min(prev[j]!, prev[j - 1]!, cur[j - 1]!), d);
+    }
+    [prev, cur] = [cur, prev];
+  }
+  return prev[q.length - 1]!;
+}

package/src/grid.ts

@@ -0,0 +1,116 @@
+import type { Box, Point } from "./geom.ts";
+
+/**
+ * A uniform grid of buckets over the plane. A box item goes into each bucket that the box touches.
+ * A segment item goes only into the buckets along the segment, so a long diagonal segment stays cheap.
+ * A query gives each item in the buckets that it touches, one time each.
+ */
+export class Grid<T> {
+  readonly #cell: number;
+  readonly #buckets = new Map<number, number[]>();
+  readonly #items: T[] = [];
+  readonly #ids = new Map<T, number>();
+  // The stamp of the last query that gave each item, by the index of the item.
+  #seen = new Int32Array(16);
+  #stamp = 0;
+
+  /** This constructor makes an empty grid with square buckets of side `cell`. */
+  constructor(cell: number) {
+    this.#cell = Math.max(1e-9, cell);
+  }
+
+  #key(i: number, j: number): number {
+    // The key packs the two bucket indices into one number. Each index stays within ±2^20.
+    return (i + 1_048_576) * 2_097_152 + (j + 1_048_576);
+  }
+
+  #id(item: T): number {
+    let id = this.#ids.get(item);
+    if (id === undefined) {
+      id = this.#items.length;
+      this.#ids.set(item, id);
+      this.#items.push(item);
+      if (id >= this.#seen.length) {
+        const seen = new Int32Array(this.#seen.length * 2);
+        seen.set(this.#seen);
+        this.#seen = seen;
+      }
+    }
+    return id;
+  }
+
+  #put(id: number, x0: number, y0: number, x1: number, y1: number): void {
+    const c = this.#cell;
+    const i1 = Math.floor(x1 / c);
+    const j1 = Math.floor(y1 / c);
+    for (let i = Math.floor(x0 / c); i <= i1; i++) {
+      for (let j = Math.floor(y0 / c); j <= j1; j++) {
+        const key = this.#key(i, j);
+        const list = this.#buckets.get(key);
+        if (list === undefined) this.#buckets.set(key, [id]);
+        else if (list[list.length - 1] !== id) list.push(id);
+      }
+    }
+  }
+
+  #take(stamp: number, x0: number, y0: number, x1: number, y1: number, visit: (item: T) => void): void {
+    const c = this.#cell;
+    const i1 = Math.floor(x1 / c);
+    const j1 = Math.floor(y1 / c);
+    const seen = this.#seen;
+    for (let i = Math.floor(x0 / c); i <= i1; i++) {
+      for (let j = Math.floor(y0 / c); j <= j1; j++) {
+        const list = this.#buckets.get(this.#key(i, j));
+        if (list === undefined) continue;
+        for (const id of list) {
+          if (seen[id] === stamp) continue;
+          seen[id] = stamp;
+          visit(this.#items[id]!);
+        }
+      }
+    }
+  }
+
+  // The buckets along a segment, widened by `margin`: the boxes of steps of at most half a bucket.
+  #segment(a: Point, b: Point, margin: number, each: (x0: number, y0: number, x1: number, y1: number) => void): void {
+    const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (this.#cell / 2)));
+    let px = a.x;
+    let py = a.y;
+    for (let k = 1; k <= n; k++) {
+      const qx = k === n ? b.x : a.x + ((b.x - a.x) * k) / n;
+      const qy = k === n ? b.y : a.y + ((b.y - a.y) * k) / n;
+      each(Math.min(px, qx) - margin, Math.min(py, qy) - margin, Math.max(px, qx) + margin, Math.max(py, qy) + margin);
+      px = qx;
+      py = qy;
+    }
+  }
+
+  /** This method adds an item with its bounding box. */
+  add(item: T, b: Box): void {
+    this.#put(this.#id(item), b.x, b.y, b.x + b.w, b.y + b.h);
+  }
+
+  /** This method adds the segment `ab` as an item. */
+  addSegment(item: T, a: Point, b: Point): void {
+    const id = this.#id(item);
+    this.#segment(a, b, 0, (x0, y0, x1, y1) => this.#put(id, x0, y0, x1, y1));
+  }
+
+  /** This method gives each item whose buckets touch the box to `visit`, one time each. */
+  query(b: Box, visit: (item: T) => void): void {
+    this.#take(++this.#stamp, b.x, b.y, b.x + b.w, b.y + b.h, visit);
+  }
+
+  /** This method gives each item whose buckets come within `margin` of the segment `ab` to `visit`, one time each. */
+  querySegment(a: Point, b: Point, margin: number, visit: (item: T) => void): void {
+    const stamp = ++this.#stamp;
+    this.#segment(a, b, margin, (x0, y0, x1, y1) => this.#take(stamp, x0, y0, x1, y1, visit));
+  }
+}
+
+/** This function gives the bounding box of the segment `ab`. */
+export function segmentBounds(a: Point, b: Point): Box {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return { x, y, w: Math.abs(a.x - b.x), h: Math.abs(a.y - b.y) };
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from "./geom.ts";
+export { Grid, segmentBounds } from "./grid.ts";
+export * from "./model.ts";
+export * from "./fixtures.ts";
+export * from "./plugs.ts";
+export * from "./curves.ts";
+export * from "./visibility.ts";
+export * from "./ways.ts";
+export * from "./segments.ts";
+export * from "./sections.ts";
+export * from "./routers/index.ts";
+export * from "./bench/properties.ts";
+export * from "./bench/quality.ts";
+export * from "./bench/run.ts";

package/src/model.ts

@@ -0,0 +1,138 @@
+import type { Box, Point } from "./geom.ts";
+
+/** A side of a node box. */
+export type Side = "north" | "east" | "south" | "west";
+
+/**
+ * A plug of a node: a place where edges go into the node.
+ * A plug with `at` is fixed. The router does not move it. A plug without `at` is free: the router places it.
+ */
+export interface Port {
+  readonly id: string;
+  /** This point is the fixed place of the plug, relative to the top-left corner of the node box. */
+  readonly at?: Point;
+  /** This side is where a free plug goes. Without it, the router picks the side. */
+  readonly side?: Side;
+}
+
+/** A node: a box that routes must not go through. */
+export interface Node {
+  readonly id: string;
+  readonly box: Box;
+  readonly ports?: readonly Port[];
+}
+
+/** One end of an edge: a node, and optionally one plug of that node. */
+export interface End {
+  readonly node: string;
+  readonly port?: string;
+}
+
+/** An edge between two nodes. `data` is free for the grouping rules. */
+export interface Edge {
+  readonly id: string;
+  readonly source: End;
+  readonly target: End;
+  readonly data?: Readonly<Record<string, unknown>>;
+}
+
+/** The input of a router. */
+export interface Graph {
+  readonly nodes: readonly Node[];
+  readonly edges: readonly Edge[];
+}
+
+/** The route of one edge: a polyline from the source plug to the target plug, in absolute coordinates. */
+export interface Route {
+  readonly edge: string;
+  readonly points: readonly Point[];
+}
+
+/**
+ * One zoom level of a result. Each shown item is a node or a group of nodes.
+ * Each link joins two shown items and carries the count of the edges that it stands for.
+ */
+export interface Level {
+  readonly depth: number;
+  readonly items: readonly LevelItem[];
+  readonly links: readonly LevelLink[];
+}
+
+/** A shown item of a level: one node, or a group that stands for its nodes. */
+export interface LevelItem {
+  readonly id: string;
+  readonly box: Box;
+  readonly nodes: readonly string[];
+}
+
+/** A link of a level: the edges between two shown items, drawn as one path. */
+export interface LevelLink {
+  readonly source: string;
+  readonly target: string;
+  readonly count: number;
+  readonly points: readonly Point[];
+}
+
+/** The output of a router. `levels` is present when the router makes zoom levels. */
+export interface Result {
+  readonly routes: readonly Route[];
+  readonly levels?: readonly Level[];
+  readonly bundles?: readonly Bundle[];
+  /** The stretches of way that several routes share, if the router gives them. */
+  readonly runs?: readonly SharedRun[];
+}
+
+/**
+ * A bundle: edges from one node that share one plug and one trunk. Then the edges fan out to their targets.
+ * A renderer draws a bundle as one fat edge with a count, or as one lane for each edge.
+ */
+export interface Bundle {
+  readonly id: string;
+  /** The key that the grouping rule gave each edge of the bundle. */
+  readonly key: string;
+  /** The node where the edges share their plug. */
+  readonly node: string;
+  /** The edges in lane order. Lane 0 turns most to the left of the trunk, in a frame with the y axis down. */
+  readonly edges: readonly string[];
+  /** The shared start of each route of the bundle, from the plug to the split point. */
+  readonly trunk: readonly Point[];
+}
+
+/**
+ * A stretch of way that several routes share, with the same points. Each route of `edges` has `points` in it,
+ * in this order or in the reverse order. A renderer draws a run as one fat line, or as one lane for each edge.
+ */
+export interface SharedRun {
+  readonly id: string;
+  /** The key of the grouping rule of the edges. */
+  readonly key: string;
+  readonly points: readonly Point[];
+  /** The edges in lane order. Lane 0 is on the left of the run, from its first point to its last. The y axis points down. */
+  readonly edges: readonly string[];
+}
+
+/** A grouping rule gives each edge a key. The edges from one plug with one key make a bundle. An edge without a key stays alone. */
+export type GroupRule = (edge: Edge) => string | undefined;
+
+/** A router: a strategy with a name. The same input must give the same result. */
+export interface Router {
+  readonly name: string;
+  /** The benchmark skips a fixture with more nodes than this. Without it, the router takes each fixture. */
+  readonly maxNodes?: number;
+  route(graph: Graph): Result;
+}
+
+/** This function gives a map from the id of each node to the node. */
+export function nodeIndex(g: Graph): Map<string, Node> {
+  const m = new Map<string, Node>();
+  for (const n of g.nodes) m.set(n.id, n);
+  return m;
+}
+
+/** This function gives the absolute place of a fixed plug, or `undefined` for a free plug or no plug. */
+export function fixedPortPoint(node: Node, end: End): Point | undefined {
+  if (end.port === undefined) return undefined;
+  const p = node.ports?.find((q) => q.id === end.port);
+  if (p?.at === undefined) return undefined;
+  return { x: node.box.x + p.at.x, y: node.box.y + p.at.y };
+}

package/src/plugs.ts

@@ -0,0 +1,75 @@
+import { center, type Box, type Point } from "./geom.ts";
+import { fixedPortPoint, type End, type Node, type Side } from "./model.ts";
+
+/** A plug: the point where a route leaves or enters a node, and the outward normal of its side. */
+export interface Plug {
+  readonly point: Point;
+  readonly normal: Point;
+}
+
+/** The outward normal of each side, in a frame with the y axis down. */
+export const SIDE_NORMAL: Readonly<Record<Side, Point>> = {
+  north: { x: 0, y: -1 },
+  east: { x: 1, y: 0 },
+  south: { x: 0, y: 1 },
+  west: { x: -1, y: 0 },
+};
+
+/** This function gives the side of the box that is nearest to the point. */
+export function nearestSide(box: Box, p: Point): Side {
+  const d: [Side, number][] = [
+    ["north", Math.abs(p.y - box.y)],
+    ["east", Math.abs(box.x + box.w - p.x)],
+    ["south", Math.abs(box.y + box.h - p.y)],
+    ["west", Math.abs(p.x - box.x)],
+  ];
+  let best = d[0]!;
+  for (const x of d) if (x[1] < best[1]) best = x;
+  return best[0];
+}
+
+/**
+ * This function gives the side that faces `toward`: the side of the larger component of the direction from the center.
+ * Thus the angle between the normal of the side and that direction is 45° or less.
+ */
+export function sideToward(box: Box, toward: Point): Side {
+  const c = center(box);
+  const dx = toward.x - c.x;
+  const dy = toward.y - c.y;
+  if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "east" : "west";
+  return dy >= 0 ? "south" : "north";
+}
+
+/**
+ * This function gives the point on a side of the box that is nearest to the line from the center to `toward`.
+ * The point stays away from the corners by `inset`, or by a quarter of the side when the side is short.
+ */
+export function pointOnSide(box: Box, side: Side, toward: Point, inset = 6): Point {
+  const c = center(box);
+  const dx = toward.x - c.x;
+  const dy = toward.y - c.y;
+  const clamp = (v: number, lo: number, len: number): number => {
+    const m = Math.min(inset, len / 4);
+    return Math.max(lo + m, Math.min(lo + len - m, v));
+  };
+  if (side === "east" || side === "west") {
+    const x = side === "east" ? box.x + box.w : box.x;
+    const y = dx === 0 ? c.y : c.y + (dy * (x - c.x)) / dx;
+    return { x, y: clamp(y, box.y, box.h) };
+  }
+  const y = side === "south" ? box.y + box.h : box.y;
+  const x = dy === 0 ? c.x : c.x + (dx * (y - c.y)) / dy;
+  return { x: clamp(x, box.x, box.w), y };
+}
+
+/**
+ * This function places the plug of one end of an edge. A fixed plug stays at its point. A plug with a side stays on that side.
+ * The router places a free plug on the side that faces `toward`.
+ */
+export function placePlug(node: Node, end: End, toward: Point): Plug {
+  const fixed = fixedPortPoint(node, end);
+  const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+  if (fixed) return { point: fixed, normal: SIDE_NORMAL[port?.side ?? nearestSide(node.box, fixed)] };
+  const side = port?.side ?? sideToward(node.box, toward);
+  return { point: pointOnSide(node.box, side, toward), normal: SIDE_NORMAL[side] };
+}

package/src/routers/corners.ts

@@ -0,0 +1,38 @@
+import { center } from "../geom.ts";
+import { nodeIndex, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { placePlug } from "../plugs.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/** The options of the corner router. */
+export interface CornersOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+
+/**
+ * This function makes a router that goes around the nodes.
+ * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
+ * of the box corners, without the needless corners. It enters the target plug along its normal.
+ */
+export function cornersRouter(options: CornersOptions): Router {
+  const router: Router = {
+    name: options.name,
+    route(graph: Graph): Result {
+      const byId = nodeIndex(graph);
+      const ways = new WayFinder(graph.nodes, options);
+      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 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 };
+    },
+  };
+  return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
+}

package/src/routers/index.ts

@@ -0,0 +1,27 @@
+import type { Router } from "../model.ts";
+import { cornersRouter } from "./corners.ts";
+import { plugsRouter } from "./plugs.ts";
+import { sectionsRouter } from "./sections.ts";
+import { sharedRouter } from "./shared.ts";
+import { straightRouter } from "./straight.ts";
+import { byCollection, trunksRouter } from "./trunks.ts";
+
+export { boxExit, straightRouter } from "./straight.ts";
+export { plugsRouter } from "./plugs.ts";
+export { cornersRouter, type CornersOptions } from "./corners.ts";
+export { sharedRouter, type SharedOptions } from "./shared.ts";
+export { sectionsRouter, type SectionsOptions } from "./sections.ts";
+export { byCollection, groupEdges, laneOrder, splitPoint, trunksRouter, type TrunksOptions } from "./trunks.ts";
+
+/** The routers that the benchmark races. */
+export const ROUTERS: readonly Router[] = [
+  straightRouter,
+  plugsRouter,
+  cornersRouter({ name: "corners", maxNodes: 10_000 }),
+  cornersRouter({ name: "corners-smooth", smooth: true, maxNodes: 10_000 }),
+  trunksRouter({ name: "trunks", rule: byCollection, maxNodes: 10_000 }),
+  sharedRouter({ name: "shared", rule: byCollection, maxNodes: 10_000 }),
+  sharedRouter({ name: "shared-all", maxNodes: 10_000 }),
+  sectionsRouter({ name: "sections", maxNodes: 100_000 }),
+  sectionsRouter({ name: "sections-tree", stretch: Infinity, maxNodes: 100_000 }),
+];

package/src/routers/plugs.ts

@@ -0,0 +1,25 @@
+import { inflectionCurve } from "../curves.ts";
+import { center } from "../geom.ts";
+import { nodeIndex, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { placePlug } from "../plugs.ts";
+
+/**
+ * Plugs and the inflection rule, with no obstacles. Each edge leaves its source plug at the tangent of the side.
+ * It goes to the target plug on the curve of the rule. This router measures the rule alone.
+ */
+export const plugsRouter: Router = {
+  name: "plugs",
+  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 ps = placePlug(s, e.source, center(t.box));
+      const pt = placePlug(t, e.target, center(s.box));
+      routes.push({ edge: e.id, points: inflectionCurve(ps.point, ps.normal, pt.point) });
+    }
+    return { routes };
+  },
+};