@mark1russell7/highways 0.4.2 → 0.5.0

package/src/highways/soft-keys/index.ts

@@ -0,0 +1,114 @@
+import type { GroupRule } from "../../model.ts";
+import { byCollection } from "../../routers/trunks.ts";
+import { chainClusters, flowDistance, type Linkage } from "../flow-clusters/index.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `soft-keys` (HWY-019 of the note on highways). */
+export interface SoftKeyOptions {
+  /** The rule that gives the key of each edge. The default is `byCollection`: the string `data.collection`. */
+  readonly rule: GroupRule;
+  /** The distance that two different keys add. `Infinity` keeps the edges of two keys apart, as the hard keys do. The default is 0.25. */
+  readonly lambda: number;
+  /** Two clusters join while their distance is this value or less. The default is 0.5. */
+  readonly tau: number;
+  /** The names of number fields of `data` that add a distance. The default is no field. */
+  readonly attributes: readonly string[];
+  /** The weight of each field of `attributes`. The distance of a field is its difference over its range. The default is 1. */
+  readonly weight: number;
+  /** The linkage of the clustering. The default is `average`. */
+  readonly linkage: Linkage;
+  /** 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`: the router `shared` with the cluster as the key. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `soft-keys`. */
+export const SOFT_KEY_DEFAULTS: Readonly<SoftKeyOptions> = Object.freeze({
+  rule: byCollection,
+  lambda: 0.25,
+  tau: 0.5,
+  attributes: Object.freeze([]) as readonly string[],
+  weight: 1,
+  linkage: "average",
+  minSize: 2,
+  spine: "shared",
+});
+
+/** The largest number of edges in one distance matrix. A larger graph splits into blocks of edges in the order of their sources. */
+const BLOCK = 2500;
+
+/**
+ * This function gives the soft-key distance of two edges (Peysakhovich, Hurter and Telea 2015): `d = d_geom + lambda [key(e) != key(f)] + sum_a w |a(e) - a(f)| / range(a)`.
+ * `d_geom` is the flow distance of HWY-023. The key term is 0 when an edge has no key.
+ */
+export function softDistance(geom: number, keyA: string | undefined, keyB: string | undefined, lambda: number, attributes: number): number {
+  const key = keyA !== undefined && keyB !== undefined && keyA !== keyB ? lambda : 0;
+  return geom + key + attributes;
+}
+
+/**
+ * This function gives the soft-key clusters of the edges (HWY-019). It clusters the edges with `softDistance`, with the cut at `tau`.
+ * Each edge of a cluster gets the key of the cluster. It gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export function softKeyClusters(input: HighwayInput, o: Readonly<SoftKeyOptions>): Map<string, EdgeGroup> {
+  const ends = edgePlugs(input.graph).map(({ edge, ps, pt }) => ({
+    edge: edge.id,
+    s: ps.point,
+    t: pt.point,
+    key: o.rule(edge),
+    values: o.attributes.map((a) => {
+      const v = edge.data?.[a];
+      return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+    }),
+  }));
+  // The range of each field, so that each field adds a distance from 0 to `weight`.
+  const ranges = o.attributes.map((_, ai) => {
+    const values = ends.map((e) => e.values[ai]).filter((v): v is number => v !== undefined);
+    return values.length > 1 ? Math.max(...values) - Math.min(...values) : 0;
+  });
+  const extra = (a: (typeof ends)[number], b: (typeof ends)[number]): number => {
+    let sum = 0;
+    ranges.forEach((range, ai) => {
+      const va = a.values[ai];
+      const vb = b.values[ai];
+      if (range > 0 && va !== undefined && vb !== undefined) sum += (o.weight * Math.abs(va - vb)) / range;
+    });
+    return sum;
+  };
+  const groups = new Map<string, EdgeGroup>();
+  const order = ends.length > BLOCK ? [...ends].sort((a, b) => a.s.x - b.s.x || a.s.y - b.s.y || (a.edge < b.edge ? -1 : 1)) : ends;
+  for (let from = 0; from < order.length; from += BLOCK) {
+    const block = order.slice(from, from + BLOCK);
+    const n = block.length;
+    const d = new Float64Array(n * n);
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++) {
+        const a = block[i]!;
+        const b = block[j]!;
+        const v = softDistance(flowDistance(a.s, a.t, b.s, b.t, false).d, a.key, b.key, o.lambda, extra(a, b));
+        d[i * n + j] = v;
+        d[j * n + i] = v;
+      }
+    const cluster = chainClusters(n, d, o.tau, o.linkage);
+    const first = new Map<number, number>();
+    block.forEach((e, i) => {
+      const c = cluster[i]!;
+      if (!first.has(c)) first.set(c, i);
+      const lead = block[first.get(c)!]!;
+      const flip = i === first.get(c) ? false : flowDistance(lead.s, lead.t, e.s, e.t, false).flip;
+      groups.set(e.edge, { key: `k${from + first.get(c)!}`, flip });
+    });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of the soft keys (HWY-019). The key of an edge is one more term of the distance, not a hard split.
+ * Edges of two keys still share a highway when they are very near, and edges of one key do not bundle when they are far.
+ */
+export function softKeyPlan(input: HighwayInput, o: Readonly<SoftKeyOptions>): HighwayPlan {
+  return groupedPlan(input, softKeyClusters(input, o), { spine: o.spine, minSize: o.minSize });
+}

package/src/highways/spiral/index.ts

@@ -0,0 +1,205 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { nodeIndex, type Node } from "../../model.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { tidyPlan } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The options of the highway strategy `spiral` (HWY-017 with EDA-035 of the notes). */
+export interface SpiralOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The spiral angle, in degrees: the largest angle between a branch and the line to the root. The default is 25. */
+  readonly alpha: number;
+  /** A node with this number of edges or more gets a spiral tree. The default is 4. */
+  readonly minTargets: number;
+  /** The number of points of the arc of each branch. The default is 4. */
+  readonly arc: number;
+}
+
+/** The default options of the strategy `spiral`. */
+export const SPIRAL_DEFAULTS: Readonly<Required<Omit<SpiralOptions, "margin" | "k">>> = Object.freeze({ alpha: 25, minTargets: 4, arc: 4 });
+
+/** One node of a spiral tree, in polar coordinates around the root. A leaf has an edge, and a join has two children. */
+export interface SpiralNode {
+  readonly r: number;
+  readonly theta: number;
+  readonly point: Point;
+  /** A join with this node is this distance or more nearer to the root than the node. A leaf keeps its box clear so. A join has 0. */
+  readonly clear: number;
+  readonly edge?: string;
+  readonly children: readonly SpiralNode[];
+}
+
+const TAU = 2 * Math.PI;
+
+/** This function gives the angle `t` in the range from 0 to 2 pi. */
+const wrap = (t: number): number => ((t % TAU) + TAU) % TAU;
+
+/**
+ * This function gives the join of the nodes `p` and `q` of a spiral tree with the angle `alpha`. It gives `undefined` when no join is possible.
+ * Each node can reach the points inside its two spirals toward the root: `|theta - theta_p| <= tan(alpha) ln(r_p / r)`.
+ * The join is the point farthest from the root that both nodes reach, and that is `clear` nearer to the root than each node.
+ * At that radius, the join is at the middle of the angles that both nodes reach.
+ */
+export function spiralJoin(p: SpiralNode, q: SpiralNode, alpha: number, root: Point): { r: number; theta: number; point: Point } | undefined {
+  const t = Math.tan(alpha);
+  // The angle from p to q, counterclockwise, in the range from -pi to pi.
+  let delta = wrap(q.theta - p.theta);
+  if (delta > Math.PI) delta -= TAU;
+  const gap = Math.abs(delta);
+  if (gap >= Math.PI || t <= 0) return undefined;
+  const near = p.r <= q.r ? p : q;
+  const far = p.r <= q.r ? q : p;
+  const meet = t * Math.log(far.r / near.r) >= gap ? near.r : Math.exp((Math.log(p.r) + Math.log(q.r) - gap / t) / 2);
+  const r = Math.min(meet, p.r - p.clear, q.r - q.clear);
+  if (!(r > 0)) return undefined;
+  // In the frame where p is at 0 and q is at `gap`, p reaches [-rp, rp] and q reaches [gap - rq, gap + rq].
+  const rp = t * Math.log(p.r / r);
+  const rq = t * Math.log(q.r / r);
+  const lo = Math.max(-rp, gap - rq);
+  const hi = Math.min(rp, gap + rq);
+  if (lo > hi + 1e-9) return undefined;
+  const theta = wrap(p.theta + Math.sign(delta) * ((lo + hi) / 2));
+  return { r, theta, point: { x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) } };
+}
+
+/**
+ * This function gives the spiral tree of the leaves around the root (Buchin, Speckmann and Verbeek 2011), with the greedy sweep.
+ * The sweep goes from the far leaves to the root. A leaf joins the wavefront at its radius. Two nodes that are next to each other in angle join at their join point.
+ * The join with the largest radius goes first. No join occurs below the radius `rMin`. The function gives the nodes of the wavefront at the end.
+ */
+export function spiralTree(leaves: readonly SpiralNode[], alpha: number, root: Point, rMin: number): SpiralNode[] {
+  const waiting = [...leaves].sort((a, b) => b.r - a.r || (a.edge! < b.edge! ? -1 : 1));
+  const front: SpiralNode[] = [];
+  const insert = (n: SpiralNode): void => {
+    let i = 0;
+    while (i < front.length && front[i]!.theta <= n.theta) i++;
+    front.splice(i, 0, n);
+  };
+  for (;;) {
+    let best: { i: number; r: number; theta: number; point: Point } | undefined;
+    if (front.length >= 2)
+      for (let i = 0; i < front.length; i++) {
+        if (front.length === 2 && i === 1) break;
+        const j = (i + 1) % front.length;
+        const join = spiralJoin(front[i]!, front[j]!, alpha, root);
+        if (join && join.r >= rMin && (!best || join.r > best.r)) best = { i, ...join };
+      }
+    const next = waiting[0];
+    if (next && (!best || next.r >= best.r)) {
+      insert(waiting.shift()!);
+      continue;
+    }
+    if (!best) return front;
+    const i = best.i;
+    const j = (i + 1) % front.length;
+    const node: SpiralNode = { r: best.r, theta: best.theta, point: best.point, clear: 0, children: [front[i]!, front[j]!] };
+    for (const k of [i, j].sort((a, b) => b - a)) front.splice(k, 1);
+    insert(node);
+  }
+}
+
+/** This function gives the leaves under a node of a spiral tree, in the order of the tree. */
+function leavesOf(n: SpiralNode): string[] {
+  return n.edge !== undefined ? [n.edge] : n.children.flatMap(leavesOf);
+}
+
+/**
+ * This function gives the highways of the spiral trees (HWY-017, EDA-035). Each node with `minTargets` edges or more is the root of a fan.
+ * The nodes with more edges go first, and each edge is in one fan at most. The far plug of each edge is a leaf of the tree of its fan.
+ * Each branch of a tree with two leaves or more is a highway. Its spine is an arc of a logarithmic spiral, or a way through the corner graph where the arc hits a box.
+ * An edge rides the branches from the root to its leaf, or from its leaf to the root when the root is its target.
+ */
+export function spiralPlan(input: HighwayInput, o: Readonly<SpiralOptions>): HighwayPlan {
+  const graph = input.graph;
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const pad = finder.margin / 2;
+  const byId = nodeIndex(graph);
+  const plugs = edgePlugs(graph);
+  const degree = new Map<string, number>();
+  for (const { edge } of plugs) {
+    if (edge.source.node === edge.target.node) continue;
+    for (const n of [edge.source.node, edge.target.node]) degree.set(n, (degree.get(n) ?? 0) + 1);
+  }
+  const hubs = [...degree].filter(([, d]) => d >= o.minTargets).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+  const alpha = (Math.max(1, Math.min(80, o.alpha)) * Math.PI) / 180;
+  const arcPoints = Math.max(2, Math.round(o.arc));
+  const used = new Set<string>();
+  const highways: Highway[] = [];
+
+  /** This function gives the spine from the point `a` to the point `b`. The spine is a spiral arc in free space, or a way through the corner graph. */
+  const spineOf = (root: Point, a: { r: number; theta: number; point: Point }, b: { r: number; theta: number; point: Point }): Point[] | undefined => {
+    if (finder.obstacles.inside(a.point, pad) || finder.obstacles.inside(b.point, pad)) return undefined;
+    let dt = wrap(b.theta - a.theta);
+    if (dt > Math.PI) dt -= TAU;
+    const arc: Point[] = [a.point];
+    for (let s = 1; s < arcPoints - 1; s++) {
+      const u = s / (arcPoints - 1);
+      const r = a.r * Math.pow(b.r / a.r, u);
+      const theta = a.theta + dt * u;
+      arc.push({ x: root.x + r * Math.cos(theta), y: root.y + r * Math.sin(theta) });
+    }
+    arc.push(b.point);
+    if (finder.obstacles.clearPath(arc, pad)) return arc;
+    const way = finder.corners.path(a.point, b.point);
+    return way ? finder.corners.pull(way) : undefined;
+  };
+
+  for (const [hubId] of hubs) {
+    const hub: Node | undefined = byId.get(hubId);
+    if (!hub) continue;
+    const root = center(hub.box);
+    const rMin = Math.hypot(hub.box.w, hub.box.h) / 2 + 2 * finder.margin;
+    const fan = plugs.filter(({ edge }) => !used.has(edge.id) && edge.source.node !== edge.target.node && (edge.source.node === hubId || edge.target.node === hubId));
+    if (fan.length < o.minTargets) continue;
+    const out = new Map<string, boolean>();
+    const near = new Map<string, Point>();
+    const far = new Map<string, Point>();
+    const leaves: SpiralNode[] = fan.map(({ edge, ps, pt }) => {
+      const outward = edge.source.node === hubId;
+      out.set(edge.id, outward);
+      near.set(edge.id, outward ? ps.point : pt.point);
+      const p = outward ? pt.point : ps.point;
+      far.set(edge.id, p);
+      const box = byId.get(outward ? edge.target.node : edge.source.node)!.box;
+      const clear = Math.hypot(box.w, box.h) / 2 + finder.margin;
+      return { r: Math.max(1e-6, dist(root, p)), theta: wrap(Math.atan2(p.y - root.y, p.x - root.x)), point: p, clear, edge: edge.id, children: [] };
+    });
+    for (const { edge } of fan) used.add(edge.id);
+    const tops = spiralTree(leaves, alpha, root, rMin);
+    // The branches: each link from a node to a child with two leaves or more, from the root down.
+    interface Branch {
+      readonly spine: Point[];
+      readonly edges: string[];
+      readonly depth: number;
+    }
+    const branches: Branch[] = [];
+    const walk = (parent: { r: number; theta: number; point: Point }, child: SpiralNode, depth: number): void => {
+      if (child.edge !== undefined) return;
+      const spine = dist(parent.point, child.point) > finder.margin ? spineOf(root, parent, child) : undefined;
+      if (spine && spine.length >= 2) branches.push({ spine, edges: leavesOf(child), depth });
+      for (const c of child.children) if (dist(c.point, child.point) > 1e-9) walk(child, c, depth + 1);
+      // A child at the point of the join (the nearer node of a join) goes on from the same point.
+      for (const c of child.children) if (dist(c.point, child.point) <= 1e-9) for (const g of c.children) walk(child, g, depth + 1);
+    };
+    for (const top of tops) {
+      if (top.edge !== undefined) continue;
+      // The trunk from the hub: it starts at the radius `rMin` on the line to the top node.
+      const start = { r: rMin, theta: top.theta, point: { x: root.x + rMin * Math.cos(top.theta), y: root.y + rMin * Math.sin(top.theta) } };
+      walk(top.r > rMin + finder.margin ? start : top, top, 0);
+    }
+    for (const b of branches) {
+      if (b.edges.length < 2) continue;
+      const last = b.spine.length - 1;
+      const tripOf = (edge: string): Point[] => [near.get(edge)!, ...b.spine, far.get(edge)!];
+      const lanes = orderLanes(
+        b.spine,
+        b.edges.map((edge) => ({ edge, points: tripOf(edge) })),
+        "bundle",
+      );
+      const members: HighwayMember[] = lanes.map((edge) => (out.get(edge) ? memberAt(b.spine, edge, 0, last, b.depth) : memberAt(b.spine, edge, last, 0, -b.depth)));
+      highways.push({ id: `h${highways.length}`, key: `spiral:${hubId}`, spine: b.spine, lanes, members });
+    }
+  }
+  return tidyPlan({ highways });
+}

