@mark1russell7/highways 0.1.0 → 0.1.2

package/package.json

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

package/src/bench/properties.ts

@@ -1,10 +1,18 @@
-import { dist, inflate, pointBoxDistance, segmentHitsBox, type Point } from "../geom.ts";
+import { dist, inflate, pointBoxDistance, segmentHitsBox, type Box, type Point } from "../geom.ts";
 import { Grid } from "../grid.ts";
 import { fixedPortPoint, nodeIndex, type Graph, type Node, type Result } from "../model.ts";
 
 /** A broken hard rule. A correct router has none. */
 export interface Violation {
-  readonly rule: "complete" | "ends-at-plugs" | "fixed-plugs" | "no-pass-through" | "counts-sum" | "bundle-trunk" | "run-shared";
+  readonly rule:
+    | "complete"
+    | "ends-at-plugs"
+    | "fixed-plugs"
+    | "no-pass-through"
+    | "counts-sum"
+    | "link-ends"
+    | "bundle-trunk"
+    | "run-shared";
   readonly edge?: string;
   readonly detail: string;
 }
@@ -15,6 +23,7 @@ export const TOLERANCE = 0.5;
 /**
  * This function checks the hard rules of a result. Each edge has one route, and each route starts and ends at its nodes.
  * Fixed plugs stay in place. No route goes through a node that is not one of its ends. The counts of each level add up.
+ * Each link of a level starts on the box of its source and ends on the box of its target.
  *
  * Each route of a bundle starts with its trunk, and an edge is in one bundle at most.
  * Each run has two edges or more, and the route of each edge holds the points of the run in a row.
@@ -91,10 +100,26 @@ export function checkProperties(graph: Graph, result: Result, limit = 100): Viol
     const sum = level.links.reduce((s, l) => s + l.count, 0);
     if (sum !== between)
       if (add({ rule: "counts-sum", detail: `level ${level.depth}: the links count ${sum} edges, not ${between}` })) return out;
+    const boxOf = new Map(level.items.map((it) => [it.id, it.box]));
+    for (const l of level.links) {
+      const s = boxOf.get(l.source);
+      const t = boxOf.get(l.target);
+      const p = l.points;
+      if (!s || !t || p.length < 2 || !onBoundary(p[0]!, s) || !onBoundary(p[p.length - 1]!, t))
+        if (add({ rule: "link-ends", detail: `level ${level.depth}: the link ${l.source} to ${l.target} does not start and end on the boundaries of its items` }))
+          return out;
+    }
   }
   return out;
 }
 
+/** This function tells if the point is on the boundary of the box, within `TOLERANCE`. */
+function onBoundary(p: Point, b: Box): boolean {
+  const inner = inflate(b, -TOLERANCE);
+  const deep = p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h;
+  return !deep && pointBoxDistance(p, b) <= TOLERANCE;
+}
+
 /** This function tells if the polyline `p` holds the points of `part` in a row. */
 function holds(p: readonly Point[], part: readonly Point[]): boolean {
   if (part.length === 0) return true;

package/src/levels.ts

@@ -0,0 +1,243 @@
+import { center, dist, type Box, type Point } from "./geom.ts";
+import type { LevelItem, LevelLink, Node, Side } from "./model.ts";
+import { pointOnSide, SIDE_NORMAL, sideToward, type Plug } from "./plugs.ts";
+import { CornerGraph, Obstacles } from "./visibility.ts";
+import type { WayFinder, WayOptions } from "./ways.ts";
+
+/** Two items of a level that a link joins, and the count of the edges between them. */
+export interface ItemPair {
+  readonly source: string;
+  readonly target: string;
+  readonly count: number;
+}
+
+/** The parts of a way finder that a link uses. */
+type Ways = Pick<WayFinder, "obstacles" | "corners" | "margin" | "out">;
+
+const EPS = 1e-6;
+
+/**
+ * This function removes the repeated points, the points in the middle of a straight run,
+ * and the points where the way turns back on itself.
+ */
+function tidy(p: readonly Point[]): Point[] {
+  const out: Point[] = [];
+  for (const q of p) {
+    if (out.length > 0 && dist(q, out[out.length - 1]!) <= EPS) continue;
+    while (out.length >= 2) {
+      const a = out[out.length - 2]!;
+      const b = out[out.length - 1]!;
+      const cross = (b.x - a.x) * (q.y - b.y) - (b.y - a.y) * (q.x - b.x);
+      if (Math.abs(cross) > EPS * (1 + dist(a, b) * dist(b, q))) break;
+      // The point b is on the line through a and q: in the middle of a straight run, or at the tip of a turn back.
+      out.pop();
+    }
+    if (out.length > 0 && dist(q, out[out.length - 1]!) <= EPS) continue;
+    out.push(q);
+  }
+  return out;
+}
+
+/**
+ * This function gives the links of one level. The items of the level are the obstacles.
+ * A link starts on the boundary of the box of its source and ends on the boundary of the box of its target.
+ * It goes around the boxes of the other items. Where there is space, its legs are parallel to the axes.
+ */
+export function levelLinks(items: readonly LevelItem[], pairs: readonly ItemPair[], options: WayOptions = {}): LevelLink[] {
+  if (pairs.length === 0) return [];
+  const nodes: Node[] = items.map((i) => ({ id: i.id, box: i.box }));
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const ways = levelWays(nodes, options);
+  const inset = Math.min(6, ways.margin);
+  const out: LevelLink[] = [];
+  for (const p of pairs) {
+    const s = byId.get(p.source);
+    const t = byId.get(p.target);
+    if (!s || !t) continue;
+    // Two items with a clear way between their facing sides get the short way.
+    const [fs, ft] = facingPlugs(s.box, t.box, inset);
+    let points = isFree(ways, s, fs) && isFree(ways, t, ft) ? quickWay(ways, ends(ways, s, fs, t, ft)) : undefined;
+    // Else the link goes from the middle of a side. Each item has at most four such plugs, so the corner graph finds their ends one time.
+    points ??= squareWay(ways, ends(ways, s, sidePlug(ways, s, center(t.box)), t, sidePlug(ways, t, center(s.box))));
+    out.push({ source: p.source, target: p.target, count: p.count, points });
+  }
+  return out;
+}
+
+/**
+ * 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.
+ */
+function levelWays(nodes: readonly Node[], options: WayOptions): Ways {
+  const margin = options.margin ?? 5;
+  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: options.k ?? 8 });
+  return { obstacles, corners, margin, out: (p) => ({ x: p.point.x + p.normal.x * margin, y: p.point.y + p.normal.y * margin }) };
+}
+
+/**
+ * This function gives the plugs of a link between two boxes. Each plug is on the side that faces the other box.
+ * When the two sides face each other and their spans overlap, both plugs are at the middle of the overlap, so the link is straight.
+ */
+export function facingPlugs(a: Box, b: Box, inset: number): [Plug, Plug] {
+  const sa = sideToward(a, center(b));
+  const sb = sideToward(b, center(a));
+  const plug = (box: Box, side: Side, toward: Point): Plug => ({ point: pointOnSide(box, side, toward, inset), normal: SIDE_NORMAL[side] });
+  const across = (sa === "east" && sb === "west") || (sa === "west" && sb === "east");
+  const down = (sa === "south" && sb === "north") || (sa === "north" && sb === "south");
+  if (across || down) {
+    const lo = across ? Math.max(a.y, b.y) + inset : Math.max(a.x, b.x) + inset;
+    const hi = across ? Math.min(a.y + a.h, b.y + b.h) - inset : Math.min(a.x + a.w, b.x + b.w) - inset;
+    if (lo <= hi) {
+      const ca = center(a);
+      const cb = center(b);
+      const m = Math.max(lo, Math.min(hi, across ? (ca.y + cb.y) / 2 : (ca.x + cb.x) / 2));
+      const at = (box: Box, side: Side): Point =>
+        across
+          ? { x: side === "east" ? box.x + box.w : box.x, y: m }
+          : { x: m, y: side === "south" ? box.y + box.h : box.y };
+      return [
+        { point: at(a, sa), normal: SIDE_NORMAL[sa] },
+        { point: at(b, sb), normal: SIDE_NORMAL[sb] },
+      ];
+    }
+  }
+  return [plug(a, sa, center(b)), plug(b, sb, center(a))];
+}
+
+const SIDES: readonly Side[] = ["north", "east", "south", "west"];
+
+/** This function tells if the way out of a plug is free. The plug and the point at `margin` from it are in no other box. */
+function isFree(ways: Ways, node: Node, plug: Plug): boolean {
+  return !ways.obstacles.inside(ways.out(plug), 0, node) && !ways.obstacles.inside(plug.point, 0, node);
+}
+
+/** This function gives the plug at the middle of a side of the node: the side with a free way out that faces `toward` most. */
+function sidePlug(ways: Ways, node: Node, toward: Point): Plug {
+  const b = node.box;
+  const c = center(b);
+  const d = { x: toward.x - c.x, y: toward.y - c.y };
+  const facing = (s: Side): number => SIDE_NORMAL[s].x * d.x + SIDE_NORMAL[s].y * d.y;
+  const order = [...SIDES].sort((u, v) => facing(v) - facing(u));
+  const plug = (s: Side): Plug => {
+    const n = SIDE_NORMAL[s];
+    return { point: { x: c.x + (n.x * b.w) / 2, y: c.y + (n.y * b.h) / 2 }, normal: n };
+  };
+  for (const s of order) if (isFree(ways, node, plug(s))) return plug(s);
+  return plug(order[0]!);
+}
+
+/** The two ends of a link: each plug, and the point where the link turns away from the normal of the plug. */
+interface Ends {
+  readonly ps: Plug;
+  readonly pt: Plug;
+  readonly a: Point;
+  readonly b: Point;
+}
+
+/**
+ * This function gives the ends of a link. The link leaves each plug along its normal for the margin.
+ * A box can be nearer than twice the margin in front of a plug. Then the link turns in the middle of the space before that box.
+ * Two plugs that face each other across a narrow space make the link turn in the middle of that space.
+ */
+function ends(ways: Ways, s: Node, ps: Plug, t: Node, pt: Plug): Ends {
+  let ra = reach(ways, s, ps);
+  let rb = reach(ways, t, pt);
+  // Two plugs that face each other turn at the same distance, so the link does not go past itself.
+  if (ps.normal.x === -pt.normal.x && ps.normal.y === -pt.normal.y) {
+    const d = (pt.point.x - ps.point.x) * ps.normal.x + (pt.point.y - ps.point.y) * ps.normal.y;
+    if (d > 0 && ra + rb > d) ra = rb = d / 2;
+  }
+  return { ps, pt, a: along(ps, ra), b: along(pt, rb) };
+}
+
+const along = (p: Plug, d: number): Point => ({ x: p.point.x + p.normal.x * d, y: p.point.y + p.normal.y * d });
+
+/** This function gives the distance that a link goes along the normal of a plug before it turns. */
+function reach(ways: Ways, node: Node, plug: Plug): number {
+  const skip = new Set([node]);
+  const far = 2 * ways.margin;
+  if (ways.obstacles.clear(plug.point, along(plug, far), 0, skip)) return ways.margin;
+  let lo = 0;
+  let hi = far;
+  for (let i = 0; i < 10; i++) {
+    const m = (lo + hi) / 2;
+    if (ways.obstacles.clear(plug.point, along(plug, m), 0, skip)) lo = m;
+    else hi = m;
+  }
+  return lo / 2;
+}
+
+/**
+ * This function gives the way between the ends when one or two legs parallel to the axes are clear, or `undefined`.
+ * The legs keep half the margin from the boxes, or less when an end turns nearer to a box.
+ */
+function quickWay(ways: Ways, e: Ends): Point[] | undefined {
+  const near = Math.min(dist(e.ps.point, e.a), dist(e.pt.point, e.b));
+  const pad = Math.max(0, Math.min(ways.margin / 2, near - 1));
+  const legs = square(e.a, e.b, ways.obstacles, pad, axisOf(e.ps.normal), axisOf(e.pt.normal));
+  return legs && tidy([e.ps.point, e.a, ...legs, e.pt.point]);
+}
+
+/**
+ * This function gives a way from plug to plug through the corner graph. The way leaves and enters each plug along its normal.
+ * Then it pulls the corners tight with legs that are parallel to the axes, where the obstacles let it.
+ */
+function squareWay(ways: Ways, e: Ends): Point[] {
+  const quick = quickWay(ways, e);
+  if (quick) return quick;
+  const legs = squarePull(ways.corners.path(e.a, e.b) ?? [e.a, e.b], ways.obstacles, ways.margin / 2, axisOf(e.ps.normal), axisOf(e.pt.normal));
+  return tidy([e.ps.point, ...legs, e.pt.point]);
+}
+
+type Axis = "x" | "y";
+
+const axisOf = (n: Point): Axis => (Math.abs(n.x) > Math.abs(n.y) ? "x" : "y");
+
+/**
+ * This function pulls a path tight. From each vertex, it goes to the farthest vertex that one or two legs can reach.
+ * These legs are parallel to the axes and clear of the obstacles by `pad`. It keeps a diagonal leg only where no such legs are clear.
+ * `first` is the axis of the way into the first vertex, and `last` is the axis of the way out of the last vertex.
+ */
+function squarePull(p: readonly Point[], obstacles: Obstacles, pad: number, first: Axis, last: Axis, lookahead = 16): Point[] {
+  if (p.length === 0) return [];
+  const out: Point[] = [p[0]!];
+  let axis: Axis | undefined = first;
+  let i = 0;
+  while (i < p.length - 1) {
+    let step: { j: number; legs: Point[] } | undefined;
+    for (let j = Math.min(p.length - 1, i + lookahead); j > i && !step; j--) {
+      const legs = square(p[i]!, p[j]!, obstacles, pad, axis, j === p.length - 1 ? last : undefined);
+      if (legs) step = { j, legs };
+    }
+    // With no clear legs to the next vertex, the legs may touch a box, but they do not go through it.
+    step ??= {
+      j: i + 1,
+      legs: square(p[i]!, p[i + 1]!, obstacles, 0, axis, i + 1 === p.length - 1 ? last : undefined) ?? [p[i + 1]!],
+    };
+    out.push(...step.legs);
+    const end = out[out.length - 1]!;
+    const before = out[out.length - 2]!;
+    axis = Math.abs(end.y - before.y) < EPS ? "x" : Math.abs(end.x - before.x) < EPS ? "y" : undefined;
+    i = step.j;
+  }
+  return out;
+}
+
+/**
+ * This function gives one or two legs parallel to the axes from `a` to `b`, clear of the obstacles by `pad`, or `undefined`.
+ * Of two clear corners, it picks the corner that continues the axis `from` and arrives along the axis `to`.
+ */
+function square(a: Point, b: Point, obstacles: Obstacles, pad: number, from: Axis | undefined, to: Axis | undefined): Point[] | undefined {
+  if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : undefined;
+  // The corner of `x` goes along the x axis first, and the corner of `y` along the y axis first.
+  const options: { c: Point; bends: number }[] = [
+    { c: { x: b.x, y: a.y }, bends: (from === "y" ? 1 : 0) + (to === "x" ? 1 : 0) },
+    { c: { x: a.x, y: b.y }, bends: (from === "x" ? 1 : 0) + (to === "y" ? 1 : 0) },
+  ];
+  options.sort((u, v) => u.bends - v.bends);
+  for (const { c } of options) if (obstacles.clear(a, c, pad) && obstacles.clear(c, b, pad)) return [c, b];
+  return undefined;
+}

