@mark1russell7/highways 0.1.3 → 0.1.4

package/src/curves/spline/index.ts

@@ -0,0 +1,77 @@
+import { dist, type Point } from "../../geom.ts";
+import { distinctPoints, type CurveSegment } from "../model.ts";
+import { fitSize, type CurveSpace } from "../space.ts";
+
+/** The options of `splineCurve`. */
+export interface SplineOptions {
+  /**
+   * The tension of the spline, from 0 to 1. The value 0 gives the centripetal Catmull-Rom spline, and 1 gives the polyline.
+   * The default is 0.
+   */
+  readonly tension?: number;
+  /** The outward normal of the plug at the first point. With it, the curve leaves the first point along this normal. */
+  readonly startNormal?: Point;
+  /** The outward normal of the plug at the last point. With it, the curve comes into the last point against this normal. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through. Without it, each piece gets the full tangents. */
+  readonly space?: CurveSpace;
+}
+
+/**
+ * This function draws a centripetal Catmull-Rom spline through the points of a polyline (Yuksel, Schaefer and Keyser, 2011).
+ * Each piece between two points is one cubic Bezier curve. The centripetal knots keep the curve free of cusps and loops in a piece.
+ * The curve goes through each point. Its tangent at a point keeps one direction on the two sides of the point.
+ *
+ * With `space`, the function makes the tangents of a piece shorter until the piece goes through no box that its leg avoids.
+ * A piece with no tangent is the straight leg.
+ */
+export function splineCurve(points: readonly Point[], options: SplineOptions = {}): CurveSegment[] {
+  const p = distinctPoints(points);
+  if (p.length === 0) return [];
+  const out: CurveSegment[] = [{ kind: "move", to: p[0]! }];
+  const n = p.length;
+  if (n === 1) return out;
+  const scale = 1 - Math.max(0, Math.min(1, options.tension ?? 0));
+  // The knot interval of each leg is the square root of its length.
+  const dt = Array.from({ length: n - 1 }, (_, i) => Math.sqrt(dist(p[i]!, p[i + 1]!)));
+  const unit = (q: Point): Point => {
+    const l = Math.hypot(q.x, q.y);
+    return l === 0 ? { x: 0, y: 0 } : { x: q.x / l, y: q.y / l };
+  };
+  // The tangent at each point, as a speed in the parameter of the knots.
+  const m: Point[] = p.map((v, i) => {
+    if (i === 0) {
+      const leg = { x: p[1]!.x - v.x, y: p[1]!.y - v.y };
+      if (!options.startNormal) return { x: leg.x / dt[0]!, y: leg.y / dt[0]! };
+      const u = unit(options.startNormal);
+      return { x: u.x * dt[0]!, y: u.y * dt[0]! };
+    }
+    if (i === n - 1) {
+      const a = p[i - 1]!;
+      const leg = { x: v.x - a.x, y: v.y - a.y };
+      if (!options.endNormal) return { x: leg.x / dt[i - 1]!, y: leg.y / dt[i - 1]! };
+      const u = unit(options.endNormal);
+      return { x: -u.x * dt[i - 1]!, y: -u.y * dt[i - 1]! };
+    }
+    const a = p[i - 1]!;
+    const b = p[i + 1]!;
+    const t0 = dt[i - 1]!;
+    const t1 = dt[i]!;
+    return {
+      x: (v.x - a.x) / t0 - (b.x - a.x) / (t0 + t1) + (b.x - v.x) / t1,
+      y: (v.y - a.y) / t0 - (b.y - a.y) / (t0 + t1) + (b.y - v.y) / t1,
+    };
+  });
+  for (let i = 0; i + 1 < n; i++) {
+    const a = p[i]!;
+    const b = p[i + 1]!;
+    const h = dt[i]! / 3;
+    const piece = (s: number): CurveSegment[] => [
+      { kind: "move", to: a },
+      { kind: "cubic", c1: { x: a.x + m[i]!.x * h * s, y: a.y + m[i]!.y * h * s }, c2: { x: b.x - m[i + 1]!.x * h * s, y: b.y - m[i + 1]!.y * h * s }, to: b },
+    ];
+    const s = fitSize(options.space, scale, () => [a, b], piece);
+    out.push(s > 0 ? piece(s)[1]! : { kind: "line", to: b });
+  }
+  return out;
+}

