@mark1russell7/highways 0.1.2 → 0.1.4

package/src/curves/arc/index.ts

@@ -0,0 +1,71 @@
+import { dist, type Point } from "../../geom.ts";
+import { distinctPoints, type CurveSegment } from "../model.ts";
+import { fitSize, type CurveSpace } from "../space.ts";
+
+/** The options of `arcCurve`. */
+export interface ArcOptions {
+  /** The largest radius of the arc at a corner. The default is 12. */
+  readonly radius?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the largest radius that fits on its legs. */
+  readonly space?: CurveSpace;
+}
+
+/** A turn smaller than this angle, in radians, is no corner. A turn nearer to a half turn than this angle stays sharp. */
+const FLAT = 1e-6;
+
+/**
+ * This function puts a circular arc at each inner vertex of a polyline. The arc is tangent to the two legs of its corner.
+ * The tangent points stay on the first half of each leg, so the ends of the polyline stay.
+ * With `space`, the function makes the radius of a corner smaller until the arc goes through no box that the polyline avoids.
+ * On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
+ */
+export function arcCurve(points: readonly Point[], options: ArcOptions = {}): CurveSegment[] {
+  const p = distinctPoints(points);
+  if (p.length === 0) return [];
+  const radius = options.radius ?? 12;
+  const out: CurveSegment[] = [{ kind: "move", to: p[0]! }];
+  for (let i = 1; i + 1 < p.length; i++) {
+    const a = p[i - 1]!;
+    const v = p[i]!;
+    const b = p[i + 1]!;
+    const la = dist(a, v);
+    const lb = dist(v, b);
+    const ux = (v.x - a.x) / la;
+    const uy = (v.y - a.y) / la;
+    const wx = (b.x - v.x) / lb;
+    const wy = (b.y - v.y) / lb;
+    const turn = Math.atan2(ux * wy - uy * wx, ux * wx + uy * wy);
+    if (Math.abs(turn) < FLAT || Math.PI - Math.abs(turn) < FLAT) {
+      out.push({ kind: "line", to: v });
+      continue;
+    }
+    // The tangent points are r·tan(|turn|/2) from the vertex.
+    const k = Math.tan(Math.abs(turn) / 2);
+    const side = Math.sign(turn);
+    const ends = (r: number): [Point, Point] => [
+      { x: v.x - ux * r * k, y: v.y - uy * r * k },
+      { x: v.x + wx * r * k, y: v.y + wy * r * k },
+    ];
+    const piece = (r: number): CurveSegment[] => {
+      const [p1, p2] = ends(r);
+      // The center is on the side of the turn, at the distance r from the first leg.
+      const center = { x: p1.x - side * uy * r, y: p1.y + side * ux * r };
+      return [{ kind: "arc", center, radius: r, start: Math.atan2(p1.y - center.y, p1.x - center.x), sweep: turn, to: p2 }];
+    };
+    const r = fitSize(
+      options.space,
+      Math.min(radius, Math.min(la, lb) / (2 * k)),
+      (s) => [ends(s)[0], v, ends(s)[1]],
+      (s) => [{ kind: "move", to: ends(s)[0] }, ...piece(s)],
+    );
+    if (r <= 0) {
+      out.push({ kind: "line", to: v });
+      continue;
+    }
+    const [p1] = ends(r);
+    if (dist(p1, out[out.length - 1]!.to) > 1e-9) out.push({ kind: "line", to: p1 });
+    out.push(...piece(r));
+  }
+  if (p.length > 1) out.push({ kind: "line", to: p[p.length - 1]! });
+  return out;
+}

package/src/curves/index.ts

