@mark1russell7/highways 0.4.1 → 0.5.0

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/highways/weiszfeld/index.ts

@@ -0,0 +1,105 @@
+import { dist, type Point } from "../../geom.ts";
+import { basePlan, nearestPlace, planRoutes, routeIndex, tidyPlan, tripsOf, type HighwayBase } from "../base.ts";
+import { memberAt, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `weiszfeld` (HWY-043 of the note on highways). */
+export interface WeiszfeldOptions {
+  /** The plan whose highways get new meeting points. The default is `shared-ways`. */
+  readonly from: HighwayBase;
+  /** The weight of the trunk is `k^alpha` for `k` members. With 0, the trunk costs its ink one time. With 1, it costs each lane. The default is 0.5. */
+  readonly alpha: number;
+  /** The number of steps of Weiszfeld. The default is 20. */
+  readonly steps: number;
+}
+
+/** The default options of the strategy `weiszfeld`. */
+export const WEISZFELD_DEFAULTS: Readonly<WeiszfeldOptions> = Object.freeze({ from: "shared-ways", alpha: 0.5, steps: 20 });
+
+const TINY = 1e-9;
+
+/** This function gives one step of Weiszfeld for the point `m`. The point `m` is near the points `ends`, and tied to `other` with the weight `w`. */
+function weiszfeldStep(m: Point, ends: readonly Point[], other: Point, w: number): Point {
+  let x = 0;
+  let y = 0;
+  let sum = 0;
+  for (const p of ends) {
+    const d = Math.max(TINY, dist(p, m));
+    x += p.x / d;
+    y += p.y / d;
+    sum += 1 / d;
+  }
+  const d = Math.max(TINY, dist(other, m));
+  x += (w * other.x) / d;
+  y += (w * other.y) / d;
+  sum += w / d;
+  return sum > 0 ? { x: x / sum, y: y / sum } : m;
+}
+
+/** This function gives the mean of a list of points that is not empty. */
+const mean = (ps: readonly Point[]): Point => ({ x: ps.reduce((s, p) => s + p.x, 0) / ps.length, y: ps.reduce((s, p) => s + p.y, 0) / ps.length });
+
+/**
+ * This function gives the meeting points `M1` and `M2` of a bundle with the least weighted ink (HWY-043):
+ * `Σ |a_i - M1| + w |M1 - M2| + Σ |M2 - b_i|`. The lists `a` and `b` are the ends of the edges on each side, and `w` is the weight of the trunk.
+ * The function starts at the means of `a` and `b`. Each step moves `M1` and then `M2` by one step of Weiszfeld.
+ */
+export function meetingPoints(a: readonly Point[], b: readonly Point[], w: number, steps: number): [Point, Point] {
+  if (a.length === 0 || b.length === 0) throw new Error("A side of the bundle has no end.");
+  let m1 = mean(a);
+  let m2 = mean(b);
+  for (let s = 0; s < steps; s++) {
+    m1 = weiszfeldStep(m1, a, m2, w);
+    m2 = weiszfeldStep(m2, b, m1, w);
+  }
+  return [m1, m2];
+}
+
+/**
+ * This function gives the highways of the plan `from`, with the meeting points of Weiszfeld (HWY-043).
+ * The ends of a member are the points where its edge comes to the highway and goes away from it after `follow` of the plan.
+ * They are the plugs, or the split point of the highway before and the merge point of the highway after.
+ * The weight of the trunk is `k^alpha` for `k` members. The trunk stays on the spine: the function projects `M1` and `M2` on the spine.
+ * Each member then joins the spine at `M1` and leaves it at `M2`, but not outside its own stretch. So a member only gets shorter on the spine.
+ */
+export function weiszfeldPlan(input: HighwayInput, o: Readonly<WeiszfeldOptions>): HighwayPlan {
+  const plan = basePlan(input, o.from);
+  if (plan.highways.length === 0) return plan;
+  const routes = routeIndex(planRoutes(input.graph, plan).routes);
+  const trips = tripsOf(plan);
+  const highways = plan.highways.map((h, hi) => {
+    const a: Point[] = [];
+    const b: Point[] = [];
+    for (const m of h.members) {
+      const trip = trips.get(m.edge) ?? [];
+      const route = routes.get(m.edge);
+      const k = trip.findIndex((s) => s.h === hi);
+      const before = k > 0 ? trip[k - 1]!.m.split : route?.[0];
+      const after = k >= 0 && k < trip.length - 1 ? trip[k + 1]!.m.merge : route?.[route.length - 1];
+      if (!before || !after) continue;
+      if (m.on <= m.off) {
+        a.push(before);
+        b.push(after);
+      } else {
+        a.push(after);
+        b.push(before);
+      }
+    }
+    if (a.length < 2) return h;
+    const [m1, m2] = meetingPoints(a, b, h.members.length ** Math.max(0, o.alpha), Math.max(0, Math.round(o.steps)));
+    const pa = nearestPlace(h.spine, m1);
+    const pb = nearestPlace(h.spine, m2);
+    if (pb - pa <= 1e-6) return h;
+    const members: HighwayMember[] = h.members.map((m) => {
+      if (m.on <= m.off) {
+        const on = Math.max(m.on, pa);
+        const off = Math.min(m.off, pb);
+        return off - on > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+      }
+      const on = Math.min(m.on, pb);
+      const off = Math.max(m.off, pa);
+      return on - off > 1e-6 ? memberAt(h.spine, m.edge, on, off, m.seq) : m;
+    });
+    return { ...h, members };
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/wspd/index.ts

@@ -0,0 +1,130 @@
+import { center, dist, type Point } from "../../geom.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `wspd` (HWY-018 of the note on highways). */
+export interface WspdOptions {
+  /** The separation `s` of the pairs: the gap between two sets is at least `s` times the radius of the larger set. The default is 2. */
+  readonly separation: number;
+  /** A pair with this number of edges or more gets a highway. The default is 3. */
+  readonly minSize: number;
+  /** The spine of each pair. The default is `trunk`. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `wspd`. */
+export const WSPD_DEFAULTS: Readonly<WspdOptions> = Object.freeze({ separation: 2, minSize: 3, spine: "trunk" });
+
+/** A cell of the split tree: the points at the places `lo` to `hi - 1` of the order, with their bounding circle. */
+export interface SplitCell {
+  readonly id: number;
+  readonly lo: number;
+  readonly hi: number;
+  readonly c: Point;
+  readonly r: number;
+  readonly kids?: readonly [SplitCell, SplitCell];
+}
+
+/**
+ * The split tree of a set of points and its well-separated pairs (Callahan and Kosaraju 1995).
+ * Each cell splits at the middle of the longer side of its bounding box. A cell of equal points is a leaf.
+ */
+export class SplitTree {
+  readonly root: SplitCell;
+  /** The place of each point in the order of the tree. */
+  readonly #at: Int32Array;
+  #count = 0;
+
+  /** This constructor builds the tree of the points. */
+  constructor(points: readonly Point[]) {
+    const order = points.map((_, i) => i);
+    this.#at = new Int32Array(points.length);
+    this.root = this.#build(points, order, 0, points.length);
+    order.forEach((p, i) => (this.#at[p] = i));
+  }
+
+  #build(points: readonly Point[], order: number[], lo: number, hi: number): SplitCell {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (let i = lo; i < hi; i++) {
+      const p = points[order[i]!]!;
+      x0 = Math.min(x0, p.x);
+      y0 = Math.min(y0, p.y);
+      x1 = Math.max(x1, p.x);
+      y1 = Math.max(y1, p.y);
+    }
+    const id = this.#count++;
+    const c = center({ x: x0, y: y0, w: x1 - x0, h: y1 - y0 });
+    const r = Math.hypot(x1 - x0, y1 - y0) / 2;
+    if (hi - lo <= 1 || r <= 1e-9) return { id, lo, hi, c, r };
+    const byX = x1 - x0 >= y1 - y0;
+    const cut = byX ? (x0 + x1) / 2 : (y0 + y1) / 2;
+    const part = order.slice(lo, hi);
+    const left = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) <= cut);
+    const right = part.filter((i) => (byX ? points[i]!.x : points[i]!.y) > cut);
+    [...left, ...right].forEach((p, k) => (order[lo + k] = p));
+    const mid = lo + left.length;
+    return { id, lo, hi, c, r, kids: [this.#build(points, order, lo, mid), this.#build(points, order, mid, hi)] };
+  }
+
+  /** This method tells if the cell holds the point `i`. */
+  holds(cell: SplitCell, i: number): boolean {
+    const at = this.#at[i]!;
+    return at >= cell.lo && at < cell.hi;
+  }
+
+  /**
+   * This method gives the well-separated pair that holds the pair of points `u` and `v`, with the cell of `u` first.
+   * Each pair of two different points is in one pair of the decomposition. Two equal points give `undefined`.
+   */
+  pairOf(u: number, v: number, s: number): [SplitCell, SplitCell] | undefined {
+    let cell = this.root;
+    while (cell.kids) {
+      const next = cell.kids.find((k) => this.holds(k, u) && this.holds(k, v));
+      if (!next) break;
+      cell = next;
+    }
+    if (!cell.kids) return undefined;
+    let a = cell.kids.find((k) => this.holds(k, u))!;
+    let b = cell.kids.find((k) => this.holds(k, v))!;
+    for (;;) {
+      const r = Math.max(a.r, b.r);
+      if (dist(a.c, b.c) - 2 * r >= s * r) return [a, b];
+      if (a.r >= b.r && a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else if (b.kids) b = b.kids.find((k) => this.holds(k, v))!;
+      else if (a.kids) a = a.kids.find((k) => this.holds(k, u))!;
+      else return [a, b];
+    }
+  }
+}
+
+/**
+ * This function gives the groups of the edges by the well-separated pair of their two nodes (HWY-018).
+ * The points are the centers of the boxes. The edges of one pair, in either direction, are one group.
+ */
+export function wspdGroups(input: HighwayInput, o: Readonly<WspdOptions>): Map<string, EdgeGroup> {
+  const nodes = input.graph.nodes;
+  const index = new Map(nodes.map((n, i) => [n.id, i]));
+  const tree = new SplitTree(nodes.map((n) => center(n.box)));
+  const groups = new Map<string, EdgeGroup>();
+  for (const e of input.graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined || u === v) continue;
+    const pair = tree.pairOf(u, v, o.separation);
+    if (!pair) continue;
+    const [a, b] = pair;
+    groups.set(e.id, a.id < b.id ? { key: `w${a.id}:${b.id}`, flip: false } : { key: `w${b.id}:${a.id}`, flip: true });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of clustered edge routing with the WSPD (HWY-018, after Bouts and Speckmann 2015).
+ * The well-separated pairs split all the pairs of nodes. The edges of one pair with `minSize` edges or more get one highway from one set to the other.
+ */
+export function wspdPlan(input: HighwayInput, o: Readonly<WspdOptions>): HighwayPlan {
+  return groupedPlan(input, wspdGroups(input, o), { spine: o.spine, minSize: o.minSize });
+}