package/src/curves/straight/index.ts

@@ -0,0 +1,7 @@
+import type { Point } from "../../geom.ts";
+import type { CurveSegment } from "../model.ts";
+
+/** This function gives the polyline as it is: one `move` to the first point and one `line` to each other point. */
+export function straightCurve(points: readonly Point[]): CurveSegment[] {
+  return points.map((to, i): CurveSegment => (i === 0 ? { kind: "move", to } : { kind: "line", to }));
+}

package/src/index.ts

@@ -5,12 +5,16 @@ export * from "./fixtures.ts";
 export * from "./cases.ts";
 export * from "./plugs.ts";
 export * from "./curves.ts";
+export * from "./curves/index.ts";
 export * from "./visibility.ts";
 export * from "./ways.ts";
 export * from "./segments.ts";
 export * from "./sections.ts";
 export * from "./routers/index.ts";
+export * from "./room/index.ts";
 export * from "./bench/properties.ts";
 export * from "./bench/quality.ts";
 export * from "./bench/links.ts";
 export * from "./bench/run.ts";
+export * from "./bench/curves.ts";
+export * from "./bench/room.ts";

package/src/levels.ts

@@ -99,6 +99,7 @@ function sideWay(ways: LevelWays, s: Node, t: Node, inset: number): Point[] {
 /**
  * This function makes the obstacles and the corner graph of the items of a level.
  * The buckets of the obstacles grow with the items, so a long link visits few buckets.
+ * The corner graphs use `cones`, so a link goes along the corridors between the groups, not around the outer edge of the board.
  */
 function levelWays(nodes: readonly Node[], options: WayOptions): LevelWays {
   const margin = options.margin ?? 5;
@@ -106,10 +107,10 @@ function levelWays(nodes: readonly Node[], options: WayOptions): LevelWays {
   let size = 0;
   for (const n of nodes) size += Math.max(n.box.w, n.box.h);
   const obstacles = new Obstacles(nodes, Math.max(180, (2 * size) / Math.max(1, nodes.length)));
-  const corners = new CornerGraph(nodes, obstacles, { margin, k });
+  const corners = new CornerGraph(nodes, obstacles, { margin, k, cones: true });
   const out = (p: Plug): Point => ({ x: p.point.x + p.normal.x * margin, y: p.point.y + p.normal.y * margin });
   let tight: CornerGraph | undefined;
-  const tightGraph = (): CornerGraph => (tight ??= new CornerGraph(nodes, obstacles, { margin: Math.min(margin, TIGHT_MARGIN), k }));
+  const tightGraph = (): CornerGraph => (tight ??= new CornerGraph(nodes, obstacles, { margin: Math.min(margin, TIGHT_MARGIN), k, cones: true }));
   return { obstacles, corners, margin, out, tight: tightGraph, free: new Map() };
 }
 

package/src/room/index.ts

@@ -0,0 +1,334 @@
+import { center, type Box, type Point } from "../geom.ts";
+import { levelLinks } from "../levels.ts";
+import type { Edge, Graph, Router } from "../model.ts";
+
+/** An item with a box: a node of a graph, an item of a level or a box of a host layout. */
+export interface Boxed {
+  readonly id: string;
+  readonly box: Box;
+}
+
+/** A link between two boxes. For a bundled link, `count` is the number of its edges. The default count is 1. */
+export interface RoomLink {
+  readonly source: string;
+  readonly target: string;
+  readonly count?: number;
+}
+
+/**
+ * A gap of a board: a boundary of the sweep over the left or top edges of the boxes.
+ * On the axis `x`, the gap is a vertical channel between two columns. On the axis `y`, it is a horizontal channel between two rows.
+ */
+export interface Gap {
+  readonly axis: "x" | "y";
+  /** The place of the gap in the order of the gaps on its axis, from 0. */
+  readonly index: number;
+  /** The coordinate where the boxes after the gap start, on the axis of the gap. */
+  readonly at: number;
+  /** The ids of the boxes that end at the near side of the gap. */
+  readonly before: readonly string[];
+  /** The ids of the boxes that start at the far side of the gap, at `at`. */
+  readonly after: readonly string[];
+  /** The current width of the gap: the distance from the nearest box edge before the gap to `at`. */
+  readonly width: number;
+  /** The number of lanes that the links need in the gap. */
+  readonly lanes: number;
+  /** The width that the gap needs: at least the current width, and at least `gutter + lanes × spacing`. */
+  readonly need: number;
+}
+
+/** The ways that `roomDemand` finds the lanes of each gap. */
+export type RoomMethod = "routes" | "lines";
+
+/** The options of `roomDemand` and `makeRoom`. */
+export interface RoomOptions {
+  /** The smallest width of each gap. The default is 8. */
+  readonly gutter?: number;
+  /** The width of one lane: the distance between two lines that run side by side. The default is 4. */
+  readonly spacing?: number;
+  /**
+   * The largest growth of the board on each axis, as a share of its size. The default is `Infinity`.
+   * When the lanes need more, each gap gets its gutter, and the lanes share the rest in proportion.
+   */
+  readonly maxGrowth?: number;
+  /**
+   * The way to find the lanes. The default is `routes`.
+   * With `routes`, the function routes the links one time on the board with each gap open to the gutter.
+   * The lanes of a gap are the most routes that run along the gap side by side.
+   * With `lines`, the lanes of a gap are the straight lines between the centers of the boxes that cross the gap.
+   */
+  readonly method?: RoomMethod;
+  /** The router of the method `routes`. Without it, the links go as the links of a zoom level (`levelLinks`), with the margin `gutter / 2`. */
+  readonly router?: Router;
+  /** With `count`, a link takes one lane for each of its edges. With `link`, the default, a link takes one lane. */
+  readonly lanes?: "link" | "count";
+  /** Two box edges nearer than this distance make one boundary of the sweep. The default is 0.5. */
+  readonly snap?: number;
+}
+
+/** The demand of a board and the board with its gaps open. */
+export interface Room<T extends Boxed> {
+  readonly gaps: readonly Gap[];
+  readonly items: T[];
+}
+
+const DEFAULT_GUTTER = 8;
+const DEFAULT_SPACING = 4;
+const DEFAULT_SNAP = 0.5;
+
+type Axis = "x" | "y";
+
+const lo = (b: Box, a: Axis): number => (a === "x" ? b.x : b.y);
+const len = (b: Box, a: Axis): number => (a === "x" ? b.w : b.h);
+const other = (a: Axis): Axis => (a === "x" ? "y" : "x");
+
+/**
+ * This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+ * Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
+ */
+export function boardGaps(items: readonly Boxed[], snap: number = DEFAULT_SNAP): Gap[] {
+  return [...axisGaps(items, "x", snap), ...axisGaps(items, "y", snap)];
+}
+
+function axisGaps(items: readonly Boxed[], axis: Axis, snap: number): Gap[] {
+  const starts = [...new Set(items.map((i) => lo(i.box, axis)))].sort((u, v) => u - v);
+  const bounds: number[] = [];
+  for (const s of starts) if (bounds.length === 0 || s - bounds[bounds.length - 1]! > snap) bounds.push(s);
+  const after: string[][] = bounds.map(() => []);
+  for (const i of items) after[lastAtOrBefore(bounds, lo(i.box, axis) + snap)]!.push(i.id);
+  const ends = items.map((i) => ({ id: i.id, end: lo(i.box, axis) + len(i.box, axis) })).sort((u, v) => u.end - v.end);
+  const gaps: Gap[] = [];
+  let k = 0;
+  for (let n = 1; n < bounds.length; n++) {
+    const at = bounds[n]!;
+    // The nearest box edge before the gap is the largest end at or before the boundary.
+    while (k < ends.length && ends[k]!.end <= at + snap) k++;
+    const near = k > 0 ? ends[k - 1]!.end : at;
+    const before: string[] = [];
+    for (let j = k - 1; j >= 0 && ends[j]!.end >= near - snap; j--) before.push(ends[j]!.id);
+    gaps.push({ axis, index: n - 1, at, before: before.reverse(), after: after[n]!, width: Math.max(0, at - near), lanes: 0, need: Math.max(0, at - near) });
+  }
+  return gaps;
+}
+
+/** This function gives the index of the last value of the sorted list `v` that is at or before `x`, or 0. */
+function lastAtOrBefore(v: readonly number[], x: number): number {
+  let a = 0;
+  let b = v.length - 1;
+  while (a < b) {
+    const m = (a + b + 1) >> 1;
+    if (v[m]! <= x) a = m;
+    else b = m - 1;
+  }
+  return a;
+}
+
+/**
+ * This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+ * A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+ * The function moves no box nearer to another box, so it makes no overlap.
+ */
+export function openGaps<T extends Boxed>(items: readonly T[], gaps: readonly Gap[], snap: number = DEFAULT_SNAP): T[] {
+  const shift = (axis: Axis): ((v: number) => number) => {
+    const list = gaps.filter((g) => g.axis === axis).sort((u, v) => u.at - v.at);
+    const at = list.map((g) => g.at);
+    const sum: number[] = [];
+    let s = 0;
+    for (const g of list) sum.push((s += Math.max(0, g.need - g.width)));
+    return (v) => (list.length === 0 || at[0]! > v + snap ? 0 : sum[lastAtOrBefore(at, v + snap)]!);
+  };
+  const sx = shift("x");
+  const sy = shift("y");
+  return items.map((i) => ({ ...i, box: { ...i.box, x: i.box.x + sx(i.box.x), y: i.box.y + sy(i.box.y) } }));
+}
+
+/**
+ * This function gives the room that the links need in each gap of the board.
+ * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+ */
+export function roomDemand(items: readonly Boxed[], links: readonly RoomLink[], options: RoomOptions = {}): Gap[] {
+  const gutter = options.gutter ?? DEFAULT_GUTTER;
+  const spacing = options.spacing ?? DEFAULT_SPACING;
+  const snap = options.snap ?? DEFAULT_SNAP;
+  const weight = (l: RoomLink): number => (options.lanes === "count" ? Math.max(1, l.count ?? 1) : 1);
+  const gaps = boardGaps(items, snap);
+  const lanes = (options.method ?? "routes") === "lines" ? lineLanes(items, links, gaps, weight) : routeLanes(items, links, gaps, gutter, snap, weight, options.router);
+  const raw = gaps.map((g, i) => ({ ...g, lanes: lanes[i]!, need: Math.max(g.width, gutter + lanes[i]! * spacing) }));
+  return capGrowth(items, raw, gutter, options.maxGrowth ?? Infinity);
+}
+
+/** This function gives the demand of the board and the board with each gap open to its need. */
+export function makeRoom<T extends Boxed>(items: readonly T[], links: readonly RoomLink[], options: RoomOptions = {}): Room<T> {
+  const gaps = roomDemand(items, links, options);
+  return { gaps, items: openGaps(items, gaps, options.snap ?? DEFAULT_SNAP) };
+}
+
+/** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
+export function roomLinks(graph: Graph): RoomLink[] {
+  const byPair = new Map<string, { source: string; target: string; count: number }>();
+  for (const e of graph.edges) {
+    const [s, t] = [e.source.node, e.target.node];
+    if (s === t) continue;
+    const key = s < t ? `${s}\u0000${t}` : `${t}\u0000${s}`;
+    const known = byPair.get(key);
+    if (known) known.count++;
+    else byPair.set(key, { source: s, target: t, count: 1 });
+  }
+  return [...byPair.values()];
+}
+
+/** This function counts, for each gap, the straight lines between the centers of the boxes of a link that cross the gap. */
+function lineLanes(items: readonly Boxed[], links: readonly RoomLink[], gaps: readonly Gap[], weight: (l: RoomLink) => number): number[] {
+  const byId = new Map(items.map((i) => [i.id, center(i.box)]));
+  return gaps.map((g) => {
+    let n = 0;
+    for (const l of links) {
+      const a = byId.get(l.source);
+      const b = byId.get(l.target);
+      if (a && b && Math.min(a[g.axis], b[g.axis]) < g.at && Math.max(a[g.axis], b[g.axis]) > g.at) n += weight(l);
+    }
+    return n;
+  });
+}
+
+/**
+ * This function routes the links one time on the board with each gap open to the gutter.
+ * The lanes of a gap are the largest number of routes that run along the gap at one place.
+ * A piece of a route goes along a gap when it is in the channel of the gap.
+ * It must also go farther along the gap than across it.
+ */
+function routeLanes(
+  items: readonly Boxed[],
+  links: readonly RoomLink[],
+  gaps: readonly Gap[],
+  gutter: number,
+  snap: number,
+  weight: (l: RoomLink) => number,
+  router: Router | undefined,
+): number[] {
+  const probeGaps = gaps.map((g) => ({ ...g, need: Math.max(g.width, gutter) }));
+  const probe = openGaps(items, probeGaps, snap);
+  const ways = probeWays(probe, links, gutter, router);
+  return probeGaps.map((g) => {
+    // The channel of the gap on the probe board: its far side moves with the growth of each gap up to this one.
+    let grow = 0;
+    for (const h of probeGaps) if (h.axis === g.axis && h.at <= g.at + snap) grow += h.need - h.width;
+    const hi = g.at + grow;
+    const lo = hi - g.need;
+    const spans: { from: number; to: number; w: number }[] = [];
+    ways.forEach((points, i) => {
+      const along = alongSpans(points, g.axis, lo, hi);
+      for (const [from, to] of merge(along)) spans.push({ from, to, w: weight(links[i]!) });
+    });
+    return density(spans);
+  });
+}
+
+/** This function gives the points of the way of each link on the probe board, in the order of the links. */
+function probeWays(items: readonly Boxed[], links: readonly RoomLink[], gutter: number, router: Router | undefined): (readonly Point[])[] {
+  if (router) {
+    const edges: Edge[] = links.map((l, i) => ({ id: `l${i}`, source: { node: l.source }, target: { node: l.target } }));
+    const routes = new Map(router.route({ nodes: items, edges }).routes.map((r) => [r.edge, r.points]));
+    return edges.map((e) => routes.get(e.id) ?? []);
+  }
+  const level = items.map((i) => ({ id: i.id, box: i.box, nodes: [i.id] }));
+  const pairs = links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 }));
+  // The margin puts the corners of the two sides of a gap on its middle line.
+  const out = levelLinks(level, pairs, { margin: Math.max(1, gutter / 2) });
+  const byPair = new Map(out.map((l) => [`${l.source}\u0000${l.target}`, l.points]));
+  return links.map((l) => byPair.get(`${l.source}\u0000${l.target}`) ?? []);
+}
+
+/**
+ * This function gives the spans along the axis of a gap where the polyline goes along the channel from `lo` to `hi`.
+ * The axis `x` gap is a vertical channel, so its spans are on the y axis.
+ */
+function alongSpans(p: readonly Point[], axis: Axis, lo: number, hi: number): [number, number][] {
+  const across = axis;
+  const along = other(axis);
+  const out: [number, number][] = [];
+  for (let i = 1; i < p.length; i++) {
+    const a = p[i - 1]!;
+    const b = p[i]!;
+    const da = b[across] - a[across];
+    // The part of the segment inside the channel, as the parameters t0 and t1 of the segment.
+    let t0 = 0;
+    let t1 = 1;
+    if (Math.abs(da) < 1e-9) {
+      if (a[across] < lo - 1e-6 || a[across] > hi + 1e-6) continue;
+    } else {
+      const u = (lo - a[across]) / da;
+      const v = (hi - a[across]) / da;
+      t0 = Math.max(0, Math.min(u, v));
+      t1 = Math.min(1, Math.max(u, v));
+      if (t1 <= t0) continue;
+    }
+    const s = a[along] + (b[along] - a[along]) * t0;
+    const e = a[along] + (b[along] - a[along]) * t1;
+    const run = Math.abs(e - s);
+    const cross = Math.abs(da) * (t1 - t0);
+    if (run > cross && run > 1e-6) out.push([Math.min(s, e), Math.max(s, e)]);
+  }
+  return out;
+}
+
+/** This function joins the spans that overlap, so that one link counts one time at each place. */
+function merge(spans: [number, number][]): [number, number][] {
+  spans.sort((u, v) => u[0] - v[0]);
+  const out: [number, number][] = [];
+  for (const s of spans) {
+    const last = out[out.length - 1];
+    if (last && s[0] <= last[1]) last[1] = Math.max(last[1], s[1]);
+    else out.push([s[0], s[1]]);
+  }
+  return out;
+}
+
+/** This function gives the largest sum of the weights of the spans that overlap at one place. Spans that only touch do not overlap. */
+function density(spans: readonly { from: number; to: number; w: number }[]): number {
+  const events: [number, number][] = [];
+  for (const s of spans) events.push([s.from, s.w], [s.to, -s.w]);
+  // At one coordinate, the ends come before the starts.
+  events.sort((u, v) => u[0] - v[0] || u[1] - v[1]);
+  let n = 0;
+  let best = 0;
+  for (const [, w] of events) {
+    n += w;
+    best = Math.max(best, n);
+  }
+  return best;
+}
+
+/**
+ * This function keeps the growth of the board on each axis at most `maxGrowth` times its size.
+ * Each gap keeps its gutter. The lanes of all gaps of the axis share the rest of the growth in proportion.
+ */
+function capGrowth(items: readonly Boxed[], gaps: Gap[], gutter: number, maxGrowth: number): Gap[] {
+  if (!Number.isFinite(maxGrowth)) return gaps;
+  const out = [...gaps];
+  for (const axis of ["x", "y"] as const) {
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    for (const i of items) {
+      x0 = Math.min(x0, lo(i.box, axis));
+      x1 = Math.max(x1, lo(i.box, axis) + len(i.box, axis));
+    }
+    const budget = Math.max(0, maxGrowth) * Math.max(0, x1 - x0);
+    let base = 0;
+    let spare = 0;
+    for (const g of gaps) {
+      if (g.axis !== axis) continue;
+      const b = Math.max(0, gutter - g.width);
+      base += b;
+      spare += Math.max(0, g.need - g.width - b);
+    }
+    if (base + spare <= budget || spare === 0) continue;
+    const f = Math.max(0, (budget - base) / spare);
+    gaps.forEach((g, i) => {
+      if (g.axis !== axis) return;
+      const b = Math.max(0, gutter - g.width);
+      out[i] = { ...g, need: g.width + b + f * Math.max(0, g.need - g.width - b) };
+    });
+  }
+  return out;
+}