@@ -0,0 +1,48 @@
+import type { Point } from "../geom.ts";
+import { arcCurve } from "./arc/index.ts";
+import type { CurveSegment, CurveType } from "./model.ts";
+import { roundedCurve } from "./rounded/index.ts";
+import type { CurveSpace } from "./space.ts";
+import { splineCurve } from "./spline/index.ts";
+import { straightCurve } from "./straight/index.ts";
+
+export * from "./model.ts";
+export { cubicAt, sampleCurve, toSvgPath } from "./sample.ts";
+export { curveSpace, type CurveSpace } from "./space.ts";
+export { straightCurve } from "./straight/index.ts";
+export { roundedCurve, type RoundedOptions } from "./rounded/index.ts";
+export { splineCurve, type SplineOptions } from "./spline/index.ts";
+export { arcCurve, type ArcOptions } from "./arc/index.ts";
+
+/** The options of `curveOf`. Each type reads only the options that it uses. */
+export interface CurveOptions {
+  readonly type: CurveType;
+  /** The types `rounded` and `arc` read this radius of the corners. The default is 12. */
+  readonly radius?: number;
+  /** The type `spline` reads this tension, from 0 to 1. The default is 0. */
+  readonly tension?: number;
+  /** The type `spline` leaves the first point along this outward normal of its plug. */
+  readonly startNormal?: Point;
+  /** The type `spline` comes into the last point against this outward normal of its plug. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. The type `straight` does not read it. */
+  readonly space?: CurveSpace;
+}
+
+/**
+ * This function gives the curve of a route: a polyline of a router, a lane of `laneRoutes` or a link of a zoom level.
+ * The curve starts at the first point and ends at the last point of the polyline.
+ * The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+ */
+export function curveOf(points: readonly Point[], options: CurveOptions): CurveSegment[] {
+  switch (options.type) {
+    case "straight":
+      return straightCurve(points);
+    case "rounded":
+      return roundedCurve(points, options);
+    case "spline":
+      return splineCurve(points, options);
+    case "arc":
+      return arcCurve(points, options);
+  }
+}

package/src/curves/model.ts

@@ -0,0 +1,64 @@
+import type { Point } from "../geom.ts";
+
+/**
+ * A type of curve for a route.
+ *
+ * - `straight`: the polyline as it is.
+ * - `rounded`: a quadratic Bezier curve at each corner, as `roundCorners` draws it.
+ * - `spline`: a centripetal Catmull-Rom spline through the points. It does not overshoot or make loops.
+ * - `arc`: a circular arc at each corner, tangent to the two legs.
+ */
+export type CurveType = "straight" | "rounded" | "spline" | "arc";
+
+/** The curve types, in the order of the benchmark. */
+export const CURVE_TYPES: readonly CurveType[] = ["straight", "rounded", "spline", "arc"];
+
+/** The start of a curve: the pen goes to `to` and draws nothing. */
+export interface MoveSegment {
+  readonly kind: "move";
+  readonly to: Point;
+}
+
+/** A straight line from the end of the segment before to `to`. */
+export interface LineSegment {
+  readonly kind: "line";
+  readonly to: Point;
+}
+
+/** A cubic Bezier curve from the end of the segment before to `to`, with the control points `c1` and `c2`. */
+export interface CubicSegment {
+  readonly kind: "cubic";
+  readonly c1: Point;
+  readonly c2: Point;
+  readonly to: Point;
+}
+
+/**
+ * A circular arc from the end of the segment before to `to`. The arc has its center at `center` and the radius `radius`.
+ * It starts at the angle `start` and turns by `sweep` radians. A positive `sweep` turns from the x axis to the y axis.
+ * On a canvas, `ctx.arc(center.x, center.y, radius, start, start + sweep, sweep < 0)` draws it.
+ */
+export interface ArcSegment {
+  readonly kind: "arc";
+  readonly center: Point;
+  readonly radius: number;
+  readonly start: number;
+  readonly sweep: number;
+  readonly to: Point;
+}
+
+/**
+ * A segment of a curve. A curve is a list of segments: one `move` first, then lines, cubic curves and arcs.
+ * A renderer maps the list to SVG path data, to canvas calls or to the vertices of a mesh.
+ */
+export type CurveSegment = MoveSegment | LineSegment | CubicSegment | ArcSegment;
+
+/** This function gives the points of a polyline without the points that are nearer than `eps` to the point before them. */
+export function distinctPoints(points: readonly Point[], eps = 1e-9): Point[] {
+  const out: Point[] = [];
+  for (const p of points) {
+    const q = out[out.length - 1];
+    if (q === undefined || Math.hypot(p.x - q.x, p.y - q.y) > eps) out.push(p);
+  }
+  return out;
+}

package/src/curves/rounded/index.ts