package/src/highways/traclus/index.ts

@@ -0,0 +1,296 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, pointSegmentDistance, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { firstRoutes, nearestPlace, orderAlongRoutes, tidyPlan } from "../base.ts";
+import { lengthBetween, memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `traclus` (HWY-025 of the note on highways). */
+export interface TraclusOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two segments are neighbours when their distance is this value or less, in units of the board. The default is 2. */
+  readonly eps: number;
+  /** A cluster has segments of this number of edges or more, and a core segment has this number of neighbours or more. The default is 3. */
+  readonly minLns: number;
+  /** The weight of the perpendicular distance. The default is 1. */
+  readonly wPerp: number;
+  /** The weight of the parallel distance. The default is 1. */
+  readonly wPar: number;
+  /** The weight of the angle distance. The default is 1. */
+  readonly wTheta: number;
+  /** A route keeps a corner when the cost of the line without it is more than this value times the cost with it. The default is 1. */
+  readonly mdl: number;
+}
+
+/** The default options of the strategy `traclus`. */
+export const TRACLUS_DEFAULTS: Readonly<Required<Omit<TraclusOptions, "margin" | "k">>> = Object.freeze({ eps: 2, minLns: 3, wPerp: 1, wPar: 1, wTheta: 1, mdl: 1 });
+
+/** One segment of a partitioned route: the edge, the index of the segment in the route, and its two ends. */
+export interface RouteSegment {
+  readonly edge: string;
+  readonly index: number;
+  readonly a: Point;
+  readonly b: Point;
+}
+
+/** This function gives the distance of the point `p` to the line through `a` and `b`. It also gives the place of its projection as a share of `ab`. */
+function project(p: Point, a: Point, b: Point): { perp: number; u: number } {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-12) return { perp: dist(p, a), u: 0 };
+  const u = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  return { perp: Math.abs((p.x - a.x) * dy - (p.y - a.y) * dx) / Math.sqrt(len2), u };
+}
+
+/**
+ * This function gives the TRACLUS distance of two segments (Lee, Han and Whang 2007): `w_perp d_perp + w_par d_par + w_theta d_theta`.
+ * `d_perp` is `(l1² + l2²) / (l1 + l2)` with the distances of the ends of the shorter segment to the line of the longer segment.
+ * `d_par` is the gap along the longer segment between the two segments, 0 when they overlap. `d_theta` is `|shorter| sin(theta)`.
+ * The segments have no direction, so the angle is 90 degrees or less.
+ */
+export function segmentDistance(p: { a: Point; b: Point }, q: { a: Point; b: Point }, w: { perp: number; par: number; theta: number }): number {
+  const [long, short] = dist(p.a, p.b) >= dist(q.a, q.b) ? [p, q] : [q, p];
+  const len = dist(long.a, long.b);
+  const s = project(short.a, long.a, long.b);
+  const e = project(short.b, long.a, long.b);
+  const perp = s.perp + e.perp > 1e-12 ? (s.perp * s.perp + e.perp * e.perp) / (s.perp + e.perp) : 0;
+  const lo = Math.min(s.u, e.u);
+  const hi = Math.max(s.u, e.u);
+  const par = (hi < 0 ? -hi : lo > 1 ? lo - 1 : 0) * len;
+  const shortLen = dist(short.a, short.b);
+  let theta = 0;
+  if (len > 1e-12 && shortLen > 1e-12) {
+    const cos = Math.abs(((long.b.x - long.a.x) * (short.b.x - short.a.x) + (long.b.y - long.a.y) * (short.b.y - short.a.y)) / (len * shortLen));
+    theta = shortLen * Math.sqrt(Math.max(0, 1 - cos * cos));
+  }
+  return w.perp * perp + w.par * par + w.theta * theta;
+}
+
+/**
+ * This function gives the characteristic points of a route by the rule of the minimum description length (MDL) of TRACLUS.
+ * A partition from point `i` to point `j` costs `L(H) + L(D|H)`. `L(H)` is the log of its length, and `L(D|H)` the logs of the perpendicular and angle distances of the route parts.
+ * The route keeps the point before `j` when that cost is more than `ratio` times the cost of the route parts. The lengths are in units of the board.
+ */
+export function characteristicPoints(route: readonly Point[], unit: number, ratio: number): Point[] {
+  const n = route.length;
+  if (n <= 2) return [...route];
+  const lg = (x: number): number => Math.log2(1 + x / unit);
+  const costs = (i: number, j: number): { par: number; nopar: number } => {
+    const a = route[i]!;
+    const b = route[j]!;
+    let perp = 0;
+    let theta = 0;
+    let nopar = 0;
+    for (let k = i; k < j; k++) {
+      const part = { a: route[k]!, b: route[k + 1]! };
+      perp += segmentDistance({ a, b }, part, { perp: 1, par: 0, theta: 0 });
+      theta += segmentDistance({ a, b }, part, { perp: 0, par: 0, theta: 1 });
+      nopar += lg(dist(part.a, part.b));
+    }
+    return { par: lg(dist(a, b)) + lg(perp) + lg(theta), nopar };
+  };
+  const out: Point[] = [route[0]!];
+  let start = 0;
+  let length = 1;
+  while (start + length < n) {
+    const curr = start + length;
+    const c = costs(start, curr);
+    if (c.par > ratio * c.nopar && curr - 1 > start) {
+      out.push(route[curr - 1]!);
+      start = curr - 1;
+      length = 1;
+    } else length++;
+  }
+  out.push(route[n - 1]!);
+  return out;
+}
+
+/**
+ * This function gives the clusters of segments of DBSCAN. A segment with `minLns` neighbours or more within `eps` (itself included) is a core segment.
+ * A cluster grows from each core segment through its neighbours. A cluster with segments of fewer than `minLns` edges is dropped.
+ */
+export function segmentClusters(segments: readonly RouteSegment[], eps: number, minLns: number, w: { perp: number; par: number; theta: number }): RouteSegment[][] {
+  const n = segments.length;
+  // A grid of cells of side `eps` prunes the pairs. Two segments within `eps` have boxes within `eps` of each other in each axis.
+  const near: number[][] = segments.map(() => []);
+  const box = segments.map((s) => ({ x0: Math.min(s.a.x, s.b.x), y0: Math.min(s.a.y, s.b.y), x1: Math.max(s.a.x, s.b.x), y1: Math.max(s.a.y, s.b.y) }));
+  for (let i = 0; i < n; i++) {
+    near[i]!.push(i);
+    for (let j = i + 1; j < n; j++) {
+      const a = box[i]!;
+      const b = box[j]!;
+      if (a.x0 > b.x1 + eps || b.x0 > a.x1 + eps || a.y0 > b.y1 + eps || b.y0 > a.y1 + eps) continue;
+      if (segmentDistance(segments[i]!, segments[j]!, w) <= eps) {
+        near[i]!.push(j);
+        near[j]!.push(i);
+      }
+    }
+  }
+  const label = new Int32Array(n).fill(-1);
+  const out: RouteSegment[][] = [];
+  for (let i = 0; i < n; i++) {
+    if (label[i] !== -1 || near[i]!.length < minLns) continue;
+    const id = out.length;
+    const members: number[] = [];
+    const queue = [i];
+    label[i] = id;
+    while (queue.length > 0) {
+      const k = queue.shift()!;
+      members.push(k);
+      if (near[k]!.length < minLns) continue;
+      for (const j of near[k]!) {
+        if (label[j] !== -1) continue;
+        label[j] = id;
+        queue.push(j);
+      }
+    }
+    out.push(members.sort((a, b) => a - b).map((k) => segments[k]!));
+  }
+  return out.filter((c) => new Set(c.map((s) => s.edge)).size >= minLns);
+}
+
+/**
+ * This function gives the representative line of a cluster of segments. The line goes along the mean direction of the segments.
+ * A sweep along that direction stops at each end of a segment. Where `minLns` segments or more cover the stop, the point is the mean of their points there.
+ * Two points of the line are at least `gap` apart.
+ */
+export function representative(cluster: readonly RouteSegment[], minLns: number, gap: number): Point[] {
+  const first = cluster[0]!;
+  const fx = first.b.x - first.a.x;
+  const fy = first.b.y - first.a.y;
+  let vx = 0;
+  let vy = 0;
+  for (const s of cluster) {
+    let dx = s.b.x - s.a.x;
+    let dy = s.b.y - s.a.y;
+    const len = Math.hypot(dx, dy);
+    if (len < 1e-9) continue;
+    if (dx * fx + dy * fy < 0) [dx, dy] = [-dx, -dy];
+    vx += dx / len;
+    vy += dy / len;
+  }
+  const vl = Math.hypot(vx, vy);
+  if (vl < 1e-9) return [];
+  const ux = vx / vl;
+  const uy = vy / vl;
+  const along = (p: Point): number => p.x * ux + p.y * uy;
+  const across = (p: Point): number => -p.x * uy + p.y * ux;
+  const spans = cluster.map((s) => {
+    const [p, q] = along(s.a) <= along(s.b) ? [s.a, s.b] : [s.b, s.a];
+    return { x0: along(p), y0: across(p), x1: along(q), y1: across(q) };
+  });
+  const stops = [...new Set(spans.flatMap((s) => [s.x0, s.x1]))].sort((a, b) => a - b);
+  const out: Point[] = [];
+  let lastX = -Infinity;
+  for (const x of stops) {
+    const cover = spans.filter((s) => s.x0 <= x + 1e-9 && s.x1 >= x - 1e-9);
+    if (cover.length < minLns) continue;
+    if (x - lastX < gap) continue;
+    let y = 0;
+    for (const s of cover) y += s.x1 - s.x0 > 1e-9 ? s.y0 + ((s.y1 - s.y0) * (x - s.x0)) / (s.x1 - s.x0) : (s.y0 + s.y1) / 2;
+    y /= cover.length;
+    out.push({ x: x * ux - y * uy, y: x * uy + y * ux });
+    lastX = x;
+  }
+  return out;
+}
+
+/** This function gives the distance of the point `p` to the polyline `line`. */
+function lineDistance(line: readonly Point[], p: Point): number {
+  let best = Infinity;
+  for (let i = 1; i < line.length; i++) best = Math.min(best, pointSegmentDistance(p, line[i - 1]!, line[i]!));
+  return best;
+}
+
+/** The largest ratio of the length along the spine of a member to the length of its own route between the same ends. */
+const DETOUR = 1.25;
+
+/**
+ * This function gives the highways of TRACLUS (HWY-025). Each first route breaks into a few long segments by the rule of MDL.
+ * DBSCAN puts the segments that are near in distance and angle into clusters. Each cluster with segments of `minLns` edges or more is one highway.
+ * The spine is the representative line of the cluster, or a way through the corner graph between its ends when the line hits a box.
+ * Each edge of the cluster joins the spine nearest to the first end of its segments. It leaves the spine nearest to the last end.
+ * An edge rides only when both ends of its part are within `eps` of the spine.
+ * Its length on the spine is also at most 1.25 times the length of its own route there.
+ * Each edge rides one highway at most: the highway where it rides the longest length.
+ */
+export function traclusPlan(input: HighwayInput, o: Readonly<TraclusOptions>): HighwayPlan {
+  const graph = input.graph;
+  const unit = boardUnit(graph);
+  const finder = new WayFinder(graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const pad = finder.margin / 2;
+  const routes = firstRoutes(input);
+  const segments: RouteSegment[] = [];
+  const corners = new Map<string, Point[]>();
+  for (const e of graph.edges) {
+    const route = routes.get(e.id);
+    if (!route || route.length < 2) continue;
+    const cps = characteristicPoints(route, unit, o.mdl);
+    corners.set(e.id, cps);
+    for (let i = 1; i < cps.length; i++) if (dist(cps[i - 1]!, cps[i]!) > 1e-9) segments.push({ edge: e.id, index: i - 1, a: cps[i - 1]!, b: cps[i]! });
+  }
+  const minLns = Math.max(2, Math.round(o.minLns));
+  const w = { perp: o.wPerp, par: o.wPar, theta: o.wTheta };
+  const eps = o.eps * unit;
+  const clusters = segmentClusters(segments, eps, minLns, w);
+  type Placed = { edge: string; on: number; off: number; ride: number };
+  const found: { spine: Point[]; placed: Placed[] }[] = [];
+  for (const cluster of clusters) {
+    const line = representative(cluster, minLns, finder.margin);
+    if (line.length < 2 || polylineLength(line) <= finder.margin) continue;
+    let spine: Point[] | undefined = line;
+    if (!finder.obstacles.clearPath(line, pad) || line.some((p) => finder.obstacles.inside(p, pad))) {
+      const a = line[0]!;
+      const b = line[line.length - 1]!;
+      const way = finder.obstacles.inside(a, pad) || finder.obstacles.inside(b, pad) ? undefined : finder.corners.path(a, b);
+      spine = way ? finder.corners.pull(way) : undefined;
+    }
+    if (!spine || spine.length < 2 || polylineLength(spine) <= finder.margin) continue;
+    // The part of each edge in the cluster: its first and its last segment in the order of its route.
+    const parts = new Map<string, { first: RouteSegment; last: RouteSegment }>();
+    for (const s of cluster) {
+      const p = parts.get(s.edge);
+      if (!p) parts.set(s.edge, { first: s, last: s });
+      else {
+        if (s.index < p.first.index) p.first = s;
+        if (s.index > p.last.index) p.last = s;
+      }
+    }
+    const placed: Placed[] = [];
+    for (const [edge, p] of parts) {
+      if (lineDistance(spine, p.first.a) > eps || lineDistance(spine, p.last.b) > eps) continue;
+      const on = nearestPlace(spine, p.first.a);
+      const off = nearestPlace(spine, p.last.b);
+      const ride = lengthBetween(spine, Math.min(on, off), Math.max(on, off));
+      const own = polylineLength(corners.get(edge)!.slice(p.first.index, p.last.index + 2));
+      if (ride > finder.margin && ride <= DETOUR * own + finder.margin) placed.push({ edge, on, off, ride });
+    }
+    if (placed.length >= 2) found.push({ spine, placed });
+  }
+  // Each edge keeps the highway where it rides the longest length. The first highway wins a tie.
+  const best = new Map<string, { at: number; ride: number }>();
+  found.forEach((f, at) => {
+    for (const x of f.placed) if ((best.get(x.edge)?.ride ?? -1) < x.ride) best.set(x.edge, { at, ride: x.ride });
+  });
+  const highways: Highway[] = [];
+  found.forEach((f, at) => {
+    const placed = f.placed.filter((x) => best.get(x.edge)!.at === at);
+    if (placed.length < 2) return;
+    const route = f.spine;
+    // The lane order reads the plugs of each edge on each side of the spine.
+    const trip = (x: Placed): Point[] => {
+      const own = routes.get(x.edge)!;
+      const [from, to] = [own[0]!, own[own.length - 1]!];
+      return x.on <= x.off ? [from, ...route, to] : [to, ...route, from];
+    };
+    const lanes = orderLanes(
+      route,
+      placed.map((x) => ({ edge: x.edge, points: trip(x) })),
+      "bundle",
+    );
+    const byEdge = new Map(placed.map((x) => [x.edge, x]));
+    const members: HighwayMember[] = lanes.map((edge) => memberAt(route, edge, byEdge.get(edge)!.on, byEdge.get(edge)!.off));
+    highways.push({ id: `h${highways.length}`, key: `t${highways.length}`, spine: route, lanes, members });
+  });
+  return tidyPlan(orderAlongRoutes({ highways }, routes));
+}

package/src/index.ts

@@ -7,6 +7,7 @@ export * from "./plugs.ts";
 export * from "./curves.ts";
 export * from "./curves/index.ts";
 export * from "./visibility.ts";
+export * from "./channels.ts";
 export * from "./ways.ts";
 export * from "./segments.ts";
 export * from "./sections.ts";