@mark1russell7/highways 0.4.2 → 0.5.1

package/src/highways/frechet/index.ts

@@ -0,0 +1,232 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { arcPlace, firstRoutes, orderAlongRoutes, tidyPlan } from "../base.ts";
+import { memberAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+
+/** The options of the highway strategy `frechet` (HWY-027 of the notes). */
+export interface FrechetOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** Two parts of routes are one bundle when their discrete Fréchet distance is this value or less, as a multiple of `boardUnit`. The default is 1. */
+  readonly eps: number;
+  /** A bundle has this number of edges or more, with the reference edge. The default is 2. */
+  readonly minSize: number;
+  /** The reference part of a bundle is this length or longer, as a multiple of `boardUnit`. The default is 2. */
+  readonly minLength: number;
+  /** The distance between two samples of a route, as a multiple of `boardUnit`. The default is 0.5. */
+  readonly step: number;
+  /** A search starts at each sample of this number along each route. The default is 2. */
+  readonly stride: number;
+}
+
+/** The default options of the strategy `frechet`. */
+export const FRECHET_DEFAULTS: Readonly<Required<Omit<FrechetOptions, "margin" | "k">>> = Object.freeze({
+  eps: 1,
+  minSize: 2,
+  minLength: 2,
+  step: 0.5,
+  stride: 2,
+});
+
+/** This function gives the points of a polyline at equal distances of `step` or less, with its first and its last point. */
+export function samplesOf(line: readonly Point[], step: number): Point[] {
+  if (line.length < 2) return [...line];
+  const out: Point[] = [line[0]!];
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const n = Math.max(1, Math.ceil(dist(a, b) / Math.max(1e-9, step)));
+    for (let s = 1; s <= n; s++) out.push({ x: a.x + ((b.x - a.x) * s) / n, y: a.y + ((b.y - a.y) * s) / n });
+  }
+  return out;
+}
+
+/** The cells of one row of the free space that a monotone path reaches. Each cell is a sorted index of the other curve. */
+type Row = readonly number[];
+
+/**
+ * This function gives the next row of the free space of the discrete Fréchet distance. The curve `q` has a free start and a free end.
+ * A cell `(j, b)` is free when the distance of `p[j]` to `q[b]` is `eps` or less.
+ * A path reaches a free cell from `(j - 1, b)`, `(j - 1, b - 1)` or `(j, b - 1)`.
+ */
+export function nextRow(prev: Row, pj: Point, q: readonly Point[], eps: number): number[] {
+  const out: number[] = [];
+  if (prev.length === 0) return out;
+  const has = new Set(prev);
+  const last = prev[prev.length - 1]!;
+  let left = false;
+  for (let b = prev[0]!; b < q.length; b++) {
+    const reach: boolean = dist(pj, q[b]!) <= eps && (has.has(b) || has.has(b - 1) || left);
+    if (reach) out.push(b);
+    left = reach;
+    if (!reach && b > last) break;
+  }
+  return out;
+}
+
+/**
+ * This function tells if a part of `q` has a discrete Fréchet distance of `eps` or less to the whole of `p`. The part of `q` is free to start and to end anywhere.
+ * It uses the rows of `nextRow`.
+ */
+export function partWithin(p: readonly Point[], q: readonly Point[], eps: number): boolean {
+  if (p.length === 0) return true;
+  let row: number[] = [];
+  for (let b = 0; b < q.length; b++) if (dist(p[0]!, q[b]!) <= eps) row.push(b);
+  for (let j = 1; j < p.length && row.length > 0; j++) row = nextRow(row, p[j]!, q, eps);
+  return row.length > 0;
+}
+
+/** One bundle of the search: the reference edge, the part of its samples, and the other edges with their sense. */
+export interface FrechetBundle {
+  readonly edge: string;
+  readonly from: number;
+  readonly to: number;
+  readonly length: number;
+  /** The other edges. `back` is true when the edge goes along the reference part in the reverse sense. */
+  readonly members: readonly { readonly edge: string; readonly back: boolean }[];
+}
+
+/**
+ * This function gives the bundles of the search (HWY-027, after Buchin, Buchin, Gudmundsson, Löffler and Luo 2011, in a simple exact form).
+ * For each reference route and each start sample (at each `stride`), it grows the reference part one sample at a time.
+ * It keeps the other routes, in both senses, with a part at a discrete Fréchet distance of `eps` or less.
+ * It stops when fewer than `minSize - 1` routes remain.
+ * Each start gives the part with the best score: the number of edges times the length.
+ * The search uses the discrete distance on samples only. It does not use the continuous distance or the full free space diagram.
+ */
+export function frechetBundles(samples: ReadonlyMap<string, readonly Point[]>, eps: number, minSize: number, minLength: number, stride: number): FrechetBundle[] {
+  const edges = [...samples.keys()];
+  const curves = new Map<string, readonly Point[]>();
+  for (const e of edges) {
+    curves.set(`${e}\u0000f`, samples.get(e)!);
+    curves.set(`${e}\u0000b`, [...samples.get(e)!].reverse());
+  }
+  // A grid of the samples of each curve, with cells of the side `eps`, finds the first row of each start.
+  const cell = Math.max(1e-6, eps);
+  const grid = new Map<string, Set<string>>();
+  const cellKey = (p: Point): string => `${Math.floor(p.x / cell)},${Math.floor(p.y / cell)}`;
+  for (const [key, c] of curves)
+    for (const p of c) {
+      const k = cellKey(p);
+      let set = grid.get(k);
+      if (!set) grid.set(k, (set = new Set()));
+      set.add(key);
+    }
+  const near = (p: Point): string[] => {
+    const cx = Math.floor(p.x / cell);
+    const cy = Math.floor(p.y / cell);
+    const out = new Set<string>();
+    for (let dx = -1; dx <= 1; dx++) for (let dy = -1; dy <= 1; dy++) for (const k of grid.get(`${cx + dx},${cy + dy}`) ?? []) out.add(k);
+    return [...out].sort();
+  };
+  const need = Math.max(1, minSize - 1);
+  const out: FrechetBundle[] = [];
+  for (const r of edges) {
+    const p = samples.get(r)!;
+    const lengths = [0];
+    for (let i = 1; i < p.length; i++) lengths.push(lengths[i - 1]! + dist(p[i - 1]!, p[i]!));
+    for (let i = 0; i < p.length - 1; i += Math.max(1, Math.round(stride))) {
+      let rows = new Map<string, number[]>();
+      for (const key of near(p[i]!)) {
+        if (key.startsWith(`${r}\u0000`)) continue;
+        const q = curves.get(key)!;
+        const row: number[] = [];
+        q.forEach((s, b) => {
+          if (dist(p[i]!, s) <= eps) row.push(b);
+        });
+        if (row.length > 0) rows.set(key, row);
+      }
+      let best: FrechetBundle | undefined;
+      let bestScore = 0;
+      for (let j = i + 1; j < p.length; j++) {
+        const next = new Map<string, number[]>();
+        for (const [key, row] of rows) {
+          const n = nextRow(row, p[j]!, curves.get(key)!, eps);
+          if (n.length > 0) next.set(key, n);
+        }
+        rows = next;
+        // One edge counts once: its forward sense wins over its reverse sense.
+        const alive = new Map<string, boolean>();
+        for (const key of rows.keys()) {
+          const [edge, sense] = key.split("\u0000") as [string, string];
+          if (!alive.has(edge) || sense === "f") alive.set(edge, sense === "b");
+        }
+        if (alive.size < need) break;
+        const length = lengths[j]! - lengths[i]!;
+        const score = (alive.size + 1) * length;
+        if (length >= minLength && score > bestScore) {
+          bestScore = score;
+          best = { edge: r, from: i, to: j, length, members: [...alive].sort((a, b) => (a[0] < b[0] ? -1 : 1)).map(([edge, back]) => ({ edge, back })) };
+        }
+      }
+      if (best) out.push(best);
+    }
+  }
+  return out;
+}
+
+/**
+ * This function gives the highways of the subtrajectory clusters of the first routes (HWY-027). The samples of each route leave out its two end points.
+ * The bundles go in the order of their score, the best first. A bundle keeps the members whose part of the route is not on a bundle already.
+ * The spine of a highway is the reference part. Each member rides the whole spine, in its own sense.
+ */
+export function frechetPlan(input: HighwayInput, o: Readonly<FrechetOptions>): 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 routes = firstRoutes(input);
+  const step = Math.max(1e-3, o.step * unit);
+  const samples = new Map<string, Point[]>();
+  for (const e of graph.edges) {
+    const route = routes.get(e.id);
+    if (!route || route.length < 4) continue;
+    const s = samplesOf(route.slice(1, -1), step);
+    if (s.length >= 2) samples.set(e.id, s);
+  }
+  const minSize = Math.max(2, Math.round(o.minSize));
+  const bundles = frechetBundles(samples, Math.max(1e-3, o.eps * unit), minSize, Math.max(finder.margin, o.minLength * unit), o.stride);
+  bundles.sort((a, b) => (b.members.length + 1) * b.length - (a.members.length + 1) * a.length || (a.edge < b.edge ? -1 : a.edge > b.edge ? 1 : a.from - b.from));
+  // The used parts of each route, as places along the route.
+  const used = new Map<string, [number, number][]>();
+  const free = (edge: string, lo: number, hi: number): boolean => (used.get(edge) ?? []).every(([a, b]) => hi <= a || lo >= b);
+  const take = (edge: string, lo: number, hi: number): void => {
+    const list = used.get(edge);
+    if (list) list.push([lo, hi]);
+    else used.set(edge, [[lo, hi]]);
+  };
+  const highways: Highway[] = [];
+  for (const bundle of bundles) {
+    const spine = samples.get(bundle.edge)!.slice(bundle.from, bundle.to + 1);
+    if (polylineLength(spine) <= finder.margin) continue;
+    const own = routes.get(bundle.edge)!;
+    const span = (route: readonly Point[]): [number, number] => {
+      const a = arcPlace(route, spine[0]!);
+      const b = arcPlace(route, spine[spine.length - 1]!);
+      return [Math.min(a, b), Math.max(a, b)];
+    };
+    const [rlo, rhi] = span(own);
+    if (!free(bundle.edge, rlo, rhi)) continue;
+    const riders = bundle.members.filter((m) => {
+      const [lo, hi] = span(routes.get(m.edge)!);
+      return free(m.edge, lo, hi);
+    });
+    if (riders.length + 1 < minSize) continue;
+    const all = [{ edge: bundle.edge, back: false }, ...riders];
+    for (const m of all) take(m.edge, ...span(routes.get(m.edge)!));
+    const last = spine.length - 1;
+    const trip = (m: { edge: string; back: boolean }): Point[] => {
+      const r = routes.get(m.edge)!;
+      const [from, to] = [r[0]!, r[r.length - 1]!];
+      return m.back ? [to, ...spine, from] : [from, ...spine, to];
+    };
+    const lanes = orderLanes(
+      spine,
+      all.map((m) => ({ edge: m.edge, points: trip(m) })),
+      "bundle",
+    );
+    const back = new Map(all.map((m) => [m.edge, m.back]));
+    const members: HighwayMember[] = lanes.map((edge) => (back.get(edge) ? memberAt(spine, edge, last, 0) : memberAt(spine, edge, 0, last)));
+    highways.push({ id: `h${highways.length}`, key: `f${highways.length}`, spine, lanes, members });
+  }
+  return tidyPlan(orderAlongRoutes({ highways }, routes));
+}