@@ -0,0 +1,60 @@
+import { dist, type Point } from "../../geom.ts";
+import { distinctPoints, type CurveSegment } from "../model.ts";
+import { fitSize, type CurveSpace } from "../space.ts";
+
+/** The options of `roundedCurve`. */
+export interface RoundedOptions {
+  /** The largest distance from a corner to the start and to the end of its curve. The default is 12. */
+  readonly radius?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the full radius. */
+  readonly space?: CurveSpace;
+}
+
+/**
+ * This function rounds each inner vertex of a polyline with a quadratic Bezier curve, as `roundCorners` does.
+ * The curve of a corner starts and ends at most `radius` from the vertex, and at most half of each leg. The ends of the polyline stay.
+ * The function gives each quadratic curve as the same cubic curve. With `space`, it makes the radius of a corner smaller until the curve
+ * goes through no box that the polyline avoids.
+ */
+export function roundedCurve(points: readonly Point[], options: RoundedOptions = {}): CurveSegment[] {
+  const p = distinctPoints(points);
+  if (p.length === 0) return [];
+  const radius = options.radius ?? 12;
+  const out: CurveSegment[] = [{ kind: "move", to: p[0]! }];
+  for (let i = 1; i + 1 < p.length; i++) {
+    const a = p[i - 1]!;
+    const v = p[i]!;
+    const b = p[i + 1]!;
+    const la = dist(a, v);
+    const lb = dist(v, b);
+    const ends = (r: number): [Point, Point] => [
+      { x: v.x + ((a.x - v.x) * r) / la, y: v.y + ((a.y - v.y) * r) / la },
+      { x: v.x + ((b.x - v.x) * r) / lb, y: v.y + ((b.y - v.y) * r) / lb },
+    ];
+    const piece = (r: number): CurveSegment[] => {
+      const [p1, p2] = ends(r);
+      // A quadratic curve with the control point v is the cubic curve with the control points 2/3 of the way to v.
+      return [{ kind: "cubic", c1: { x: p1.x + (2 * (v.x - p1.x)) / 3, y: p1.y + (2 * (v.y - p1.y)) / 3 }, c2: { x: p2.x + (2 * (v.x - p2.x)) / 3, y: p2.y + (2 * (v.y - p2.y)) / 3 }, to: p2 }];
+    };
+    const r = fitSize(
+      options.space,
+      Math.min(radius, la / 2, lb / 2),
+      (s) => [ends(s)[0], v, ends(s)[1]],
+      (s) => [{ kind: "move", to: ends(s)[0] }, ...piece(s)],
+    );
+    if (r <= 0) {
+      out.push({ kind: "line", to: v });
+      continue;
+    }
+    const [p1] = ends(r);
+    if (dist(p1, at(out)) > 1e-9) out.push({ kind: "line", to: p1 });
+    out.push(...piece(r));
+  }
+  if (p.length > 1) out.push({ kind: "line", to: p[p.length - 1]! });
+  return out;
+}
+
+/** This function gives the end of the last segment. */
+function at(segments: readonly CurveSegment[]): Point {
+  return segments[segments.length - 1]!.to;
+}

package/src/curves/sample.ts

