@mark1russell7/highways 0.5.0 → 0.5.1

package/src/highways/power/index.ts

@@ -0,0 +1,117 @@
+import type { WayOptions } from "../../ways.ts";
+import { nodeLinks, type GroupScope } from "../confluent/index.ts";
+import { groupedPlan, type EdgeGroup, type GroupSpine } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+
+/** The rule of a module: the nodes with the same neighbours (`exact`), or with near neighbours by the Jaccard index (`near`). */
+export type ModuleRule = "exact" | "near";
+
+/** The values of `ModuleRule`. */
+export const MODULE_RULES: readonly ModuleRule[] = Object.freeze(["exact", "near"]);
+
+/** The options of the highway strategy `power` (HWY-014 of the notes). */
+export interface PowerOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The rule of the modules. The default is `exact`. */
+  readonly modules: ModuleRule;
+  /** With the rule `near`, a node joins a module at this Jaccard index or more with the first node of the module. The default is 0.8. */
+  readonly jaccard: number;
+  /** A power edge saves the number of its edges less 1. It becomes a highway when it saves this number of edges or more. The default is 2. */
+  readonly minSaved: number;
+  /** The edges of one power edge. With `collection`, a power edge holds the edges of one collection. The default is `all`. */
+  readonly scope: GroupScope;
+  /** The spine of each power edge. The default is `trunk`. */
+  readonly spine: GroupSpine;
+  /** An edge rides the trunk only when each of its legs is this share of the trunk or shorter. `Infinity` sets no limit. The default is 1. */
+  readonly legMax: number;
+}
+
+/** The default options of the strategy `power`. */
+export const POWER_DEFAULTS: Readonly<Required<Omit<PowerOptions, "margin" | "k">>> = Object.freeze({
+  modules: "exact",
+  jaccard: 0.8,
+  minSaved: 2,
+  scope: "all",
+  spine: "trunk",
+  legMax: 1,
+});
+
+/** This function gives the Jaccard index of two sets: the size of their common part over the size of their union. Two empty sets give 1. */
+export function jaccardIndex(a: ReadonlySet<string>, b: ReadonlySet<string>): number {
+  let common = 0;
+  for (const x of a) if (b.has(x)) common++;
+  const union = a.size + b.size - common;
+  return union === 0 ? 1 : common / union;
+}
+
+/**
+ * This function gives the module of each node. With `exact`, the nodes with the same set of neighbours are one module.
+ * With `near`, the nodes go in the order of their degree, the largest first. A node joins the first module whose first node has a Jaccard index of `jaccard` or more with it.
+ * The function gives the modules as lists of nodes, each in the order of the ids.
+ */
+export function modulesOf(links: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>, rule: ModuleRule, jaccard: number): string[][] {
+  const nodes = [...links.keys()].sort();
+  const sets = new Map(nodes.map((u) => [u, new Set(links.get(u)!.keys())] as const));
+  if (rule === "exact") {
+    const byKey = new Map<string, string[]>();
+    for (const u of nodes) {
+      const key = [...sets.get(u)!].sort().join("\u0000");
+      const list = byKey.get(key);
+      if (list) list.push(u);
+      else byKey.set(key, [u]);
+    }
+    return [...byKey.values()];
+  }
+  const order = [...nodes].sort((u, v) => sets.get(v)!.size - sets.get(u)!.size || (u < v ? -1 : u > v ? 1 : 0));
+  const modules: string[][] = [];
+  for (const u of order) {
+    const home = modules.find((m) => !sets.get(m[0]!)!.has(u) && jaccardIndex(sets.get(m[0]!)!, sets.get(u)!) >= jaccard);
+    if (home) home.push(u);
+    else modules.push([u]);
+  }
+  return modules.map((m) => [...m].sort());
+}
+
+/**
+ * This function gives the highways of the edge compression with modules and power graphs (HWY-014, Dwyer, Henry Riche, Marriott and Mears 2013).
+ * The edges between two modules are one power edge. With modules of the rule `exact`, each node of one module links to each node of the other.
+ * A power edge that saves `minSaved` edges or more is one highway from module to module.
+ * Its trunk goes between the Weber points of the two ends.
+ * The search does not nest modules, so it finds no power edge inside a power edge.
+ */
+export function powerPlan(input: HighwayInput, o: Readonly<PowerOptions>): HighwayPlan {
+  const groups = new Map<string, EdgeGroup>();
+  const sourceOf = new Map(input.graph.edges.map((e) => [e.id, e.source.node] as const));
+  for (const scope of nodeLinks(input.graph, o.scope)) {
+    const modules = modulesOf(scope.links, o.modules, o.jaccard);
+    const moduleOf = new Map<string, number>();
+    modules.forEach((m, i) => {
+      for (const u of m) moduleOf.set(u, i);
+    });
+    // The edges between each pair of modules, with the smaller index first.
+    const between = new Map<string, { i: number; j: number; edges: string[] }>();
+    for (const [u, m] of scope.links)
+      for (const [v, edges] of m) {
+        const i = moduleOf.get(u)!;
+        const j = moduleOf.get(v)!;
+        if (i >= j) continue;
+        const key = `${i},${j}`;
+        let p = between.get(key);
+        if (!p) between.set(key, (p = { i, j, edges: [] }));
+        for (const e of edges) if (!p.edges.includes(e)) p.edges.push(e);
+      }
+    const pairs = [...between.values()].sort((p, q) => q.edges.length - p.edges.length || p.i - q.i || p.j - q.j);
+    for (const p of pairs) {
+      if (p.edges.length - 1 < Math.max(1, o.minSaved)) continue;
+      const first = new Set(modules[p.i]);
+      const key = `p${scope.key}/${p.i}-${p.j}`;
+      for (const e of p.edges) if (!groups.has(e)) groups.set(e, { key, flip: !first.has(sourceOf.get(e)!) });
+    }
+  }
+  return groupedPlan(input, groups, {
+    ...(o.margin === undefined ? {} : { margin: o.margin }),
+    ...(o.k === undefined ? {} : { k: o.k }),
+    spine: o.spine,
+    minSize: 2,
+    legMax: o.legMax,
+  });
+}

