@mark1russell7/highways 0.1.3 → 0.1.4

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/src/bench/curves.ts

@@ -0,0 +1,98 @@
+import { curveOf, CURVE_TYPES, curveSpace, sampleCurve, type CurveType } from "../curves/index.ts";
+import { polylineLength } from "../geom.ts";
+import { nodeIndex, type Graph, type Router } from "../model.ts";
+import { nearestSide, SIDE_NORMAL } from "../plugs.ts";
+import { measureLinks, type MeasuredLink } from "./links.ts";
+
+// The core runs in any host, so it reads the clock without the types of Node or the browser.
+const now = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** One row of the benchmark of the curves: one curve type on the routes of one router on one fixture. */
+export interface CurveBenchRow {
+  readonly router: string;
+  readonly fixture: string;
+  readonly type: CurveType;
+  /** The number of routes. */
+  readonly links: number;
+  /** The number of polylines that go through a box that is not one of their ends (`measureLinks`). */
+  readonly through: number;
+  /** The number of curves without a free space that go through such a box. */
+  readonly free: number;
+  /** The number of curves with the free space of the nodes (`curveSpace`) that go through such a box. */
+  readonly clamped: number;
+  /** The ratio of the length of all curves with the free space to the length of all polylines. */
+  readonly length: number;
+  /** The time to make all curves with the free space, in milliseconds. */
+  readonly ms: number;
+}
+
+/** The options of `benchCurves`. */
+export interface CurveBenchOptions {
+  /** The radius of the types `rounded` and `arc`. The default is 12. */
+  readonly radius?: number;
+  /** The tolerance of the samples of the curves. The default is 0.25. */
+  readonly tolerance?: number;
+}
+
+/**
+ * This function routes a graph with a router and makes each curve type of each route.
+ * It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+ * The type `spline` leaves each plug along the normal of the nearest side of its node.
+ */
+export function benchCurves(router: Router, fixture: string, graph: Graph, options: CurveBenchOptions = {}): CurveBenchRow[] {
+  const tolerance = options.tolerance ?? 0.25;
+  const result = router.route(graph);
+  const byId = nodeIndex(graph);
+  const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+  const edges = new Map(graph.edges.map((e) => [e.id, e]));
+  const space = curveSpace(
+    graph.nodes.map((n) => n.box),
+    tolerance,
+  );
+  const routes = result.routes.flatMap((r) => {
+    const e = edges.get(r.edge);
+    const s = e && byId.get(e.source.node);
+    const t = e && byId.get(e.target.node);
+    if (!e || !s || !t || r.points.length < 2) return [];
+    const first = r.points[0]!;
+    const last = r.points[r.points.length - 1]!;
+    return [{ source: s.id, target: t.id, points: r.points, startNormal: SIDE_NORMAL[nearestSide(s.box, first)], endNormal: SIDE_NORMAL[nearestSide(t.box, last)] }];
+  });
+  const base = measureLinks(boxes, routes);
+  const ink = routes.reduce((sum, r) => sum + polylineLength(r.points), 0);
+  return CURVE_TYPES.map((type): CurveBenchRow => {
+    const make = (withSpace: boolean): MeasuredLink[] =>
+      routes.map((r) => ({
+        source: r.source,
+        target: r.target,
+        points: sampleCurve(
+          curveOf(r.points, { type, radius: options.radius ?? 12, startNormal: r.startNormal, endNormal: r.endNormal, ...(withSpace ? { space } : {}) }),
+          tolerance,
+        ),
+      }));
+    const free = measureLinks(boxes, make(false));
+    const t0 = now();
+    const clamped = make(true);
+    const ms = now() - t0;
+    const length = clamped.reduce((sum, l) => sum + polylineLength(l.points), 0);
+    return {
+      router: router.name,
+      fixture,
+      type,
+      links: routes.length,
+      through: base.through,
+      free: free.through,
+      clamped: measureLinks(boxes, clamped).through,
+      length: ink > 0 ? length / ink : 1,
+      ms,
+    };
+  });
+}
+
+/** This function writes the rows of `benchCurves` as a Markdown table. */
+export function formatCurves(rows: readonly CurveBenchRow[]): string {
+  const head = "| router | fixture | curve | routes | through, polyline | through, free | through, clamped | length | ms |";
+  const line = "|---|---|---|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => `| ${r.router} | ${r.fixture} | ${r.type} | ${r.links} | ${r.through} | ${r.free} | ${r.clamped} | ${r.length.toFixed(3)} | ${r.ms.toFixed(1)} |`);
+  return [head, line, ...body].join("\n");
+}