@@ -0,0 +1,73 @@
+import type { Point } from "../geom.ts";
+import type { CurveSegment } from "./model.ts";
+
+/** The largest number of points that `sampleCurve` gives for one segment. */
+const MAX_STEPS = 1024;
+
+/**
+ * This function gives a polyline that follows the curve. The distance from each part of the curve to the polyline is `tolerance` or less.
+ * The polyline starts at the point of the `move` and goes through the end of each segment.
+ * Hit tests, measures and renderers that draw only lines use this polyline.
+ */
+export function sampleCurve(segments: readonly CurveSegment[], tolerance = 0.5): Point[] {
+  const tol = Math.max(1e-6, tolerance);
+  const out: Point[] = [];
+  let at: Point | undefined;
+  for (const s of segments) {
+    if (s.kind === "move" || at === undefined) {
+      out.push(s.to);
+      at = s.to;
+      continue;
+    }
+    if (s.kind === "cubic") {
+      // The chord of a step of 1/n of the parameter is within 3·D/(4·n²) of the curve. D is the largest second difference of the control points.
+      const d = Math.max(
+        Math.hypot(at.x - 2 * s.c1.x + s.c2.x, at.y - 2 * s.c1.y + s.c2.y),
+        Math.hypot(s.c1.x - 2 * s.c2.x + s.to.x, s.c1.y - 2 * s.c2.y + s.to.y),
+      );
+      const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.sqrt((3 * d) / (4 * tol)))));
+      for (let k = 1; k < n; k++) out.push(cubicAt(at, s.c1, s.c2, s.to, k / n));
+    } else if (s.kind === "arc") {
+      // The chord of an angle φ is within r·(1 - cos(φ/2)) of the arc.
+      const step = s.radius <= tol ? Math.PI : 2 * Math.acos(1 - tol / s.radius);
+      const n = Math.min(MAX_STEPS, Math.max(1, Math.ceil(Math.abs(s.sweep) / step)));
+      for (let k = 1; k < n; k++) {
+        const a = s.start + (s.sweep * k) / n;
+        out.push({ x: s.center.x + s.radius * Math.cos(a), y: s.center.y + s.radius * Math.sin(a) });
+      }
+    }
+    out.push(s.to);
+    at = s.to;
+  }
+  return out;
+}
+
+/** This function gives the point at the parameter `t` of the cubic Bezier curve with the control points `p0`, `p1`, `p2` and `p3`. */
+export function cubicAt(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point {
+  const u = 1 - t;
+  const a = u * u * u;
+  const b = 3 * u * u * t;
+  const c = 3 * u * t * t;
+  const d = t * t * t;
+  return { x: a * p0.x + b * p1.x + c * p2.x + d * p3.x, y: a * p0.y + b * p1.y + c * p2.y + d * p3.y };
+}
+
+/**
+ * This function writes the segments as the data of an SVG path: the commands `M`, `L`, `C` and `A`.
+ * Each number has at most `digits` digits after the point.
+ */
+export function toSvgPath(segments: readonly CurveSegment[], digits = 2): string {
+  const n = (v: number): string => {
+    const s = String(Number(v.toFixed(digits)));
+    return s === "-0" ? "0" : s;
+  };
+  const p = (q: Point): string => `${n(q.x)} ${n(q.y)}`;
+  const parts: string[] = [];
+  for (const s of segments) {
+    if (s.kind === "move") parts.push(`M ${p(s.to)}`);
+    else if (s.kind === "line") parts.push(`L ${p(s.to)}`);
+    else if (s.kind === "cubic") parts.push(`C ${p(s.c1)} ${p(s.c2)} ${p(s.to)}`);
+    else parts.push(`A ${n(s.radius)} ${n(s.radius)} 0 ${Math.abs(s.sweep) > Math.PI ? 1 : 0} ${s.sweep > 0 ? 1 : 0} ${p(s.to)}`);
+  }
+  return parts.join(" ");
+}

package/src/curves/space.ts

@@ -0,0 +1,91 @@
+import { TOLERANCE } from "../bench/properties.ts";
+import { inflate, segmentHitsBox, type Box, type Point } from "../geom.ts";
+import { Grid } from "../grid.ts";
+import type { CurveSegment } from "./model.ts";
+import { sampleCurve } from "./sample.ts";
+
+/**
+ * The free space of a board: the boxes that a curve must not go through.
+ * Make it one time for a board with `curveSpace`, and give it to each call of `curveOf`.
+ */
+export interface CurveSpace {
+  /** The boxes of the board. */
+  readonly boxes: readonly Box[];
+  /** The tolerance of the samples of a curve, in units of the plane. */
+  readonly tolerance: number;
+  /**
+   * This method tells if the polyline `q` goes through a box that the polyline `p` does not go through.
+   * A polyline goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
+   */
+  addsHit(q: readonly Point[], p: readonly Point[]): boolean;
+}
+
+/**
+ * This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
+ * The curves sample each piece within `tolerance` of the curve for the test.
+ */
+export function curveSpace(boxes: readonly Box[], tolerance = 0.25): CurveSpace {
+  const inner = boxes.map((b) => inflate(b, -TOLERANCE));
+  let size = 0;
+  for (const b of boxes) size += Math.max(b.w, b.h);
+  // The buckets grow with the boxes, as the buckets of `measureLinks` do.
+  const grid = new Grid<number>(Math.max(180, (2 * size) / Math.max(1, boxes.length)));
+  inner.forEach((b, i) => grid.add(i, b));
+  const hits = (p: readonly Point[]): Set<number> => {
+    const out = new Set<number>();
+    for (let i = 1; i < p.length; i++) {
+      const a = p[i - 1]!;
+      const b = p[i]!;
+      grid.querySegment(a, b, 0, (id) => {
+        if (!out.has(id) && segmentHitsBox(a, b, inner[id]!, TOLERANCE)) out.add(id);
+      });
+    }
+    return out;
+  };
+  return {
+    boxes,
+    tolerance,
+    addsHit(q: readonly Point[], p: readonly Point[]): boolean {
+      let before: Set<number> | undefined;
+      for (let i = 1; i < q.length; i++) {
+        const a = q[i - 1]!;
+        const b = q[i]!;
+        const hit = grid.someSegment(a, b, 0, (id) => {
+          if (!segmentHitsBox(a, b, inner[id]!, TOLERANCE)) return false;
+          before ??= hits(p);
+          return !before.has(id);
+        });
+        if (hit) return true;
+      }
+      return false;
+    },
+  };
+}
+
+/**
+ * This function finds the largest size from `max` down to 0 that keeps a piece of a curve clear.
+ * A clear piece goes through no box that its polyline avoids.
+ *
+ * The function `piece` gives the segments of the piece at a size. They start with a `move`.
+ * The polyline `chord` is the part of the original polyline that the piece replaces.
+ * The function tries `max` first, then it halves the interval `steps` times. The result is 0 when no size of the search is clear.
+ */
+export function fitSize(
+  space: CurveSpace | undefined,
+  max: number,
+  chord: (size: number) => readonly Point[],
+  piece: (size: number) => readonly CurveSegment[],
+  steps = 8,
+): number {
+  if (space === undefined || max <= 0) return Math.max(0, max);
+  const clear = (size: number): boolean => !space.addsHit(sampleCurve(piece(size), space.tolerance), chord(size));
+  if (clear(max)) return max;
+  let lo = 0;
+  let hi = max;
+  for (let i = 0; i < steps; i++) {
+    const mid = (lo + hi) / 2;
+    if (clear(mid)) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}

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/grid.ts

@@ -71,6 +71,56 @@ export class Grid<T> {
     }
   }
 
+  /**
+   * This method gives each item in the buckets along the segment `ab`, widened by `margin`, to `visit`, one time each.
+   * The buckets are those of `#segment`, in the same order, so the items come in the same order.
+   * A bucket in the range of the step before has no new item, so the walk skips it.
+   * The walk stops when `visit` gives true, and then the method gives true.
+   */
+  #walk(a: Point, b: Point, margin: number, visit: (item: T) => boolean | void): boolean {
+    const stamp = ++this.#stamp;
+    const c = this.#cell;
+    const items = this.#items;
+    const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (c / 2)));
+    let px = a.x;
+    let py = a.y;
+    // The bucket range of the step before. The first step has none.
+    let pi0 = 1;
+    let pi1 = 0;
+    let pj0 = 1;
+    let pj1 = 0;
+    for (let k = 1; k <= n; k++) {
+      const qx = k === n ? b.x : a.x + ((b.x - a.x) * k) / n;
+      const qy = k === n ? b.y : a.y + ((b.y - a.y) * k) / n;
+      const i0 = Math.floor((Math.min(px, qx) - margin) / c);
+      const j0 = Math.floor((Math.min(py, qy) - margin) / c);
+      const i1 = Math.floor((Math.max(px, qx) + margin) / c);
+      const j1 = Math.floor((Math.max(py, qy) + margin) / c);
+      // A visit can add an item and so replace the array of stamps. Each step reads it again, as `#take` does.
+      const seen = this.#seen;
+      for (let i = i0; i <= i1; i++) {
+        const before = i >= pi0 && i <= pi1;
+        for (let j = j0; j <= j1; j++) {
+          if (before && j >= pj0 && j <= pj1) continue;
+          const list = this.#buckets.get(this.#key(i, j));
+          if (list === undefined) continue;
+          for (const id of list) {
+            if (seen[id] === stamp) continue;
+            seen[id] = stamp;
+            if (visit(items[id]!) === true) return true;
+          }
+        }
+      }
+      pi0 = i0;
+      pi1 = i1;
+      pj0 = j0;
+      pj1 = j1;
+      px = qx;
+      py = qy;
+    }
+    return false;
+  }
+
   // The buckets along a segment, widened by `margin`: the boxes of steps of at most half a bucket.
   #segment(a: Point, b: Point, margin: number, each: (x0: number, y0: number, x1: number, y1: number) => void): void {
     const n = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y) / (this.#cell / 2)));
@@ -103,8 +153,17 @@ export class Grid<T> {
 
   /** This method gives each item whose buckets come within `margin` of the segment `ab` to `visit`, one time each. */
   querySegment(a: Point, b: Point, margin: number, visit: (item: T) => void): void {
-    const stamp = ++this.#stamp;
-    this.#segment(a, b, margin, (x0, y0, x1, y1) => this.#take(stamp, x0, y0, x1, y1, visit));
+    this.#walk(a, b, margin, (item) => {
+      visit(item);
+    });
+  }
+
+  /**
+   * This method tells if `test` gives true for an item whose buckets come within `margin` of the segment `ab`.
+   * It gives the items in the order of `querySegment`, and it stops at the first item that passes the test.
+   */
+  someSegment(a: Point, b: Point, margin: number, test: (item: T) => boolean): boolean {
+    return this.#walk(a, b, margin, test);
   }
 }
 

package/src/index.ts

@@ -2,13 +2,19 @@ export * from "./geom.ts";
 export { Grid, segmentBounds } from "./grid.ts";
 export * from "./model.ts";
 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";