@mark1russell7/highways 0.1.0 → 0.1.2

package/build/index.d.ts

@@ -391,6 +391,17 @@ 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 declare function pullApart(graph: SegmentGraph, options: PullApartOptions): Route[];
+/** This function gives the key of a shared run: the ids of its edges, sorted and joined with commas. */
+export declare function runKey(edges: readonly string[]): string;
+/**
+ * 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 declare function laneRoutes(source: Result | SegmentGraph, open: ReadonlySet<string>, laneWidth: number, maxWidth?: number): Route[];
 /**
  * This function gives the lane order of the edges on a shared way `run` (metro-line order). Two routes go on together
  * past the last point of the run until they part. The route that turns more to the left there gets the lane more to the left.
@@ -485,7 +496,10 @@ interface SectionsOptions extends WayOptions, SectionOptions {
  * 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 declare function sectionsRouter(options: SectionsOptions): Router;
 /** The options of the trunk router. */
@@ -531,7 +545,7 @@ export declare function trunksRouter(options: TrunksOptions): Router;
 export declare const ROUTERS: readonly Router[];
 /** 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;
 }
@@ -540,6 +554,7 @@ export declare const TOLERANCE = .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.

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geom.ts","../src/grid.ts","../src/model.ts","../src/fixtures.ts","../src/plugs.ts","../src/curves.ts","../src/visibility.ts","../src/ways.ts","../src/segments.ts","../src/sections.ts","../src/routers/straight.ts","../src/routers/plugs.ts","../src/routers/corners.ts","../src/routers/shared.ts","../src/routers/sections.ts","../src/routers/trunks.ts","../src/routers/index.ts","../src/bench/properties.ts","../src/bench/quality.ts","../src/bench/run.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geom.ts","../src/grid.ts","../src/model.ts","../src/fixtures.ts","../src/plugs.ts","../src/curves.ts","../src/visibility.ts","../src/ways.ts","../src/segments.ts","../src/sections.ts","../src/routers/straight.ts","../src/routers/plugs.ts","../src/routers/corners.ts","../src/routers/shared.ts","../src/routers/sections.ts","../src/routers/trunks.ts","../src/routers/index.ts","../src/bench/properties.ts","../src/bench/quality.ts","../src/bench/run.ts"],"mappings":"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"}

package/build/index.js

@@ -372,7 +372,7 @@ const COLLECTIONS = [
 	"scores",
 	"teams"
 ];
-const SIDES = [
+const SIDES$1 = [
 	"north",
 	"east",
 	"south",
@@ -441,7 +441,7 @@ function makeFixture(spec) {
 		clusterOf.push(cluster);
 		const id = `n${nodes.length}`;
 		if (R() < (spec.fixedPorts ?? 0)) {
-			const s = SIDES[Math.floor(R() * 4)];
+			const s = SIDES$1[Math.floor(R() * 4)];
 			const t = .2 + .6 * R();
 			const at = s === "north" ? {
 				x: w * t,
@@ -778,6 +778,7 @@ var CornerGraph = class {
 	#stamp = 0;
 	#tested = /* @__PURE__ */ new Int32Array(0);
 	#testStamp = 0;