package/src/bench/room.ts

@@ -0,0 +1,122 @@
+import { levelLinks } from "../levels.ts";
+import type { Graph, Node, Result } from "../model.ts";
+import { makeRoom, roomLinks, type RoomOptions } from "../room/index.ts";
+import { sectionsRouter } from "../routers/sections.ts";
+import { laneRoutes, runKey, segmentsOf } from "../segments.ts";
+import { measureLinks, measureRouteFaults, type LinkFaults } from "./links.ts";
+import { measureQuality } from "./quality.ts";
+
+// The core runs in any host, so it reads the clock without the types of Node or the browser.
+const now = (): number => (globalThis as { performance?: { now(): number } }).performance?.now() ?? Date.now();
+
+/** One row of the benchmark of the room: one state of a board, packed or open, and the measures of its links. */
+export interface RoomBenchRow {
+  readonly fixture: string;
+  /** The state of the board: `packed`, `gutter` (each gap open to the gutter only), or a method of `roomDemand`. */
+  readonly board: string;
+  /** The area of the bounding box of the boxes, as a share of the area of the packed board. */
+  readonly area: number;
+  /** The faults of the links of the far view (`levelLinks` with each box as one item). */
+  readonly faults: LinkFaults;
+  /** The crossings of the links of the far view (`measureQuality`). */
+  readonly crossings: number;
+  /** The ink of the links of the far view. */
+  readonly ink: number;
+  /** The mean detour of the links of the far view. */
+  readonly detour: number;
+  /**
+   * The number of lane routes of the router `sections` that go through a box. Each shared segment opens to one lane for each edge,
+   * at the spacing of the options (`laneRoutes`).
+   */
+  readonly laneThrough: number;
+  /** The time of `makeRoom`, in milliseconds. It is 0 for the packed board. */
+  readonly ms: number;
+}
+
+/** This function gives the area of the bounding box of the nodes. */
+function areaOf(nodes: readonly Node[]): number {
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const n of nodes) {
+    x0 = Math.min(x0, n.box.x);
+    y0 = Math.min(y0, n.box.y);
+    x1 = Math.max(x1, n.box.x + n.box.w);
+    y1 = Math.max(y1, n.box.y + n.box.h);
+  }
+  return nodes.length ? (x1 - x0) * (y1 - y0) : 0;
+}
+
+/**
+ * This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
+ * It also measures the lane routes of the router `sections` at the lane width `spacing`.
+ */
+export function measureBoard(graph: Graph, spacing: number): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms"> {
+  const links = roomLinks(graph);
+  const items = graph.nodes.map((n) => ({ id: n.id, box: n.box, nodes: [n.id] }));
+  const drawn = levelLinks(
+    items,
+    links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
+  );
+  const boxes = new Map(graph.nodes.map((n) => [n.id, n.box]));
+  // `measureQuality` reads routes of edges, so each link of the far view stands for the first edge of its pair.
+  const edgeOf = new Map<string, string>();
+  for (const e of graph.edges) {
+    const key = `${e.source.node}\u0000${e.target.node}`;
+    if (!edgeOf.has(key)) edgeOf.set(key, e.id);
+  }
+  const asRoutes: Result = { routes: drawn.map((l) => ({ edge: edgeOf.get(`${l.source}\u0000${l.target}`)!, points: l.points })) };
+  const q = measureQuality(graph, asRoutes);
+  const routed = sectionsRouter({ name: "sections" }).route(graph);
+  const segments = segmentsOf(routed);
+  const open = new Set(segments.segments.filter((s) => s.count > 1).map((s) => runKey(s.edges)));
+  const lanes = laneRoutes(segments, open, spacing);
+  return {
+    faults: measureLinks(boxes, drawn),
+    crossings: q.crossings,
+    ink: q.ink,
+    detour: q.detour,
+    laneThrough: measureRouteFaults(graph, { routes: lanes }).through,
+  };
+}
+
+/**
+ * This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
+ * The options of `makeRoom` are the same for each method, except `method`.
+ */
+export function benchRoom(fixture: string, graph: Graph, options: RoomOptions = {}): RoomBenchRow[] {
+  const spacing = options.spacing ?? 4;
+  const area0 = areaOf(graph.nodes);
+  const links = roomLinks(graph);
+  const row = (board: string, nodes: readonly Node[], ms: number): RoomBenchRow => ({
+    fixture,
+    board,
+    area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+    ms,
+    ...measureBoard({ nodes, edges: graph.edges }, spacing),
+  });
+  const rows = [row("packed", graph.nodes, 0)];
+  const states: [string, RoomOptions][] = [
+    ["gutter", { ...options, spacing: 0, method: "routes" }],
+    ["routes", { ...options, method: "routes" }],
+    ["lines", { ...options, method: "lines" }],
+  ];
+  for (const [board, o] of states) {
+    const t0 = now();
+    const room = makeRoom(graph.nodes, links, o);
+    rows.push(row(board, room.items, now() - t0));
+  }
+  return rows;
+}
+
+/** This function writes the rows of `benchRoom` as a Markdown table. */
+export function formatRoom(rows: readonly RoomBenchRow[]): string {
+  const head = "| fixture | board | area | links | through | outside | out and back | worst detour | crossings | ink | detour | lane through | ms |";
+  const line = "|---|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|";
+  const body = rows.map((r) => {
+    const f = r.faults;
+    return `| ${r.fixture} | ${r.board} | ${r.area.toFixed(3)} | ${f.links} | ${f.through} | ${f.outside} | ${f.backtrack} | ${f.worstDetour.toFixed(2)} | ${r.crossings} | ${Math.round(r.ink)} | ${r.detour.toFixed(3)} | ${r.laneThrough} | ${r.ms.toFixed(1)} |`;
+  });
+  return [head, line, ...body].join("\n");
+}

