@mark1russell7/highways 0.1.3 → 0.1.5

package/package.json

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

package/src/bench/curves.ts

@@ -0,0 +1,125 @@
+import { 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 { curveStrategies } from "../strategies/builtins.ts";
+import type { Strategy } from "../strategies/model.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.
+ * The type `T` of the name of the curve is `CurveType` for `benchCurves`, and `string` for `benchCurveStrategies`.
+ */
+export interface CurveBenchRow<T extends string = CurveType> {
+  readonly router: string;
+  readonly fixture: string;
+  readonly type: T;
+  /** 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[] {
+  // Each built-in curve strategy has the name of its curve type, so each row has a `CurveType`.
+  return benchCurveStrategies(
+    router,
+    fixture,
+    graph,
+    CURVE_TYPES.map((t) => curveStrategies[t]),
+    options,
+  ) as CurveBenchRow[];
+}
+
+/**
+ * This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+ * The option `radius` goes to each strategy. A strategy without such an option does not read it.
+ */
+export function benchCurveStrategies(
+  router: Router,
+  fixture: string,
+  graph: Graph,
+  curves: readonly Strategy<"curve">[],
+  options: CurveBenchOptions = {},
+): CurveBenchRow<string>[] {
+  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);
+  const radius = { radius: options.radius ?? 12 };
+  return curves.map((curve): CurveBenchRow<string> => {
+    const make = (withSpace: boolean): MeasuredLink[] =>
+      routes.map((r) => ({
+        source: r.source,
+        target: r.target,
+        points: sampleCurve(
+          curve.run({ points: r.points, startNormal: r.startNormal, endNormal: r.endNormal, ...(withSpace ? { space } : {}) }, radius),
+          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: curve.name,
+      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>[]): 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,190 @@
+import { levelLinks } from "../levels.ts";
+import type { Graph, Node, Result } from "../model.ts";
+import { makeRoom, openGaps, roomLinks, type RoomOptions } from "../room/index.ts";
+import { gapLanes, LANE_ORDERS, type LaneOrder } from "../room/lanes.ts";
+import { sectionsRouter } from "../routers/sections.ts";
+import { laneRoutes, runKey, segmentsOf } from "../segments.ts";
+import { roomStrategies } from "../strategies/builtins.ts";
+import type { Strategy } from "../strategies/model.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.
+ * With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+ * Without it, the links of a gap share the lines of the level links.
+ * The function also measures the lane routes of the router `sections` at the lane width `spacing`.
+ */
+export function measureBoard(graph: Graph, spacing: number, order?: LaneOrder): 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 level = levelLinks(
+    items,
+    links.map((l) => ({ source: l.source, target: l.target, count: l.count ?? 1 })),
+  );
+  const drawn = order ? gapLanes(graph.nodes, level, { spacing, order }) : level;
+  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 each room strategy opens.
+ * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
+ */
+export function benchRoom(
+  fixture: string,
+  graph: Graph,
+  options: RoomOptions = {},
+  methods: readonly Strategy<"room">[] = [roomStrategies.routes, roomStrategies.lines],
+): 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 t0 = now();
+  const gutter = makeRoom(graph.nodes, links, { ...options, spacing: 0, method: "routes" });
+  rows.push(row("gutter", gutter.items, now() - t0));
+  const { method: _method, ...preset } = options;
+  for (const s of methods) {
+    const t1 = now();
+    const gaps = s.run({ items: graph.nodes, links }, preset);
+    const nodes = openGaps(graph.nodes, gaps, options.snap);
+    rows.push(row(s.name, nodes, now() - t1));
+  }
+  return rows;
+}
+
+/** One setting of a sweep of the room: the options of `makeRoom` and the lane order of the far view. */
+export interface RoomSetting {
+  /** The name of the setting in the column `board`. */
+  readonly name: string;
+  readonly options: RoomOptions;
+  /** The lane order of the far view. Without it, the links of a gap share the lines of the level links. */
+  readonly lanes?: LaneOrder;
+}
+
+/**
+ * This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+ * The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
+ */
+export function sweepRoom(fixture: string, graph: Graph, settings: readonly RoomSetting[], baseline: RoomOptions = { gutter: 8, spacing: 4 }): RoomBenchRow[] {
+  const area0 = areaOf(graph.nodes);
+  const links = roomLinks(graph);
+  const row = (board: string, nodes: readonly Node[], ms: number, spacing: number, lanes?: LaneOrder): RoomBenchRow => ({
+    fixture,
+    board,
+    area: area0 > 0 ? areaOf(nodes) / area0 : 1,
+    ms,
+    ...measureBoard({ nodes, edges: graph.edges }, spacing, lanes),
+  });
+  const fair = makeRoom(graph.nodes, links, { ...baseline, spacing: 0, method: "routes", maxGrowth: Infinity, passes: 1 });
+  const rows = [row("gutter", fair.items, 0, baseline.spacing ?? 4)];
+  for (const s of settings) {
+    const t0 = now();
+    const open = makeRoom(graph.nodes, links, { ...s.options, method: "routes" });
+    rows.push(row(s.name, open.items, now() - t0, s.options.spacing ?? 4, s.lanes));
+  }
+  return rows;
+}
+
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+export const GROWTH_SWEEP: readonly number[] = [0, 0.06, 0.09, 0.12, 0.15, 0.18, 0.21, 0.25, 0.3, 0.35, 0.5, Infinity];
+
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+export function growthSettings(values: readonly number[] = GROWTH_SWEEP): RoomSetting[] {
+  return values.map((m) => ({ name: `maxGrowth ${m}`, options: { gutter: 8, spacing: 4, maxGrowth: m } }));
+}
+
+/**
+ * This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+ * The order `shared` is the far view without lanes, as before ROOM-C.
+ */
+export function laneSettings(spacings: readonly number[] = [2, 4, 6, 8], orders: readonly LaneOrder[] = LANE_ORDERS): RoomSetting[] {
+  return spacings.flatMap((spacing) => [
+    { name: `shared spacing ${spacing}`, options: { gutter: 8, spacing } },
+    ...orders.map((lanes) => ({ name: `${lanes} spacing ${spacing}`, options: { gutter: 8, spacing }, lanes })),
+  ]);
+}
+
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+export function passSettings(gutters: readonly number[] = [4, 8, 12, 16], passes: readonly number[] = [1, 2]): RoomSetting[] {
+  return gutters.flatMap((gutter) => passes.map((p) => ({ name: `gutter ${gutter} passes ${p}`, options: { gutter, spacing: 4, passes: p } })));
+}
+
+/** 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;
+}