package/src/highways/growth/index.ts

@@ -0,0 +1,148 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, polylineLength, type Point } from "../../geom.ts";
+import { orderLanes } from "../../segments.ts";
+import { WayFinder } from "../../ways.ts";
+import { firstRoutes, nearestPlace, tidyPlan } from "../base.ts";
+import { lengthBetween, memberAt, pointAt, type Highway, type HighwayInput, type HighwayMember, type HighwayPlan } from "../model.ts";
+import { edgePlugs } from "../stretches.ts";
+
+/** The order of the edges in the growth: the longest first route first, or the order of the graph. */
+export type GrowthOrder = "length" | "input";
+
+/** The options of the highway strategy `growth` (HWY-055 of the note on highways). */
+export interface GrowthOptions {
+  /** The distance from a box to the corners of the graph. The default is 5. */
+  readonly margin?: number;
+  /** The number of visible neighbours of each corner. The default is 8. */
+  readonly k?: number;
+  /** The order of the edges. The default is `length`. */
+  readonly order: GrowthOrder;
+  /** The cost of the part on a spine, as a share of its length. The ramps cost their full length. The default is 0.5. */
+  readonly share: number;
+  /** An edge joins a highway only when its way along it is this value times its first route or shorter. The default is 1.3. */
+  readonly stretch: number;
+  /** A spine end extends when this number of its lanes or more go on together. The default is 3. */
+  readonly extendLanes: number;
+  /** The lanes go on together when their ends are this distance from their center or nearer, in units of the board. The default is 2. */
+  readonly extendRadius: number;
+  /** A highway with this number of edges or more stays in the plan. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `growth`. */
+export const GROWTH_DEFAULTS: Readonly<GrowthOptions> = Object.freeze({ order: "length", share: 0.5, stretch: 1.3, extendLanes: 3, extendRadius: 2, minSize: 2 });
+
+interface Grown {
+  spine: Point[];
+  members: { edge: string; on: number; off: number }[];
+}
+
+interface Rider {
+  readonly edge: string;
+  readonly ps: Point;
+  readonly pt: Point;
+  readonly a: Point;
+  readonly b: Point;
+  readonly len: number;
+}
+
+/**
+ * This function gives the highways of local growth (HWY-055). The edges come one by one, by default the longest first route first.
+ * Each edge joins the highway with the largest saving: its first route less its ramps and `share` of its part on the spine. Without a saving, the edge starts a highway on its own way.
+ * After the growth, a spine end can go on to the center of the far ends of its lanes.
+ * This occurs when `extendLanes` of them or more are near that center and the line is clear.
+ */
+export function growthPlan(input: HighwayInput, o: Readonly<GrowthOptions>): 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 routes = firstRoutes(input);
+  const riders: Rider[] = edgePlugs(graph).map(({ edge, ps, pt }) => {
+    const route = routes.get(edge.id);
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    return { edge: edge.id, ps: ps.point, pt: pt.point, a, b, len: route ? polylineLength(route) : dist(ps.point, pt.point) };
+  });
+  if (o.order === "length") riders.sort((p, q) => q.len - p.len || (p.edge < q.edge ? -1 : p.edge > q.edge ? 1 : 0));
+  const grown: Grown[] = [];
+  const short = finder.margin;
+  for (const r of riders) {
+    let best = -1;
+    let bestSave = 0;
+    let bestOn = 0;
+    let bestOff = 0;
+    grown.forEach((h, hi) => {
+      const on = nearestPlace(h.spine, r.a);
+      const off = nearestPlace(h.spine, r.b);
+      const part = lengthBetween(h.spine, Math.min(on, off), Math.max(on, off));
+      if (part <= short) return;
+      const ramps = dist(r.a, pointAt(h.spine, on)) + dist(pointAt(h.spine, off), r.b);
+      if (ramps + part > o.stretch * r.len) return;
+      const save = r.len - (ramps + o.share * part);
+      if (save > bestSave) [best, bestSave, bestOn, bestOff] = [hi, save, on, off];
+    });
+    if (best >= 0) {
+      grown[best]!.members.push({ edge: r.edge, on: bestOn, off: bestOff });
+      continue;
+    }
+    const raw = finder.corners.path(r.a, r.b);
+    if (!raw) continue;
+    const spine = finder.corners.pull(raw);
+    if (spine.length < 2 || polylineLength(spine) <= short) continue;
+    grown.push({ spine, members: [{ edge: r.edge, on: 0, off: spine.length - 1 }] });
+  }
+
+  // A spine end goes on while enough of its lanes go on together.
+  const byEdge = new Map(riders.map((r) => [r.edge, r]));
+  const radius = o.extendRadius * boardUnit(graph);
+  const need = Math.max(2, Math.round(o.extendLanes));
+  for (const h of grown) {
+    for (const end of ["first", "last"] as const) {
+      const last = h.spine.length - 1;
+      const at = end === "first" ? 0 : last;
+      // The far point of each lane at this end: the point out of the plug that the lane goes to or comes from.
+      const far: { m: Grown["members"][number]; side: "on" | "off"; p: Point }[] = [];
+      for (const m of h.members) {
+        const r = byEdge.get(m.edge)!;
+        if (m.on === at) far.push({ m, side: "on", p: r.a });
+        else if (m.off === at) far.push({ m, side: "off", p: r.b });
+      }
+      if (far.length < need) continue;
+      const c = { x: far.reduce((s, f) => s + f.p.x, 0) / far.length, y: far.reduce((s, f) => s + f.p.y, 0) / far.length };
+      const near = far.filter((f) => dist(f.p, c) <= radius);
+      const tip = h.spine[at]!;
+      if (near.length < need || dist(tip, c) <= short) continue;
+      if (finder.obstacles.inside(c, pad) || !finder.obstacles.clear(tip, c, pad)) continue;
+      if (end === "first") {
+        h.spine.unshift(c);
+        for (const m of h.members) [m.on, m.off] = [m.on + 1, m.off + 1];
+        for (const f of near) f.m[f.side] = 0;
+      } else {
+        h.spine.push(c);
+        for (const f of near) f.m[f.side] = last + 1;
+      }
+    }
+  }
+
+  const highways: Highway[] = [];
+  grown.forEach((h, hi) => {
+    if (h.members.length < Math.max(2, o.minSize)) return;
+    const spine = h.spine;
+    const back = [...spine].reverse();
+    const lanes = orderLanes(
+      spine,
+      h.members.map((m) => {
+        const r = byEdge.get(m.edge)!;
+        return { edge: m.edge, points: m.on <= m.off ? [r.ps, r.a, ...spine, r.b, r.pt] : [r.ps, r.a, ...back, r.b, r.pt] };
+      }),
+      "bundle",
+    );
+    const byLane = new Map(h.members.map((m) => [m.edge, m]));
+    const members: HighwayMember[] = lanes.map((edge) => {
+      const m = byLane.get(edge)!;
+      return memberAt(spine, edge, m.on, m.off);
+    });
+    highways.push({ id: `h${hi}`, key: `g${hi}`, spine, lanes, members });
+  });
+  return tidyPlan({ highways });
+}