package/src/cases.ts

@@ -103,6 +103,34 @@ export function manyGroupsBoard(): Graph {
   return b.graph();
 }
 
+/**
+ * This function makes the far view of a board after a host layout packs it.
+ * The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+ * The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+ * The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+ *
+ * The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+ */
+export function packedGridBoard(): Graph {
+  const R = rng(11);
+  const b = new Board();
+  const cols = 12;
+  const rows = 8;
+  const w = 140;
+  const h = 90;
+  const id = (r: number, c: number): string => `p${r}-${c}`;
+  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) b.node(id(r, c), c * w, r * h, w, h);
+  const step = (): number => Math.floor(R() * 5) - 2;
+  for (let r = 0; r < rows; r++)
+    for (let c = 0; c < cols; c++) {
+      const rr = Math.max(0, Math.min(rows - 1, r + step()));
+      const cc = Math.max(0, Math.min(cols - 1, c + step()));
+      b.link(id(r, c), id(rr, cc));
+    }
+  for (let n = 0; n < 48; n++) b.link(id(Math.floor(R() * rows), Math.floor(R() * cols)), id(Math.floor(R() * rows), Math.floor(R() * cols)));
+  return b.graph();
+}
+
 /** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
 export const CASES: readonly CaseBoard[] = [
   { name: "case-dense-groups", defect: "Groups overlap at the far view, and level links go through other groups.", make: denseGroupsBoard },

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;
+}