package/src/highways/resistance/index.ts

@@ -0,0 +1,159 @@
+import { rng } from "../../fixtures.ts";
+import type { Graph } from "../../model.ts";
+import { groupedPlan, type EdgeGroup } from "../grouped.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { compatibilityMatrix, edgeBlocks, edgeEnds, labelGroups, spectralLabels, type SpectralOptions } from "../spectral/index.ts";
+
+/** The options of the highway strategy `resistance` (HWY-021 of the note on highways). */
+export interface ResistanceOptions extends SpectralOptions {
+  /** The number of random projections of the estimate of the resistance. The default is 16. */
+  readonly projections: number;
+  /** The weight of the resistance, from 0 to 1. A pair with `C >= c0` gets the weight `C (1 - weight R_e R_f)`. The default is 0.5. */
+  readonly weight: number;
+  /** With `true`, an edge with a resistance of 0.99 or more (a bridge) gets no pair. The default is `false`. */
+  readonly sparsify: boolean;
+}
+
+/** The default options of the strategy `resistance`. */
+export const RESISTANCE_DEFAULTS: Readonly<ResistanceOptions> = Object.freeze({
+  c0: 0.5,
+  clusters: 0,
+  kMax: 16,
+  minSize: 2,
+  spine: "trunk",
+  projections: 16,
+  weight: 0.5,
+  sparsify: false,
+});
+
+/** The seed of the random projections. One seed gives the same estimate each time. */
+const SEED = 21;
+
+/** A resistance of this value or more marks a bridge. */
+const BRIDGE = 0.99;
+
+/**
+ * This function solves `L z = y` with the method of conjugate gradients. `L` is the Laplacian of the graph, and `y` has a sum of 0 on each connected part.
+ * The result has a mean of 0 on each connected part.
+ */
+function solveLaplacian(n: number, adj: readonly (readonly number[])[], y: Float64Array, part: Int32Array, parts: number): Float64Array {
+  const mul = (v: Float64Array, out: Float64Array): void => {
+    for (let i = 0; i < n; i++) {
+      let s = adj[i]!.length * v[i]!;
+      for (const j of adj[i]!) s -= v[j]!;
+      out[i] = s;
+    }
+  };
+  const centre = (v: Float64Array): void => {
+    const sum = new Float64Array(parts);
+    const size = new Float64Array(parts);
+    for (let i = 0; i < n; i++) {
+      sum[part[i]!] = sum[part[i]!]! + v[i]!;
+      size[part[i]!] = size[part[i]!]! + 1;
+    }
+    for (let i = 0; i < n; i++) v[i] = v[i]! - sum[part[i]!]! / size[part[i]!]!;
+  };
+  const z = new Float64Array(n);
+  const r = Float64Array.from(y);
+  centre(r);
+  const p = Float64Array.from(r);
+  const lp = new Float64Array(n);
+  let rr = r.reduce((s, v) => s + v * v, 0);
+  const stop = 1e-20 * Math.max(1, rr);
+  for (let iter = 0; iter < 4 * n + 20 && rr > stop; iter++) {
+    mul(p, lp);
+    const pl = p.reduce((s, v, i) => s + v * lp[i]!, 0);
+    if (pl <= 0) break;
+    const a = rr / pl;
+    for (let i = 0; i < n; i++) {
+      z[i] = z[i]! + a * p[i]!;
+      r[i] = r[i]! - a * lp[i]!;
+    }
+    const next = r.reduce((s, v) => s + v * v, 0);
+    const b = next / rr;
+    rr = next;
+    for (let i = 0; i < n; i++) p[i] = r[i]! + b * p[i]!;
+  }
+  centre(z);
+  return z;
+}
+
+/**
+ * This function gives an estimate of the effective resistance of each edge of the graph (Spielman and Srivastava 2011).
+ * It takes `k` random vectors `q` of the values `±1/√k` on the edges. It solves `L z = Bᵀ q` for each vector. Then `R(u, v) ≈ Σ (z_u - z_v)²`.
+ * The value is from 0 to 1. A loop and an edge with an unknown node get 0. Parallel edges share the current, so each gets a lower value.
+ */
+export function edgeResistance(graph: Graph, projections: number): Map<string, number> {
+  const index = new Map(graph.nodes.map((v, i) => [v.id, i] as const));
+  const n = graph.nodes.length;
+  const adj: number[][] = graph.nodes.map(() => []);
+  const ends: { id: string; u: number; v: number }[] = [];
+  for (const e of graph.edges) {
+    const u = index.get(e.source.node);
+    const v = index.get(e.target.node);
+    if (u === undefined || v === undefined || u === v) continue;
+    adj[u]!.push(v);
+    adj[v]!.push(u);
+    ends.push({ id: e.id, u, v });
+  }
+  // The connected parts of the graph.
+  const part = new Int32Array(n).fill(-1);
+  let parts = 0;
+  for (let i = 0; i < n; i++) {
+    if (part[i]! >= 0) continue;
+    const stack = [i];
+    part[i] = parts;
+    while (stack.length > 0) {
+      const a = stack.pop()!;
+      for (const b of adj[a]!)
+        if (part[b]! < 0) {
+          part[b] = parts;
+          stack.push(b);
+        }
+    }
+    parts++;
+  }
+  const k = Math.max(1, Math.round(projections));
+  const random = rng(SEED);
+  const sum = new Float64Array(ends.length);
+  for (let r = 0; r < k; r++) {
+    const y = new Float64Array(n);
+    for (const { u, v } of ends) {
+      const q = (random() < 0.5 ? -1 : 1) / Math.sqrt(k);
+      y[u] = y[u]! + q;
+      y[v] = y[v]! - q;
+    }
+    const z = solveLaplacian(n, adj, y, part, parts);
+    ends.forEach(({ u, v }, i) => {
+      sum[i] = sum[i]! + (z[u]! - z[v]!) ** 2;
+    });
+  }
+  const out = new Map<string, number>(graph.edges.map((e) => [e.id, 0] as const));
+  ends.forEach(({ id }, i) => out.set(id, Math.max(0, Math.min(1, sum[i]!))));
+  return out;
+}
+
+/**
+ * This function gives the clusters of the edges with the compatibility scaled by the resistance (HWY-021).
+ * The compatibility of a pair is `C (1 - weight R_e R_f)`. A pair of two bridges thus gets a lower value. Then the spectral clusters of `spectral` apply.
+ */
+export function resistanceClusters(input: HighwayInput, o: Readonly<ResistanceOptions>): Map<string, EdgeGroup> {
+  const resistance = edgeResistance(input.graph, o.projections);
+  const weight = Math.max(0, Math.min(1, o.weight));
+  const groups = new Map<string, EdgeGroup>();
+  edgeBlocks(edgeEnds(input)).forEach((block, b) => {
+    const r = block.map((e) => resistance.get(e.edge) ?? 0);
+    const scale = (i: number, j: number): number => (o.sparsify && (r[i]! >= BRIDGE || r[j]! >= BRIDGE) ? 0 : 1 - weight * r[i]! * r[j]!);
+    const labels = spectralLabels(block.length, compatibilityMatrix(block, o.c0, scale), o);
+    labelGroups(block, labels, `p${b}:`, groups);
+  });
+  return groups;
+}
+
+/**
+ * This function gives the highways of the spectral clusters of the compatibility graph with the weights of the effective resistance (HWY-021).
+ * The clusters with `minSize` edges or more get highways.
+ */
+export function resistancePlan(input: HighwayInput, o: Readonly<ResistanceOptions>): HighwayPlan {
+  return groupedPlan(input, resistanceClusters(input, o), { spine: o.spine, minSize: Math.max(2, Math.round(o.minSize)) });
+}