package/src/visibility.ts

@@ -86,6 +86,11 @@ export interface CornerGraphOptions {
    * The lattice links groups of nodes across empty space. Without it, the nearest corners of a group are all in that group.
    */
   readonly lattice?: number;
+  /**
+   * With `cones`, each corner also links to the nearest corner that it can see in each of four cones around the axes.
+   * Then a path can go along a long corridor between rows or columns of boxes. The default is false.
+   */
+  readonly cones?: boolean;
 }
 
 /**
@@ -164,7 +169,8 @@ export class CornerGraph {
     }
     const links: Set<number>[] = this.points.map(() => new Set<number>());
     for (let i = 0; i < this.points.length; i++) {
-      for (const j of this.nearestVisible(this.points[i]!, this.#k, i)) {
+      // The k nearest corners of a corner in a long corridor are often all on one side. The cones add a link along the corridor.
+      for (const j of this.#nearestVisible(this.points[i]!, this.#k, i, this.#pad, options.cones ?? false)) {
         links[i]!.add(j);
         links[j]!.add(i);
       }
@@ -221,13 +227,17 @@ export class CornerGraph {
    * within `r` that an earlier ring did not test, nearest first, and equal distances by index.
    * The ring of `r` takes the corners of the buckets that the square of side `2r` around `p` touches.
    * A corner of these buckets beyond `r` waits for the next ring. So the method visits each bucket one time.
+   * With `cones`, the method also gives the nearest visible corner of each of four cones around the axes that the `k` nearest corners leave empty.
    */