package/src/routers/sections.ts

@@ -1,16 +1,6 @@
 import { center, dist, polylineLength, type Box, type Point } from "../geom.ts";
-import {
-  nodeIndex,
-  type Graph,
-  type Level,
-  type LevelItem,
-  type LevelLink,
-  type Node,
-  type Result,
-  type Route,
-  type Router,
-  type SharedRun,
-} from "../model.ts";
+import { levelLinks, type ItemPair } from "../levels.ts";
+import { nodeIndex, type Graph, type Level, type LevelItem, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 import { allSections, buildSections, treeDepth, type Section, type SectionOptions } from "../sections.ts";
 import { orderLanes } from "../segments.ts";
@@ -37,7 +27,10 @@ const dedupe = (p: readonly Point[]): Point[] => p.filter((q, i) => i === 0 || d
  * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
  * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
  * Each way from hub to hub is found one time, so all the edges on it share its points.
- * The edges in one section of the lowest level go straight around the nodes. The result gives one zoom level for each depth of the tree.
+ * The edges in one section of the lowest level go straight around the nodes.
+ *
+ * The result gives one zoom level for each depth of the tree.
+ * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
  */
 export function sectionsRouter(options: SectionsOptions): Router {
   const router: Router = {
@@ -98,8 +91,6 @@ export function sectionsRouter(options: SectionsOptions): Router {
       const at = (p: Point): string => `${p.x},${p.y}`;
 
       const routes: Route[] = [];
-      // The index in the route of each hub that the route passes, by section.
-      const marks = new Map<string, Map<Section, number>>();
       for (const e of graph.edges) {
         const s = byId.get(e.source.node);
         const t = byId.get(e.target.node);
@@ -122,18 +113,13 @@ export function sectionsRouter(options: SectionsOptions): Router {
         const side = (list: Section[]): Section[] => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
         const chain = [...side(a), ...side(b).reverse()];
         const out: Point[] = [ps.point];
-        const mark = new Map<Section, number>();
         const append = (p: readonly Point[]): void => {
           for (const q of p) if (dist(q, out[out.length - 1]!) > 1e-9) out.push(q);
         };
         const used: string[] = [];
         const start = ways.out(ps);
         append(piece(at(start), start, chain[0]!.id, hub(chain[0]!), used));
-        mark.set(chain[0]!, out.length - 1);
-        for (let i = 1; i < chain.length; i++) {
-          append(piece(chain[i - 1]!.id, hub(chain[i - 1]!), chain[i]!.id, hub(chain[i]!), used));
-          mark.set(chain[i]!, out.length - 1);
-        }
+        for (let i = 1; i < chain.length; i++) append(piece(chain[i - 1]!.id, hub(chain[i - 1]!), chain[i]!.id, hub(chain[i]!), used));
         const end = ways.out(pt);
         append(piece(chain[chain.length - 1]!.id, hub(chain[chain.length - 1]!), at(end), end, used));
         append([pt.point]);
@@ -148,7 +134,6 @@ export function sectionsRouter(options: SectionsOptions): Router {
           else users.set(key, [e.id]);
         }
         routes.push({ edge: e.id, points: out });
-        marks.set(e.id, mark);
       }
 
       const routeOf = new Map(routes.map((r) => [r.edge, r]));
@@ -158,7 +143,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
         if (list.length < 2 || p.length < 2) continue;
         runs.push({ id: `r${runs.length}`, key, points: p, edges: orderLanes(p, list.map((id) => routeOf.get(id)!)) });
       }
-      return { routes, runs, levels: makeLevels(graph, root, routeOf, marks) };
+      return { routes, runs, levels: makeLevels(graph, root, routeOf, options) };
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
@@ -167,14 +152,10 @@ export function sectionsRouter(options: SectionsOptions): Router {
 /**
  * This function gives one zoom level for each depth of the tree, and a last level with each node alone.
  * At depth d, a section of depth d is one item. A link joins two items and counts the edges between them.
- * Its points are the part of the route of its first edge between the two items.
+ * In a level with groups, a link goes around the boxes of the other items (`levelLinks`).
+ * In the last level, the points of a link are the route of its first edge.
  */
-function makeLevels(
-  graph: Graph,
-  root: Section,
-  routeOf: ReadonlyMap<string, Route>,
-  marks: ReadonlyMap<string, ReadonlyMap<Section, number>>,
-): Level[] {
+function makeLevels(graph: Graph, root: Section, routeOf: ReadonlyMap<string, Route>, options: WayOptions): Level[] {
   const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
   const levels: Level[] = [];
   const deepest = treeDepth(root);
@@ -208,7 +189,7 @@ function makeLevels(
         }
     };
     if (graph.nodes.length > 0) visit(root);
-    const links = new Map<string, { source: string; target: string; count: number; points: readonly Point[] }>();
+    const links = new Map<string, { source: string; target: string; count: number; edge: string }>();
     for (const e of graph.edges) {
       const iu = indexOfNode.get(e.source.node);
       const iv = indexOfNode.get(e.target.node);
@@ -224,13 +205,12 @@ function makeLevels(
         link.count++;
         continue;
       }
-      const route = routeOf.get(e.id)?.points ?? [];
-      const mark = marks.get(e.id);
-      const from = typeof a === "number" ? 0 : (mark?.get(a) ?? 0);
-      const to = typeof b === "number" ? route.length - 1 : (mark?.get(b) ?? route.length - 1);
-      links.set(key, { source: ida, target: idb, count: 1, points: route.slice(from, to + 1) });
+      links.set(key, { source: ida, target: idb, count: 1, edge: e.id });
     }
-    levels.push({ depth: d, items, links: [...links.values()] as LevelLink[] });
+    const pairs: ItemPair[] = [...links.values()].map(({ source, target, count }) => ({ source, target, count }));
+    if (d > deepest)
+      levels.push({ depth: d, items, links: [...links.values()].map(({ edge, ...l }) => ({ ...l, points: routeOf.get(edge)?.points ?? [] })) });
+    else levels.push({ depth: d, items, links: levelLinks(items, pairs, options) });
   }
   return levels;
 }

package/src/segments.ts

@@ -148,6 +148,30 @@ export interface PullApartOptions {
  * The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
  */
 export function pullApart(graph: SegmentGraph, options: PullApartOptions): Route[] {
+  return lanePaths(graph, (s) => (s.count > 1 ? Math.min(options.spacing, options.maxWidth / (s.count - 1)) : 0));
+}
+
+/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
+export function runKey(edges: readonly string[]): string {
+  return [...edges].sort().join(",");
+}
+
+/**
+ * This function opens the shared segments whose key is in `open`: each edge of an open segment gets its own lane.
+ * The lanes are `laneWidth` apart, and an open segment is at most `maxWidth` wide. The other segments stay as one way.
+ *
+ * Lane 0 is on the left of the segment, from its first point to its last, with the y axis down.
+ * The function takes a result or its segments. It gives a route for each edge, with the ends at their plugs.
+ * The key of a segment is `runKey` of its edges.
+ */
+export function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<string>, laneWidth: number, maxWidth: number = Infinity): Route[] {
+  const graph = "paths" in source ? source : segmentsOf(source);
+  if (open.size === 0) return graph.paths.map((path) => ({ edge: path.edge, points: pathPoints(graph, path) }));
+  return lanePaths(graph, (s) => (s.count > 1 && open.has(runKey(s.edges)) ? Math.min(laneWidth, maxWidth / (s.count - 1)) : 0));
+}
+
+/** This function gives the route of each path, with the lanes of each segment at the spacing that `spacingOf` gives. */
+function lanePaths(graph: SegmentGraph, spacingOf: (s: Segment) => number): Route[] {
   const byId = new Map(graph.segments.map((s) => [s.id, s]));
   const routes: Route[] = [];
   for (const path of graph.paths) {
@@ -156,9 +180,8 @@ export function pullApart(graph: SegmentGraph, options: PullApartOptions): Route
     for (const ref of path.segments) {
       const s = byId.get(ref.segment);
       if (!s) continue;
-      const n = s.count;
-      const spacing = n > 1 ? Math.min(options.spacing, options.maxWidth / (n - 1)) : 0;
-      const moved = offsetPolyline(s.points, ((n - 1) / 2 - ref.lane) * spacing);
+      const spacing = spacingOf(s);
+      const moved = offsetPolyline(s.points, ((s.count - 1) / 2 - ref.lane) * spacing);
       for (const q of ref.reverse ? moved.reverse() : moved) if (out.length === 0 || dist(q, out[out.length - 1]!) > SAME) out.push(q);
     }
     if (out.length >= 2 && ends.length >= 2) {

package/src/visibility.ts

@@ -81,6 +81,8 @@ export class CornerGraph {
   // The stamp of the last call of nearestVisible that tested each corner.
   #tested = new Int32Array(0);
   #testStamp = 0;
+  // The corners that each end of a path sees, by the coordinates of the end.
+  readonly #endCache = new Map<string, number[]>();
 
   /** This constructor makes the graph of the nodes. */
   constructor(nodes: readonly Node[], obstacles: Obstacles, options: CornerGraphOptions) {
@@ -167,6 +169,10 @@ export class CornerGraph {
 
   /** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
   nearestVisible(p: Point, k: number, self = -1): number[] {
+    return this.#nearestVisible(p, k, self, this.#pad);
+  }
+
+  #nearestVisible(p: Point, k: number, self: number, pad: number): number[] {
     const out: number[] = [];
     if (this.#tested.length < this.points.length) this.#tested = new Int32Array(this.points.length);
     const tested = this.#tested;
@@ -181,7 +187,7 @@ export class CornerGraph {
         // A corner beyond r can be nearer than a corner of the next ring, so it waits for that ring.
         if (d > r) break;
         tested[j] = stamp;
-        if (this.#obstacles.clear(p, this.points[j]!, this.#pad)) out.push(j);
+        if (this.#obstacles.clear(p, this.points[j]!, pad)) out.push(j);
         if (out.length >= k) return out;
       }
     }
@@ -205,7 +211,7 @@ export class CornerGraph {
     }
     const stamp = ++this.#stamp;
     const goal = new Map<number, number>();
-    for (const j of this.nearestVisible(to, this.#k * 2)) goal.set(j, dist(this.points[j]!, to));
+    for (const j of this.#ends(to)) goal.set(j, dist(this.points[j]!, to));
     if (goal.size === 0) return undefined;
     const heap = new MinHeap();
     const h = (i: number): number => floor * dist(this.points[i]!, to);
@@ -217,7 +223,7 @@ export class CornerGraph {
       this.#parent[j] = parent;
       heap.push(g + h(j), j);
     };
-    for (const j of this.nearestVisible(from, this.#k * 2)) relax(j, dist(from, this.points[j]!), -1);
+    for (const j of this.#ends(from)) relax(j, dist(from, this.points[j]!), -1);
     let best = Infinity;
     let bestEnd = -1;
     while (heap.size > 0) {
@@ -246,6 +252,22 @@ export class CornerGraph {
     return out.reverse();
   }
 
+  /**
+   * This method gives the corners that an end of a path can see. An end near a box sees no corner with the clearance.
+   * Then the end takes the corners that it sees without the clearance, so the path does not cut through the boxes.
+   * The graph does not change, so the method keeps the corners of each end.
+   */
+  #ends(p: Point): number[] {
+    const key = `${p.x},${p.y}`;
+    let out = this.#endCache.get(key);
+    if (!out) {
+      out = this.nearestVisible(p, this.#k * 2);
+      if (out.length === 0) out = this.#nearestVisible(p, this.#k * 2, -1, 0);
+      this.#endCache.set(key, out);
+    }
+    return out;
+  }
+
   /** This method removes the vertices that a later vertex makes needless: from each vertex, it goes to the farthest vertex in view. */
   pull(p: readonly Point[], lookahead = 16): Point[] {
     if (p.length < 3) return [...p];