package/src/highways/hdbscan/index.ts

@@ -0,0 +1,250 @@
+import { dist, type Point } from "../../geom.ts";
+import { flowDistance } 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 distance of two edges: 1 less their compatibility of FDEB, or the flow distance in 4D of HWY-023. */
+export type EdgeDistance = "compatibility" | "flow";
+
+/** The values of `EdgeDistance`. */
+export const EDGE_DISTANCES: readonly EdgeDistance[] = Object.freeze(["compatibility", "flow"]);
+
+/** The options of the highway strategy `hdbscan` (HWY-028 of the note on highways). */
+export interface HdbscanOptions {
+  /** A cluster has this number of edges or more. The default is 3. */
+  readonly minClusterSize: number;
+  /** The core distance of an edge is the distance to its neighbour of this rank. The default is 3. */
+  readonly minSamples: number;
+  /** The distance of two edges. The default is `compatibility`. */
+  readonly distance: EdgeDistance;
+  /** The spine of each cluster. The default is `trunk`: one trunk from one area to the other area. */
+  readonly spine: GroupSpine;
+}
+
+/** The default options of the strategy `hdbscan`. */
+export const HDBSCAN_DEFAULTS: Readonly<HdbscanOptions> = Object.freeze({ minClusterSize: 3, minSamples: 3, distance: "compatibility", spine: "trunk" });
+
+/** 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 compatibility of two edges of FDEB (Holten and van Wijk 2009): `Ca Cs Cp Cv`, from 0 to 1.
+ * `Ca` is the angle, `Cs` the scale, `Cp` the position and `Cv` the visibility. The direction of an edge does not change the value.
+ */
+export function compatibility(p0: Point, p1: Point, q0: Point, q1: Point): number {
+  const lp = dist(p0, p1);
+  const lq = dist(q0, q1);
+  if (lp <= 1e-9 || lq <= 1e-9) return 0;
+  const ca = Math.abs(((p1.x - p0.x) * (q1.x - q0.x) + (p1.y - p0.y) * (q1.y - q0.y)) / (lp * lq));
+  const avg = (lp + lq) / 2;
+  const cs = 2 / (avg / Math.min(lp, lq) + Math.max(lp, lq) / avg);
+  const pm = { x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2 };
+  const qm = { x: (q0.x + q1.x) / 2, y: (q0.y + q1.y) / 2 };
+  const cp = avg / (avg + dist(pm, qm));
+  const cv = Math.min(visibility(p0, p1, q0, q1), visibility(q0, q1, p0, p1));
+  return ca * cs * cp * cv;
+}
+
+/** This function gives the visibility of the edge `q` from the edge `p` of FDEB: `max(1 - 2 |pm - im| / |i0 i1|, 0)`. The points `i` are the projection of `q` on the line of `p`. */
+function visibility(p0: Point, p1: Point, q0: Point, q1: Point): number {
+  const dx = p1.x - p0.x;
+  const dy = p1.y - p0.y;
+  const l2 = dx * dx + dy * dy;
+  const project = (q: Point): Point => {
+    const u = ((q.x - p0.x) * dx + (q.y - p0.y) * dy) / l2;
+    return { x: p0.x + u * dx, y: p0.y + u * dy };
+  };
+  const i0 = project(q0);
+  const i1 = project(q1);
+  const span = dist(i0, i1);
+  if (span <= 1e-9) return 0;
+  const im = { x: (i0.x + i1.x) / 2, y: (i0.y + i1.y) / 2 };
+  const pm = { x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2 };
+  return Math.max(1 - (2 * dist(pm, im)) / span, 0);
+}
+
+/**
+ * This function gives the HDBSCAN clusters of the points of a distance matrix (Campello, Moulavi and Sander 2013). The value -1 is noise.
+ * The core distance of a point is the distance to its `minSamples`-th nearest point. The mutual reachability is `max(core(a), core(b), d(a, b))`.
+ * The minimum spanning tree of the mutual reachability gives the tree of the clusters. A split with two parts of `minClusterSize` or more gives two clusters.
+ * The selection keeps the clusters with the largest stability, `sum (lambda_leave - lambda_birth)`, with `lambda = 1 / distance`. The root is not a cluster.
+ */
+export function hdbscanLabels(n: number, d: Float64Array, minClusterSize: number, minSamples: number): Int32Array {
+  const labels = new Int32Array(n).fill(-1);
+  const mcs = Math.max(2, Math.round(minClusterSize));
+  if (n < mcs || n < 2) return labels;
+  const k = Math.max(1, Math.min(n - 1, Math.round(minSamples)));
+  // The core distance of each point.
+  const core = new Float64Array(n);
+  const row = new Float64Array(n - 1);
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let j = 0; j < n; j++) if (j !== i) row[c++] = d[i * n + j]!;
+    row.sort();
+    core[i] = row[k - 1]!;
+  }
+  const reach = (i: number, j: number): number => Math.max(core[i]!, core[j]!, d[i * n + j]!);
+  // The minimum spanning tree (Prim), with ties to the lower index.
+  const inTree = new Uint8Array(n);
+  const best = new Float64Array(n).fill(Infinity);
+  const from = new Int32Array(n).fill(-1);
+  const links: { a: number; b: number; w: number }[] = [];
+  let cur = 0;
+  inTree[0] = 1;
+  for (let step = 1; step < n; step++) {
+    let next = -1;
+    for (let j = 0; j < n; j++) {
+      if (inTree[j]) continue;
+      const w = reach(cur, j);
+      if (w < best[j]!) [best[j], from[j]] = [w, cur];
+      if (next < 0 || best[j]! < best[next]!) next = j;
+    }
+    inTree[next] = 1;
+    links.push({ a: from[next]!, b: next, w: best[next]! });
+    cur = next;
+  }
+  links.sort((p, q) => p.w - q.w || p.a - q.a || p.b - q.b);
+  // The single linkage tree: the node `n + i` is the merge `i`.
+  const parent = new Int32Array(2 * n - 1).fill(-1);
+  const left = new Int32Array(n - 1);
+  const right = new Int32Array(n - 1);
+  const height = new Float64Array(n - 1);
+  const size = new Int32Array(2 * n - 1).fill(1);
+  const uf = new Int32Array(2 * n - 1);
+  for (let i = 0; i < uf.length; i++) uf[i] = i;
+  const find = (i: number): number => {
+    while (uf[i] !== i) i = uf[i] = uf[uf[i]!]!;
+    return i;
+  };
+  links.forEach((l, i) => {
+    const ra = find(l.a);
+    const rb = find(l.b);
+    const node = n + i;
+    left[i] = ra;
+    right[i] = rb;
+    height[i] = l.w;
+    size[node] = size[ra]! + size[rb]!;
+    parent[ra] = node;
+    parent[rb] = node;
+    uf[ra] = node;
+    uf[rb] = node;
+  });
+  const root = 2 * n - 2;
+  const lambdaOf = (h: number): number => 1 / Math.max(h, 1e-9);
+  const leaves = (node: number): number[] => {
+    const out: number[] = [];
+    const stack = [node];
+    while (stack.length > 0) {
+      const x = stack.pop()!;
+      if (x < n) out.push(x);
+      else stack.push(left[x - n]!, right[x - n]!);
+    }
+    return out;
+  };
+  // The condensed tree. Each cluster has a birth lambda, a parent cluster, its stability and the points that leave it at their lambda.
+  const birth: number[] = [0];
+  const up: number[] = [-1];
+  const stability: number[] = [0];
+  const fall = new Int32Array(n).fill(0);
+  const queue: [node: number, cluster: number][] = [[root, 0]];
+  while (queue.length > 0) {
+    const [node, c] = queue.shift()!;
+    const i = node - n;
+    const lambda = lambdaOf(height[i]!);
+    const kids = [left[i]!, right[i]!];
+    const big = kids.filter((x) => size[x]! >= mcs);
+    if (big.length === 2) {
+      for (const x of kids) {
+        const id = birth.length;
+        birth.push(lambda);
+        up.push(c);
+        stability.push(0);
+        stability[c] = stability[c]! + size[x]! * (lambda - birth[c]!);
+        queue.push([x, id]);
+      }
+      continue;
+    }
+    for (const x of kids) {
+      if (big.includes(x)) {
+        if (x >= n) queue.push([x, c]);
+        else {
+          fall[x] = c;
+          stability[c] = stability[c]! + (lambda - birth[c]!);
+        }
+        continue;
+      }
+      for (const p of leaves(x)) {
+        fall[p] = c;
+        stability[c] = stability[c]! + (lambda - birth[c]!);
+      }
+    }
+  }
+  // The selection by the excess of mass, from the last cluster to the first. A child cluster always has a larger id than its parent.
+  const count = birth.length;
+  const chosen = new Uint8Array(count);
+  const value = [...stability];
+  const children: number[][] = Array.from({ length: count }, () => []);
+  for (let c = 1; c < count; c++) children[up[c]!]!.push(c);
+  for (let c = count - 1; c >= 1; c--) {
+    const sub = children[c]!.reduce((s, x) => s + value[x]!, 0);
+    if (children[c]!.length > 0 && sub > value[c]!) value[c] = sub;
+    else {
+      chosen[c] = 1;
+      const stack = [...children[c]!];
+      while (stack.length > 0) {
+        const x = stack.pop()!;
+        chosen[x] = 0;
+        stack.push(...children[x]!);
+      }
+    }
+  }
+  for (let p = 0; p < n; p++) {
+    let c = fall[p]!;
+    while (c > 0 && !chosen[c]) c = up[c]!;
+    labels[p] = c > 0 ? c : -1;
+  }
+  return labels;
+}
+
+/**
+ * This function gives the HDBSCAN clusters of the edges (HWY-028). The edges that are noise get no group.
+ * Each edge of a cluster gets `flip` when it goes opposite to the first edge of the cluster.
+ */
+export function hdbscanClusters(input: HighwayInput, o: Readonly<HdbscanOptions>): Map<string, EdgeGroup> {
+  const ends = edgePlugs(input.graph).map(({ edge, ps, pt }) => ({ edge: edge.id, s: ps.point, t: pt.point }));
+  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;
+  const between = (a: (typeof ends)[number], b: (typeof ends)[number]): number =>
+    o.distance === "flow" ? flowDistance(a.s, a.t, b.s, b.t, false).d : 1 - compatibility(a.s, a.t, b.s, b.t);
+  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 v = between(block[i]!, block[j]!);
+        d[i * n + j] = v;
+        d[j * n + i] = v;
+      }
+    const labels = hdbscanLabels(n, d, o.minClusterSize, o.minSamples);
+    const lead = new Map<number, number>();
+    block.forEach((e, i) => {
+      const c = labels[i]!;
+      if (c < 0) return;
+      if (!lead.has(c)) lead.set(c, i);
+      const l = block[lead.get(c)!]!;
+      const flip = (e.t.x - e.s.x) * (l.t.x - l.s.x) + (e.t.y - e.s.y) * (l.t.y - l.s.y) < 0;
+      groups.set(e.edge, { key: `c${from}:${c}`, flip });
+    });
+  }
+  return groups;
+}
+
+/**
+ * This function gives the highways of the HDBSCAN clusters (HWY-028). The clusters that live over a long range of densities are the highways.
+ * The number of highways is not fixed, and the noise edges stay alone.
+ */
+export function hdbscanPlan(input: HighwayInput, o: Readonly<HdbscanOptions>): HighwayPlan {
+  return groupedPlan(input, hdbscanClusters(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minClusterSize)) });
+}