-  #nearestVisible(p: Point, k: number, self: number, pad: number): number[] {
+  #nearestVisible(p: Point, k: number, self: number, pad: number, cones = false): number[] {
     const out: number[] = [];
+    // The bits of the full cones: 1 is +x, 2 is +y, 4 is -x and 8 is -y.
+    let full = 0;
     if (this.#dist.length < this.points.length) this.#dist = new Float64Array(this.points.length);
     const dd = this.#dist;
     const points = this.points;
     const cell = this.#cell;
+    const reach = CONE_CELLS * cell;
     const blockers: Node[] = [];
     const now = this.#near;
     // The corners that the rings found beyond their radius. The next ring takes them.
@@ -238,6 +248,8 @@ export class CornerGraph {
     let pj0 = 1;
     let pj1 = 0;
     for (let r = cell; r <= cell * 8; r *= 2) {
+      // The ring of `r` holds the corners beyond `r / 2`. With the k nearest corners, the cones take no corner beyond `reach`.
+      if (out.length >= k && r / 2 >= reach) return out;
       // These bounds are the bounds of a query of the box at (p.x - r, p.y - r) with the side 2r.
       const x0 = p.x - r;
       const y0 = p.y - r;
@@ -273,6 +285,12 @@ export class CornerGraph {
         // A node that stopped an earlier segment often stops this segment too, so the test takes these nodes first.
         // The order of the nodes does not change the result.
         const q = points[j]!;
+        const cone = cones ? coneOf(q.x - p.x, q.y - p.y) : 0;
+        if (out.length >= k) {
+          // After the k nearest corners, only a corner of an empty cone counts, up to `CONE_CELLS` cells from `p`.
+          if (dd[j]! > reach) return out;
+          if ((full & cone) !== 0) continue;
+        }
         let blocked = false;
         for (let b = 0; b < blockers.length && !blocked; b++) blocked = hits(p, q, blockers[b]!, pad);
         if (blocked) continue;
@@ -280,7 +298,8 @@ export class CornerGraph {
         if (hit !== undefined) blockers.push(hit);
         else {
           out.push(j);
-          if (out.length >= k) return out;
+          full |= cone;
+          if (out.length >= k && (!cones || full === 15)) return out;
         }
       }
       wait = later;
@@ -474,6 +493,12 @@ export class CornerGraph {
   }
 }
 
+/** A link of a cone is at most this number of cells long. A longer search costs time on a dense level and finds few new links. */
+const CONE_CELLS = 3;
+
+/** This function gives the bit of the cone of the offset (`dx`, `dy`): 1 is +x, 2 is +y, 4 is -x and 8 is -y. A diagonal offset is in a cone of the x axis. */
+const coneOf = (dx: number, dy: number): number => (Math.abs(dx) >= Math.abs(dy) ? (dx > 0 ? 1 : 4) : dy > 0 ? 2 : 8);
+
 /** This function packs the two indices of a bucket into one number. Each index stays within ±2^20. */
 const bucketKey = (i: number, j: number): number => (i + 1_048_576) * 2_097_152 + (j + 1_048_576);