+	#endCache = /* @__PURE__ */ new Map();
 	/** This constructor makes the graph of the nodes. */
 	constructor(nodes, obstacles, options) {
 		this.#obstacles = obstacles;
@@ -877,6 +878,9 @@ var CornerGraph = class {
 	}
 	/** This method gives at most `k` corners that `p` can see, nearest first. The corner `self` does not count. */
 	nearestVisible(p, k, self = -1) {
+		return this.#nearestVisible(p, k, self, this.#pad);
+	}
+	#nearestVisible(p, k, self, pad) {
 		const out = [];
 		if (this.#tested.length < this.points.length) this.#tested = new Int32Array(this.points.length);
 		const tested = this.#tested;
@@ -895,7 +899,7 @@ var CornerGraph = class {
 			for (const [d, j] of cands) {
 				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;
 			}
 		}
@@ -918,7 +922,7 @@ var CornerGraph = class {
 		}
 		const stamp = ++this.#stamp;
 		const goal = /* @__PURE__ */ new Map();
-		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 void 0;
 		const heap = new MinHeap();
 		const h = (i) => floor * dist(this.points[i], to);
@@ -930,7 +934,7 @@ var CornerGraph = class {
 			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) {
@@ -958,6 +962,21 @@ var CornerGraph = class {
 		out.push(from);
 		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) {
+		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, lookahead = 16) {
 		if (p.length < 3) return [...p];
@@ -1240,6 +1259,30 @@ function offsetPolyline(p, d) {
 * The lanes keep the lane order, so they do not cross in a segment. The two ends of each route stay at their plugs.
 */
 function pullApart(graph, options) {
+	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. */
+function runKey(edges) {
+	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.
+*/
+function laneRoutes(source, open, laneWidth, maxWidth = Infinity) {
+	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, spacingOf) {
 	const byId = new Map(graph.segments.map((s) => [s.id, s]));
 	const routes = [];
 	for (const path of graph.paths) {
@@ -1248,9 +1291,8 @@ function pullApart(graph, options) {
 		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) {
@@ -1469,13 +1511,281 @@ const plugsRouter = {
 		return { routes };
 	}
 };
+// src/levels.ts
+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) {
+	const out = [];
+	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;
+			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.
+*/
+function levelLinks(items, pairs, options = {}) {
+	if (pairs.length === 0) return [];
+	const nodes = 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 = [];
+	for (const p of pairs) {
+		const s = byId.get(p.source);
+		const t = byId.get(p.target);
+		if (!s || !t) continue;
+		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)) : void 0;
+		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, options) {
+	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)));
+	return {
+		obstacles,
+		corners: new CornerGraph(nodes, obstacles, {
+			margin,
+			k: options.k ?? 8
+		}),
+		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.
+*/
+function facingPlugs(a, b, inset) {
+	const sa = sideToward(a, center(b));
+	const sb = sideToward(b, center(a));
+	const plug = (box, side, toward) => ({
+		point: pointOnSide(box, side, toward, inset),
+		normal: SIDE_NORMAL[side]
+	});
+	const across = sa === "east" && sb === "west" || sa === "west" && sb === "east";
+	if (across || sa === "south" && sb === "north" || sa === "north" && sb === "south") {
+		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, side) => 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 = [
+	"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, node, plug) {
+	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, node, toward) {
+	const b = node.box;
+	const c = center(b);
+	const d = {
+		x: toward.x - c.x,
+		y: toward.y - c.y
+	};
+	const facing = (s) => 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) => {
+		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]);
+}
+/**
+* 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, s, ps, t, pt) {
+	let ra = reach(ways, s, ps);
+	let rb = reach(ways, t, pt);
+	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, d) => ({
+	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, node, plug) {
+	const skip = /* @__PURE__ */ 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, e) {
+	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, e) {
+	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
+	]);
+}
+const axisOf = (n) => 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, obstacles, pad, first, last, lookahead = 16) {
+	if (p.length === 0) return [];
+	const out = [p[0]];
+	let axis = first;
+	let i = 0;
+	while (i < p.length - 1) {
+		let step;
+		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 : void 0);
+			if (legs) step = {
+				j,
+				legs
+			};
+		}
+		step ??= {
+			j: i + 1,
+			legs: square(p[i], p[i + 1], obstacles, 0, axis, i + 1 === p.length - 1 ? last : void 0) ?? [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" : void 0;
+		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, b, obstacles, pad, from, to) {
+	if (Math.abs(a.x - b.x) < EPS || Math.abs(a.y - b.y) < EPS) return obstacles.clear(a, b, pad) ? [b] : void 0;
+	const options = [{
+		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];
+}
 // src/routers/sections.ts
 const dedupe$1 = (p) => p.filter((q, i) => i === 0 || dist(q, p[i - 1]) > 1e-9);
 /**
 * 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.
 */
 function sectionsRouter(options) {
 	const router = {
@@ -1536,7 +1846,6 @@ function sectionsRouter(options) {
 			};
 			const at = (p) => `${p.x},${p.y}`;
 			const routes = [];
-			const marks = /* @__PURE__ */ new Map();
 			for (const e of graph.edges) {
 				const s = byId.get(e.source.node);
 				const t = byId.get(e.target.node);
@@ -1562,18 +1871,13 @@ function sectionsRouter(options) {
 				const side = (list) => list.slice(Math.max(0, list.indexOf(lca) - keep), list.indexOf(lca));
 				const chain = [...side(a), ...side(b).reverse()];
 				const out = [ps.point];
-				const mark = /* @__PURE__ */ new Map();
 				const append = (p) => {
 					for (const q of p) if (dist(q, out[out.length - 1]) > 1e-9) out.push(q);
 				};
 				const used = [];
 				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]);
@@ -1593,7 +1897,6 @@ function sectionsRouter(options) {
 					edge: e.id,
 					points: out
 				});
-				marks.set(e.id, mark);
 			}
 			const routeOf = new Map(routes.map((r) => [r.edge, r]));
 			const runs = [];
@@ -1610,7 +1913,7 @@ function sectionsRouter(options) {
 			return {
 				routes,
 				runs,
-				levels: makeLevels(graph, root, routeOf, marks)
+				levels: makeLevels(graph, root, routeOf, options)
 			};
 		}
 	};
@@ -1622,9 +1925,10 @@ function sectionsRouter(options) {
 /**
 * 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, root, routeOf, marks) {
+function makeLevels(graph, root, routeOf, options) {
 	const indexOfNode = new Map(graph.nodes.map((n, i) => [n.id, i]));
 	const levels = [];
 	const deepest = treeDepth(root);
@@ -1686,21 +1990,30 @@ function makeLevels(graph, root, routeOf, marks) {
 				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)
+				edge: e.id
 			});
 		}
-		levels.push({
+		const pairs = [...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: [...links.values()]
+			links: levelLinks(items, pairs, options)
 		});
 	}
 	return levels;
@@ -2139,6 +2452,7 @@ const TOLERANCE = .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.
@@ -2252,9 +2566,26 @@ function checkProperties(graph, result, limit = 100) {
 				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, b) {
+	const inner = inflate(b, -.5);
+	return !(p.x > inner.x && p.x < inner.x + inner.w && p.y > inner.y && p.y < inner.y + inner.h) && pointBoxDistance(p, b) <= .5;
+}
 /** This function tells if the polyline `p` holds the points of `part` in a row. */
 function holds(p, part) {
 	if (part.length === 0) return true;
@@ -2520,6 +2851,6 @@ function formatTable(rows) {
 		})
 	].join("\n");
 }
-export { CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, dist, fixedPortPoint, formatTable, frechet, groupEdges, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, makeFixture, measureQuality, measureStability, nearestSide, nodeIndex, offsetPolyline, orderLanes, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roundCorners, runBenchmark, sameData, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splitPoint, straightRouter, treeDepth, trunksRouter, turns };
+export { CLEARANCE_CAP, CornerGraph, FIXTURES, Grid, Obstacles, ROUTERS, SIDE_NORMAL, TOLERANCE, WayFinder, allSections, benchOne, bendCount, boxExit, buildSections, byCollection, center, checkProperties, cornersRouter, countCrossings, dist, fixedPortPoint, formatTable, frechet, groupEdges, inflate, inflectionCount, inflectionCurve, inflectionSector, laneOrder, laneRoutes, makeFixture, measureQuality, measureStability, nearestSide, nodeIndex, offsetPolyline, orderLanes, pathPoints, placePlug, plugsRouter, pointBoxDistance, pointOnSide, pointSegmentDistance, polylineLength, pullApart, rng, roundCorners, runBenchmark, runKey, sameData, sectionsRouter, segmentBounds, segmentBoxDistance, segmentHitsBox, segmentHitsRect, segmentsCross, segmentsOf, sharedRouter, sideAngle, sideToward, splitPoint, straightRouter, treeDepth, trunksRouter, turns };
 
 //# sourceMappingURL=index.js.map