package/src/highways/sbeb/index.ts

@@ -0,0 +1,303 @@
+import { boardUnit } from "../../bench/measures/routes.ts";
+import { dist, type Point } from "../../geom.ts";
+import { byCollection } from "../../routers/trunks.ts";
+import { WayFinder, type WayOptions } from "../../ways.ts";
+import { firstRoutes } from "../base.ts";
+import type { EdgeGroup } from "../grouped.ts";
+import type { DensityGrid, DensitySource } from "../kdeeb/index.ts";
+import type { HighwayInput, HighwayPlan } from "../model.ts";
+import { QUICKBUNDLES_DEFAULTS, quickBundles, resample } from "../quickbundles/index.ts";
+import { edgePlugs } from "../stretches.ts";
+import { outOfBoxes, tracePlan } from "../trace.ts";
+
+/** The clusterer that gives the groups of edges: QuickBundles (HWY-026) with its defaults, or the collection of each edge. */
+export type SkeletonGroups = "quickbundles" | "keys";
+
+/** The values of `SkeletonGroups`. */
+export const SKELETON_GROUPS: readonly SkeletonGroups[] = Object.freeze(["quickbundles", "keys"]);
+
+/** The point that each sample point moves toward: the nearest point of the skeleton of its group, or of the mean polyline of its group. */
+export type SkeletonTarget = "skeleton" | "mean";
+
+/** The values of `SkeletonTarget`. */
+export const SKELETON_TARGETS: readonly SkeletonTarget[] = Object.freeze(["skeleton", "mean"]);
+
+/** The options of the highway strategy `sbeb` (HWY-009 of the notes). */
+export interface SbebOptions extends Pick<WayOptions, "margin" | "k"> {
+  /** The clusterer of the groups. The default is `quickbundles`. */
+  readonly group: SkeletonGroups;
+  /** The first lines of the edges: their straight lines, or their first routes. The default is `lines`. */
+  readonly source: DensitySource;
+  /** The radius of the shape of a group, as a multiple of `boardUnit`. The default is 1.5. */
+  readonly radius: number;
+  /** The share of the distance to the target that a point moves in one step, from 0 to 1. The default is 0.5. */
+  readonly attraction: number;
+  /** The number of steps. The default is 4. */
+  readonly steps: number;
+  /** The share of the Laplacian smoothing of each polyline after each step, from 0 to 1. The default is 0.5. */
+  readonly smoothing: number;
+  /** The target of the points. The default is `skeleton`. */
+  readonly target: SkeletonTarget;
+  /** The side of a cell of the image of the shape, in units of the board. A large shape gets larger cells, up to 256 cells on a side. The default is 4. */
+  readonly cell: number;
+  /** The side of the grid that the points of the edges snap to after the steps, in units of the board. The default is 8. */
+  readonly snap: number;
+  /** A group with this number of edges or more moves, and a highway has this number of edges or more. The default is 2. */
+  readonly minSize: number;
+}
+
+/** The default options of the strategy `sbeb`. */
+export const SBEB_DEFAULTS: Readonly<Required<Omit<SbebOptions, "margin" | "k">>> = Object.freeze({
+  group: "quickbundles",
+  source: "lines",
+  radius: 1.5,
+  attraction: 0.5,
+  steps: 4,
+  smoothing: 0.5,
+  target: "skeleton",
+  cell: 4,
+  snap: 8,
+  minSize: 2,
+});
+
+/** This function gives the group of each edge: the clusters of QuickBundles, or the collection of the edge. An edge without a collection has no group with `keys`. */
+export function skeletonGroups(input: HighwayInput, group: SkeletonGroups): Map<string, EdgeGroup> {
+  if (group === "quickbundles") return quickBundles(input, QUICKBUNDLES_DEFAULTS);
+  const out = new Map<string, EdgeGroup>();
+  for (const e of input.graph.edges) {
+    const key = byCollection(e);
+    if (key !== undefined) out.set(e.id, { key, flip: false });
+  }
+  return out;
+}
+
+/** This function gives the first line of each edge. The line goes from a point at `margin` out of the source plug to a point at `margin` out of the target plug. */
+export function firstLines(input: HighwayInput, finder: WayFinder, source: DensitySource, spacing: number): Map<string, Point[]> {
+  const routes = source === "routes" ? firstRoutes(input) : undefined;
+  const out = new Map<string, Point[]>();
+  for (const { edge, ps, pt } of edgePlugs(input.graph)) {
+    const a = finder.out(ps);
+    const b = finder.out(pt);
+    const route = routes?.get(edge.id);
+    const base = route && route.length > 2 ? [a, ...route.slice(1, -1), b] : [a, b];
+    let len = 0;
+    for (let i = 1; i < base.length; i++) len += dist(base[i - 1]!, base[i]!);
+    out.set(edge.id, resample(base, Math.max(2, Math.min(129, Math.ceil(len / Math.max(1e-3, spacing)) + 1))));
+  }
+  return out;
+}
+
+/** The image of the shape of a group and its skeleton. */
+export interface ShapeSkeleton {
+  readonly grid: DensityGrid;
+  /** The distance of each cell to the nearest cell outside the shape, in cells. A cell outside the shape has 0. */
+  readonly depth: Float64Array;
+  /** The value is 1 for each cell of the skeleton. */
+  readonly skeleton: Uint8Array;
+}
+
+/** This function gives the distance from the point `p` to the segment from `a` to `b`. */
+function segDist(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 u = l2 > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2)) : 0;
+  return Math.hypot(p.x - a.x - u * dx, p.y - a.y - u * dy);
+}
+
+/** The steps to the 8 neighbours of a cell, as pairs of opposite steps: along x, along y and along the two diagonals. */
+const PAIRS: readonly (readonly [number, number])[] = [
+  [1, 0],
+  [0, 1],
+  [1, 1],
+  [1, -1],
+];
+
+/**
+ * This function gives the shape of a group and its skeleton (its medial axis). The shape is the union of the disks of radius `radius` along the lines, minus the boxes.
+ * The depth is a chamfer distance transform with the steps 1 and √2. A cell is on the skeleton when two conditions are true.
+ * Its depth is half of `radius` or more. Its depth is a ridge along one of the four pairs of opposite neighbours.
+ * A ridge is not lower than the two neighbours, and it is higher than one of them.
+ */
+export function shapeSkeleton(lines: readonly (readonly Point[])[], finder: WayFinder, radius: number, cell: number): ShapeSkeleton {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const l of lines)
+    for (const p of l) {
+      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 pad = radius + 2 * Math.max(1e-3, cell);
+  const c = Math.max(1e-3, cell, (x1 - x0 + 2 * pad) / 256, (y1 - y0 + 2 * pad) / 256);
+  const grid: DensityGrid = { cell: c, x0: x0 - pad, y0: y0 - pad, w: Math.max(1, Math.ceil((x1 - x0 + 2 * pad) / c)), h: Math.max(1, Math.ceil((y1 - y0 + 2 * pad) / c)) };
+  const { w, h } = grid;
+  const inside = new Uint8Array(w * h);
+  const mid = (x: number, y: number): Point => ({ x: grid.x0 + (x + 0.5) * c, y: grid.y0 + (y + 0.5) * c });
+  for (const l of lines)
+    for (let i = 1; i < l.length; i++) {
+      const a = l[i - 1]!;
+      const b = l[i]!;
+      const gx0 = Math.max(0, Math.floor((Math.min(a.x, b.x) - radius - grid.x0) / c));
+      const gx1 = Math.min(w - 1, Math.floor((Math.max(a.x, b.x) + radius - grid.x0) / c));
+      const gy0 = Math.max(0, Math.floor((Math.min(a.y, b.y) - radius - grid.y0) / c));
+      const gy1 = Math.min(h - 1, Math.floor((Math.max(a.y, b.y) + radius - grid.y0) / c));
+      for (let y = gy0; y <= gy1; y++) for (let x = gx0; x <= gx1; x++) if (!inside[y * w + x] && segDist(mid(x, y), a, b) <= radius) inside[y * w + x] = 1;
+    }
+  const boxPad = finder.margin / 2;
+  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) if (inside[y * w + x] && finder.obstacles.inside(mid(x, y), boxPad)) inside[y * w + x] = 0;
+  // The chamfer distance transform: one pass forward and one pass backward.
+  const depth = new Float64Array(w * h);
+  for (let i = 0; i < w * h; i++) depth[i] = inside[i] ? Infinity : 0;
+  const at = (x: number, y: number): number => (x < 0 || y < 0 || x >= w || y >= h ? 0 : depth[y * w + x]!);
+  const D = Math.SQRT2;
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      const i = y * w + x;
+      if (!inside[i]) continue;
+      depth[i] = Math.min(depth[i]!, at(x - 1, y) + 1, at(x, y - 1) + 1, at(x - 1, y - 1) + D, at(x + 1, y - 1) + D);
+    }
+  for (let y = h - 1; y >= 0; y--)
+    for (let x = w - 1; x >= 0; x--) {
+      const i = y * w + x;
+      if (!inside[i]) continue;
+      depth[i] = Math.min(depth[i]!, at(x + 1, y) + 1, at(x, y + 1) + 1, at(x + 1, y + 1) + D, at(x - 1, y + 1) + D);
+    }
+  const skeleton = new Uint8Array(w * h);
+  const least = Math.max(1, (0.5 * radius) / c);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      const v = depth[y * w + x]!;
+      if (v < least) continue;
+      for (const [dx, dy] of PAIRS) {
+        const p = at(x + dx, y + dy);
+        const q = at(x - dx, y - dy);
+        if (v >= p && v >= q && (v > p || v > q)) {
+          skeleton[y * w + x] = 1;
+          break;
+        }
+      }
+    }
+  return { grid, depth, skeleton };
+}
+
+/** This function gives the middle of the skeleton cell nearest to `p`, within `reach` in units of the board, or `undefined`. */
+export function nearestSkeleton(s: ShapeSkeleton, p: Point, reach: number): Point | undefined {
+  const { grid: g, skeleton } = s;
+  const cx = Math.floor((p.x - g.x0) / g.cell);
+  const cy = Math.floor((p.y - g.y0) / g.cell);
+  const r = Math.ceil(reach / g.cell);
+  let best: Point | undefined;
+  let bestD = Infinity;
+  for (let y = Math.max(0, cy - r); y <= Math.min(g.h - 1, cy + r); y++)
+    for (let x = Math.max(0, cx - r); x <= Math.min(g.w - 1, cx + r); x++) {
+      if (!skeleton[y * g.w + x]) continue;
+      const q = { x: g.x0 + (x + 0.5) * g.cell, y: g.y0 + (y + 0.5) * g.cell };
+      const d = dist(p, q);
+      if (d < bestD && d <= reach) [best, bestD] = [q, d];
+    }
+  return best;
+}
+
+/** This function gives the mean polyline of lines in one direction, with `k` points. */
+export function meanLine(lines: readonly (readonly Point[])[], k: number): Point[] {
+  const n = Math.max(2, Math.round(k));
+  const sum = Array.from({ length: n }, () => ({ x: 0, y: 0 }));
+  for (const l of lines)
+    resample(l, n).forEach((p, i) => {
+      sum[i]!.x += p.x;
+      sum[i]!.y += p.y;
+    });
+  return sum.map((p) => ({ x: p.x / Math.max(1, lines.length), y: p.y / Math.max(1, lines.length) }));
+}
+
+/** This function gives the point of a polyline nearest to `p`. */
+export function nearestOnLine(line: readonly Point[], p: Point): Point {
+  let best = line[0]!;
+  let bestD = dist(p, best);
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1]!;
+    const b = line[i]!;
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const l2 = dx * dx + dy * dy;
+    const u = l2 > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l2)) : 0;
+    const q = { x: a.x + u * dx, y: a.y + u * dy };
+    const d = dist(p, q);
+    if (d < bestD) [best, bestD] = [q, d];
+  }
+  return best;
+}
+
+/** This function gives the groups with `min` edges or more, as lists of edges. The groups are in the order of their first edges. */
+export function bigGroups(groups: ReadonlyMap<string, EdgeGroup>, min: number): { key: string; edges: { edge: string; flip: boolean }[] }[] {
+  const byKey = new Map<string, { edge: string; flip: boolean }[]>();
+  for (const [edge, g] of groups) {
+    const list = byKey.get(g.key);
+    if (list) list.push({ edge, flip: g.flip });
+    else byKey.set(g.key, [{ edge, flip: g.flip }]);
+  }
+  return [...byKey]
+    .filter(([, list]) => list.length >= Math.max(2, min))
+    .map(([key, edges]) => ({ key, edges }));
+}
+
+/**
+ * This function gives the polylines of the skeleton-based edge bundling (SBEB, Ersoy, Hurter, Paulovich, Cantareiro and Telea 2011). The ends of each polyline stay.
+ * In each step, each group of `minSize` edges or more draws its shape, and each inner point moves the share `attraction` toward its target.
+ * The share falls to 0 at the distance `2 radius`. A Laplacian smoothing keeps each polyline smooth, and a point in a box moves out of it.
+ * The edges outside such a group do not move.
+ */
+export function sbebLines(input: HighwayInput, finder: WayFinder, o: Readonly<SbebOptions>): Map<string, Point[]> {
+  const radius = Math.max(1e-3, o.radius * boardUnit(input.graph));
+  const lines = firstLines(input, finder, o.source, Math.max(4, 2 * o.cell));
+  const groups = bigGroups(skeletonGroups(input, o.group), o.minSize).map((g) => ({ ...g, edges: g.edges.filter((m) => lines.has(m.edge)) }));
+  const pad = finder.margin / 2;
+  const a = Math.max(0, Math.min(1, o.attraction));
+  const smooth = Math.max(0, Math.min(1, o.smoothing));
+  for (let step = 0; step < Math.max(0, Math.round(o.steps)); step++) {
+    for (const g of groups) {
+      if (g.edges.length < 2) continue;
+      const own = g.edges.map((m) => lines.get(m.edge)!);
+      const target: (p: Point) => Point | undefined =
+        o.target === "mean"
+          ? ((mean) => (p: Point) => nearestOnLine(mean, p))(meanLine(g.edges.map((m, i) => (m.flip ? [...own[i]!].reverse() : own[i]!)), 33))
+          : ((s) => (p: Point) => nearestSkeleton(s, p, 2 * radius))(shapeSkeleton(own, finder, radius, o.cell));
+      g.edges.forEach((m, i) => {
+        const l = own[i]!;
+        const moved = l.map((p, j) => {
+          if (j === 0 || j === l.length - 1) return p;
+          const s = target(p);
+          if (!s) return p;
+          const k = a * Math.max(0, 1 - dist(p, s) / (2 * radius));
+          return { x: p.x + k * (s.x - p.x), y: p.y + k * (s.y - p.y) };
+        });
+        const smoothed = moved.map((p, j) => {
+          if (j === 0 || j === moved.length - 1 || smooth === 0) return p;
+          const u = moved[j - 1]!;
+          const v = moved[j + 1]!;
+          return { x: (1 - smooth) * p.x + (smooth * (u.x + v.x)) / 2, y: (1 - smooth) * p.y + (smooth * (u.y + v.y)) / 2 };
+        });
+        lines.set(
+          m.edge,
+          smoothed.map((p, j) => (j === 0 || j === smoothed.length - 1 ? p : outOfBoxes(finder.obstacles, p, pad))),
+        );
+      });
+    }
+  }
+  return lines;
+}
+
+/**
+ * This function gives the highways of the skeleton-based edge bundling (HWY-009). The points of `sbebLines` snap to a grid of side `snap`.
+ * The ways go through the corner graph, and each stretch that `minSize` ways share is a highway.
+ */
+export function sbebPlan(input: HighwayInput, o: Readonly<SbebOptions>): HighwayPlan {
+  const finder = new WayFinder(input.graph.nodes, { ...(o.margin === undefined ? {} : { margin: o.margin }), ...(o.k === undefined ? {} : { k: o.k }) });
+  const lines = sbebLines(input, finder, o);
+  const waypoints = new Map([...lines].map(([edge, l]) => [edge, l.slice(1, -1)] as const));
+  return tracePlan(input, finder, waypoints, { snap: o.snap, minSize: o.minSize, key: "sbeb" });
+}