An agent skill for creating detailed, interactive isometric illustrations of real-world machines and complex systems. Generates polished SVGs with optional WebGL shaders and 3D effects.
import { cameraOf, roundedPlan } from "./iso-kit.mjs";
import { add3, sub3, mul3, dot3, len3, unit3, pathLength, resample, curveRuns, cut as cutAlong, tangentAlong } from "./lathe.mjs";
import { runsOf } from "./tube.mjs";
const BIG = 1e9;
export function body(F, poly, meta = {}) {
return { kind: "body", F, poly: poly.map(([s, r]) => [s, Math.max(0, r)]), ...meta };
}
export function traced(meridian, { radius = null, error = 0.02, depth = 6 } = {}) {
const segments = radius ? null : curveRuns(meridian);
const out = [[meridian[0][0], meridian[0][1]]];
for (let index = 0; index < meridian.length - 1; index++) {
const [s0] = meridian[index];
const [s1, r1] = meridian[index + 1];
const along = Math.abs(s1 - s0) > 1e-9;
const at = along && radius ? radius : along && segments[index] ? segments[index].radius : null;
if (at) {
const split = (a, b, level) => {
const mid = (a + b) / 2;
if (level >= depth) return;
const ra = at(a);
const rb = at(b);
const deviation = Math.max(...[0.25, 0.5, 0.75].map((t) => Math.abs(at(a + (b - a) * t) - (ra + (rb - ra) * t))));
if (deviation <= error) return;
split(a, mid, level + 1);
out.push([mid, at(mid)]);
split(mid, b, level + 1);
};
split(s0, s1, 0);
}
out.push([s1, r1]);
}
return out;
}
export function lathe(F, meridian, { radius = null, ...meta } = {}) {
return body(F, traced(meridian, { radius }), meta);
}
export function solid(F, profile, { radius = null, ...meta } = {}) {
const first = profile[0];
const last = profile[profile.length - 1];
return body(F, traced([[first[0], 0], ...profile, [last[0], 0]], { radius: radius && ((s) => radius(Math.max(first[0], Math.min(last[0], s)))) }), meta);
}
export function prism(F, polygon, s0, s1, meta = {}) {
return { kind: "prism", F, poly: polygon.map(([x, y]) => [x, y]), s0: Math.min(s0, s1), s1: Math.max(s0, s1), ...meta };
}
const FLOOR = { o: [0, 0, 0], a: [0, 0, 1], u: [1, 0, 0], v: [0, 1, 0] };
export const extruded = (ring, z, height, meta = {}) => prism(FLOOR, ring, z, z + height, meta);
export const slab = (plan, z, height, meta = {}, steps = 8) => extruded(roundedPlan(plan, steps), z, height, meta);
export const cylinder = (cx, cy, r, z, height, meta = {}) => disc({ o: [cx, cy, 0], a: [0, 0, 1], u: [1, 0, 0], v: [0, 1, 0] }, z, z + height, r, meta);
export const disc = (F, s0, s1, r, meta = {}) => body(F, [[s0, 0], [s0, r], [s1, r], [s1, 0]], meta);
export const ring = (F, s0, s1, rIn, rOut, meta = {}) => body(F, [[s0, rIn], [s0, rOut], [s1, rOut], [s1, rIn]], meta);
export function box(min, max, meta = {}) {
const centre = mul3(add3(min, max), 0.5);
return { kind: "box", o: centre, axes: [[1, 0, 0], [0, 1, 0], [0, 0, 1]], half: mul3(sub3(max, min), 0.5), ...meta };
}
export const orientedBox = (centre, axes, half, meta = {}) => ({ kind: "box", o: centre, axes: axes.map(unit3), half, ...meta });
export const ball = (at, r, meta = {}) => ({ kind: "ball", o: at, r, ...meta });
export function tube(points, radius, meta = {}) {
const total = pathLength(points) || 1;
let walked = 0;
const radii = Array.isArray(radius)
? radius
: points.map((point, index) => {
if (index > 0) walked += len3(sub3(point, points[index - 1]));
return typeof radius === "function" ? radius(walked / total) : radius;
});
return { kind: "tube", points, radii, round: meta.round ?? [false, false], ...meta };
}
export const slide = (F, from, to, r, meta = {}) => ({ ...disc(F, from, to, r, meta), slide: { from, to, r } });
export function moved(shape, offset) {
if (!offset || (!offset[0] && !offset[1] && !offset[2])) return shape;
if (shape.slide) {
const { from, to, r } = shape.slide;
const reach = Math.max(from + 1e-3, to + dot3(offset, shape.F.a));
return { ...shape, poly: [[from, 0], [from, r], [reach, r], [reach, 0]], slide: { from, to: reach, r }, _b: undefined, _f: undefined };
}
const cut = shape.cut ? (Array.isArray(shape.cut) ? shape.cut.map((one) => moved(one, offset)) : moved(shape.cut, offset)) : undefined;
if (shape.kind === "body" || shape.kind === "prism") return { ...shape, cut, F: { ...shape.F, o: add3(shape.F.o, offset) }, _b: undefined, _f: undefined };
if (shape.kind === "tube") return { ...shape, cut, points: shape.points.map((p) => add3(p, offset)), tips: shape.tips && shape.tips.map((tip) => tip && add3(tip, offset)), _b: undefined };
return { ...shape, cut, o: add3(shape.o, offset), _b: undefined };
}
function polyDistance(poly, s, r) {
let best = BIG;
let inside = false;
for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
const [s0, r0] = poly[j];
const [s1, r1] = poly[i];
const ds = s1 - s0;
const dr = r1 - r0;
const span = ds * ds + dr * dr;
const t = span > 0 ? Math.max(0, Math.min(1, ((s - s0) * ds + (r - r0) * dr) / span)) : 0;
const es = s - s0 - ds * t;
const er = r - r0 - dr * t;
const d = es * es + er * er;
if (d < best && (r0 > 1e-9 || r1 > 1e-9)) best = d;
if (r0 > r !== r1 > r && s < s0 + ((r - r0) * ds) / (dr || 1e-12)) inside = !inside;
}
const d = Math.sqrt(best);
return inside ? -d : d;
}
function polygonDistance(poly, x, y) {
let best = BIG;
let inside = false;
for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
const [x0, y0] = poly[j];
const [x1, y1] = poly[i];
const dx = x1 - x0;
const dy = y1 - y0;
const span = dx * dx + dy * dy;
const t = span > 0 ? Math.max(0, Math.min(1, ((x - x0) * dx + (y - y0) * dy) / span)) : 0;
const ex = x - x0 - dx * t;
const ey = y - y0 - dy * t;
const d = ex * ex + ey * ey;
if (d < best) best = d;
if (y0 > y !== y1 > y && x < x0 + ((y - y0) * dx) / (dy || 1e-12)) inside = !inside;
}
const d = Math.sqrt(best);
return inside ? -d : d;
}
function cappedSegment(p, a, b, r, endRadius = r) {
const bx = b[0] - a[0];
const by = b[1] - a[1];
const bz = b[2] - a[2];
const px = p[0] - a[0];
const py = p[1] - a[1];
const pz = p[2] - a[2];
const baba = bx * bx + by * by + bz * bz || 1e-12;
const paba = px * bx + py * by + pz * bz;
if (endRadius !== r) {
const length = Math.sqrt(baba);
const along = paba / length;
const radial = Math.hypot(px - bx * paba / baba, py - by * paba / baba, pz - bz * paba / baba);
return polyDistance([[0, 0], [0, r], [length, endRadius], [length, 0]], along, radial);
}
const x = Math.hypot(px * baba - bx * paba, py * baba - by * paba, pz * baba - bz * paba) - r * baba;
const y = Math.abs(paba - baba * 0.5) - baba * 0.5;
const x2 = x * x;
const y2 = y * y * baba;
const d = Math.max(x, y) < 0 ? -Math.min(x2, y2) : (x > 0 ? x2 : 0) + (y > 0 ? y2 : 0);
return (Math.sign(d) * Math.sqrt(Math.abs(d))) / baba;
}
function segmentPoint(p, a, b) {
const ba = sub3(b, a);
const pa = sub3(p, a);
const t = Math.max(0, Math.min(1, dot3(pa, ba) / (dot3(ba, ba) || 1e-12)));
return { d: len3(sub3(pa, mul3(ba, t))), t };
}
export function sdf(shape, p) {
const d = baseSdf(shape, p);
return shape.cut ? Math.max(d, -cutDistance(shape, p)) : d;
}
function cutDistance(shape, p) {
if (!Array.isArray(shape.cut)) return sdf(shape.cut, p);
let best = BIG;
for (const cut of shape.cut) best = Math.min(best, sdf(cut, p));
return best;
}
function baseSdf(shape, p) {
if (shape.kind === "body") {
const { F } = shape;
const q = sub3(p, F.o);
const s = dot3(q, F.a);
const x = dot3(q, F.u);
const y = dot3(q, F.v);
return polyDistance(shape.poly, s, Math.hypot(x, y));
}
if (shape.kind === "ball") {
let d = len3(sub3(p, shape.o)) - shape.r;
if (shape.flats) for (const [nx, ny, nz, cut] of shape.flats) d = Math.max(d, nx * (p[0] - shape.o[0]) + ny * (p[1] - shape.o[1]) + nz * (p[2] - shape.o[2]) - cut);
return d;
}
if (shape.kind === "prism") {
const { F } = shape;
const q = sub3(p, F.o);
const s = dot3(q, F.a);
const flat = polygonDistance(shape.poly, dot3(q, F.u), dot3(q, F.v));
const along = Math.max(shape.s0 - s, s - shape.s1);
return Math.hypot(Math.max(flat, 0), Math.max(along, 0)) + Math.min(Math.max(flat, along), 0);
}
if (shape.kind === "box") {
const q = sub3(p, shape.o);
const d = shape.axes.map((axis, index) => Math.abs(dot3(q, axis)) - shape.half[index]);
const outside = Math.hypot(Math.max(d[0], 0), Math.max(d[1], 0), Math.max(d[2], 0));
return outside + Math.min(Math.max(d[0], d[1], d[2]), 0);
}
const { points, radii, round } = shape;
let best = BIG;
const last = points.length - 1;
for (let index = 0; index < last; index++) {
const d = cappedSegment(p, points[index], points[index + 1], radii[index], radii[index + 1]);
if (d < best) best = d;
}
if (round[0]) best = Math.min(best, len3(sub3(p, points[0])) - radii[0]);
if (round[1]) best = Math.min(best, len3(sub3(p, points[last])) - radii[last]);
return best;
}
export function boundsOf(shape) {
if (shape._b) return shape._b;
let min;
let max;
if (shape.kind === "body") {
const { F, poly } = shape;
const s0 = Math.min(...poly.map(([s]) => s));
const s1 = Math.max(...poly.map(([s]) => s));
const rm = Math.max(...poly.map(([, r]) => r));
const a = add3(F.o, mul3(F.a, s0));
const b = add3(F.o, mul3(F.a, s1));
const spread = [0, 1, 2].map((i) => rm * Math.sqrt(Math.max(0, 1 - F.a[i] * F.a[i])));
min = [0, 1, 2].map((i) => Math.min(a[i], b[i]) - spread[i]);
max = [0, 1, 2].map((i) => Math.max(a[i], b[i]) + spread[i]);
} else if (shape.kind === "ball") {
min = shape.o.map((v) => v - shape.r);
max = shape.o.map((v) => v + shape.r);
} else if (shape.kind === "prism") {
const { F } = shape;
min = [BIG, BIG, BIG];
max = [-BIG, -BIG, -BIG];
for (const s of [shape.s0, shape.s1])
for (const [x, y] of shape.poly) {
const p = add3(add3(F.o, mul3(F.a, s)), add3(mul3(F.u, x), mul3(F.v, y)));
for (let i = 0; i < 3; i++) (min[i] = Math.min(min[i], p[i])), (max[i] = Math.max(max[i], p[i]));
}
} else if (shape.kind === "box") {
const extent = [0, 1, 2].map((i) => shape.axes.reduce((sum, axis, j) => sum + Math.abs(axis[i]) * shape.half[j], 0));
min = shape.o.map((v, i) => v - extent[i]);
max = shape.o.map((v, i) => v + extent[i]);
} else {
min = [BIG, BIG, BIG];
max = [-BIG, -BIG, -BIG];
shape.points.forEach((p, index) => {
for (let i = 0; i < 3; i++) {
min[i] = Math.min(min[i], p[i] - shape.radii[index]);
max[i] = Math.max(max[i], p[i] + shape.radii[index]);
}
});
}
shape._b = { min, max };
return shape._b;
}
export function cameraBasis(P) {
const { sinA, cosA, sinE, cosE, k } = cameraOf(P);
return { R: [sinA, -cosA, 0], D: [cosA * sinE, sinA * sinE, -cosE], V: [cosA * cosE, sinA * cosE, sinE], k, origin: P.origin };
}
function screenBox(shape, cam, offset) {
const { min, max } = boundsOf(shape);
let x0 = BIG;
let y0 = BIG;
let x1 = -BIG;
let y1 = -BIG;
const visit = (p) => {
const x = cam.origin[0] + dot3(p, cam.R) * cam.k;
const y = cam.origin[1] + dot3(p, cam.D) * cam.k;
x0 = Math.min(x0, x);
y0 = Math.min(y0, y);
x1 = Math.max(x1, x);
y1 = Math.max(y1, y);
};
if (shape.kind === "tube") {
shape.points.forEach((p, index) => {
const r = shape.radii[index];
const q = add3(p, offset);
visit(add3(q, mul3(cam.R, r)));
visit(add3(q, mul3(cam.R, -r)));
visit(add3(q, mul3(cam.D, r)));
visit(add3(q, mul3(cam.D, -r)));
});
} else {
for (const x of [min[0], max[0]]) for (const y of [min[1], max[1]]) for (const z of [min[2], max[2]]) visit(add3([x, y, z], offset));
}
return [x0, y0, x1, y1];
}
function spanOf(c, V, min, max) {
let t0 = -BIG;
let t1 = BIG;
for (let i = 0; i < 3; i++) {
if (Math.abs(V[i]) < 1e-12) {
if (c[i] < min[i] || c[i] > max[i]) return null;
continue;
}
let a = (min[i] - c[i]) / V[i];
let b = (max[i] - c[i]) / V[i];
if (a > b) [a, b] = [b, a];
t0 = Math.max(t0, a);
t1 = Math.min(t1, b);
}
return t0 <= t1 ? [t0, t1] : null;
}
function tubeDistance(shape, p, segments) {
const { points, radii, round } = shape;
const last = points.length - 1;
let best = BIG;
for (const index of segments) {
const d = cappedSegment(p, points[index], points[index + 1], radii[index], radii[index + 1]);
if (d < best) best = d;
for (const [joint, flag] of [[0, round[0]], [last, round[1]]]) {
if (!flag || (joint !== index && joint !== index + 1)) continue;
const q = points[joint];
const e = Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]) - radii[joint];
if (e < best) best = e;
}
}
return best;
}
function bodyDepth(shape, c, V, eps) {
const { F, poly } = shape;
if (!shape._f || shape._f.view.some((value, index) => value !== V[index])) {
const s = poly.map(([value]) => value);
shape._f = { view: [...V], aV: dot3(F.a, V), uV: dot3(F.u, V), vV: dot3(F.v, V), s0: Math.min(...s), s1: Math.max(...s), rm: Math.max(...poly.map(([, r]) => r)) };
}
const { aV, uV, vV, s0, s1, rm } = shape._f;
const q = [c[0] - F.o[0], c[1] - F.o[1], c[2] - F.o[2]];
const sc = dot3(q, F.a);
const xc = dot3(q, F.u);
const yc = dot3(q, F.v);
let lo = -BIG;
let hi = BIG;
if (Math.abs(aV) > 1e-9) {
const a = (s0 - sc) / aV;
const b = (s1 - sc) / aV;
lo = Math.min(a, b);
hi = Math.max(a, b);
} else if (sc < s0 || sc > s1) return null;
const qa = uV * uV + vV * vV;
if (qa > 1e-12) {
const qb = 2 * (xc * uV + yc * vV);
const qc = xc * xc + yc * yc - rm * rm;
const disc = qb * qb - 4 * qa * qc;
if (disc < 0) return null;
const root = Math.sqrt(disc);
lo = Math.max(lo, (-qb - root) / (2 * qa));
hi = Math.min(hi, (-qb + root) / (2 * qa));
} else if (xc * xc + yc * yc > rm * rm) return null;
if (lo > hi) return null;
let t = hi + eps;
for (let step = 0; step < 160 && t >= lo - eps; step++) {
let d = polyDistance(poly, sc + t * aV, Math.hypot(xc + t * uV, yc + t * vV));
if (shape.cut) d = Math.max(d, -cutDistance(shape, [c[0] + V[0] * t, c[1] + V[1] * t, c[2] + V[2] * t]));
if (d < eps) return t;
t -= Math.max(d, eps * 0.5);
}
return null;
}
function rayDepth(shape, c, V, eps, segments) {
if (shape.kind === "body") return bodyDepth(shape, c, V, eps);
const span = spanOf(c, V, boundsOf(shape).min, boundsOf(shape).max);
if (!span) return null;
let t = span[1] + eps;
for (let step = 0; step < 160 && t >= span[0] - eps; step++) {
const p = [c[0] + V[0] * t, c[1] + V[1] * t, c[2] + V[2] * t];
const d = segments ? tubeDistance(shape, p, segments) : sdf(shape, p);
if (d < eps) return t;
t -= Math.max(d, eps * 0.5);
}
return null;
}
function flatDistance(x, y, a, b) {
const dx = b[0] - a[0];
const dy = b[1] - a[1];
const span = dx * dx + dy * dy;
const t = span > 0 ? Math.max(0, Math.min(1, ((x - a[0]) * dx + (y - a[1]) * dy) / span)) : 0;
return Math.hypot(x - a[0] - dx * t, y - a[1] - dy * t);
}
export const shareOf = (item, state) => (typeof state === "number" ? state : state.shares[item.ride ?? item.piece] ?? 0);
export const offsetOf = (item, state) => mul3(item.move ?? [0, 0, 0], shareOf(item, state));
export const labelOf = (state) => (typeof state === "number" ? `share ${Math.round(state * 1000) / 1000}` : state.label);
export function springStates(order, { stagger = 0.035, stiffness = 64, damping = 14.2, substeps = 4, fps = 60, settle = 1e-3, stride = 1, reversals = [] } = {}) {
const out = [];
const scripts = [[true], [false], ...reversals.flatMap((at) => [[true, at], [false, at]])];
for (const [on, back] of scripts) {
const springs = Object.fromEntries(order.map((id) => [id, { x: on ? 0 : 1, v: 0, target: on ? 0 : 1, pending: null }]));
const toggle = (value, clock) => {
const goal = value ? 1 : 0;
let index = 0;
for (const id of value ? order : [...order].reverse()) {
if (springs[id].target === goal) springs[id].pending = null;
else springs[id].pending = { value: goal, at: clock + index++ * stagger };
}
};
const name = back === undefined ? (on ? "apart" : "together") : `${on ? "apart" : "together"}, back at ${back.toFixed(2)} s,`;
const dt = 1 / fps;
let clock = 0;
let goal = on ? 1 : 0;
toggle(on, 0);
for (let frame = 0; frame < 100000; frame++) {
if (back !== undefined && clock < back && clock + dt >= back) toggle(!on, back), (goal = on ? 0 : 1);
clock += dt;
for (const spring of Object.values(springs)) {
if (spring.pending && clock >= spring.pending.at) (spring.target = spring.pending.value), (spring.pending = null);
for (let index = 0; index < substeps; index++) {
const h = dt / substeps;
spring.v += ((spring.target - spring.x) * stiffness - spring.v * damping) * h;
spring.x += spring.v * h;
}
}
const settled = (back === undefined || clock >= back) && Object.values(springs).every((spring) => !spring.pending && Math.abs(spring.x - goal) < settle && Math.abs(spring.v) < settle);
if (settled) break;
if ((frame + 1) % stride === 0) out.push({ label: `${name} ${clock.toFixed(3)} s`, shares: Object.fromEntries(Object.entries(springs).map(([id, spring]) => [id, spring.x])) });
}
}
return out;
}
export const uniformStates = (count = 10) => Array.from({ length: count + 1 }, (_, index) => index / count);
export const reversalsOf = (order, stagger = 0.035, margin = 0.008) => order.flatMap((_, index) => [index * stagger - margin, index * stagger + margin]).filter((at) => at > 0);
export function prefixStates(order, { shares = [0.25, 0.5, 0.75, 1] } = {}) {
const out = [];
for (let count = 1; count < order.length; count++)
for (const s of shares)
out.push({ label: `first ${count - 1} out, ${order[count - 1]} at ${s}`, shares: Object.fromEntries(order.map((id, index) => [id, index < count - 1 ? 1 : index === count - 1 ? s : 0])) });
return out;
}
function rasterOf(item, cam, step, offset) {
const shapes = item.shapes.map((shape) => moved(shape, offset));
const flat = (p) => [cam.origin[0] + dot3(p, cam.R) * cam.k, cam.origin[1] + dot3(p, cam.D) * cam.k];
const boxes = shapes.map((shape) => screenBox(shape, cam, [0, 0, 0]));
const guides = shapes.map((shape) => {
if (shape.kind === "tube") {
const points = shape.points.map(flat);
const widths = shape.radii.map((r) => r * cam.k);
const boxes = new Float64Array((points.length - 1) * 4);
for (let i = 0; i < points.length - 1; i++) {
const pad = Math.max(widths[i], widths[i + 1]) + step * 0.5;
boxes[i * 4] = Math.min(points[i][0], points[i + 1][0]) - pad;
boxes[i * 4 + 1] = Math.max(points[i][0], points[i + 1][0]) + pad;
boxes[i * 4 + 2] = Math.min(points[i][1], points[i + 1][1]) - pad;
boxes[i * 4 + 3] = Math.max(points[i][1], points[i + 1][1]) + pad;
}
return { points, widths, boxes };
}
if (shape.kind === "body") {
const s = shape.poly.map(([value]) => value);
return { axis: [flat(add3(shape.F.o, mul3(shape.F.a, Math.min(...s)))), flat(add3(shape.F.o, mul3(shape.F.a, Math.max(...s))))], reach: Math.max(...shape.poly.map(([, r]) => r)) * cam.k };
}
return null;
});
const x0 = Math.floor(Math.min(...boxes.map((b) => b[0])) / step);
const y0 = Math.floor(Math.min(...boxes.map((b) => b[1])) / step);
const x1 = Math.ceil(Math.max(...boxes.map((b) => b[2])) / step);
const y1 = Math.ceil(Math.max(...boxes.map((b) => b[3])) / step);
const w = x1 - x0 + 1;
const h = y1 - y0 + 1;
return { x0, y0, x1, y1, w, h, boxes, shapes, guides, depth: null };
}
function depthAt(raster, cam, step, cx, cy) {
if (!raster.depth) {
raster.depth = new Float32Array(raster.w * raster.h);
raster.done = new Uint8Array(raster.w * raster.h);
}
const cell = (cy - raster.y0) * raster.w + (cx - raster.x0);
if (raster.done[cell]) return raster.depth[cell];
const x = cx * step;
const y = cy * step;
const c = add3(mul3(cam.R, (x - cam.origin[0]) / cam.k), mul3(cam.D, (y - cam.origin[1]) / cam.k));
let best = NaN;
for (let index = 0; index < raster.shapes.length; index++) {
const shape = raster.shapes[index];
const b = raster.boxes[index];
if (x < b[0] || x > b[2] || y < b[1] || y > b[3]) continue;
const guide = raster.guides[index];
let segments = null;
if (shape.kind === "tube") {
segments = [];
const boxes = guide.boxes;
for (let i = 0; i < guide.points.length - 1; i++) {
if (x < boxes[i * 4] || x > boxes[i * 4 + 1] || y < boxes[i * 4 + 2] || y > boxes[i * 4 + 3]) continue;
if (flatDistance(x, y, guide.points[i], guide.points[i + 1]) <= Math.max(guide.widths[i], guide.widths[i + 1]) + step * 0.5) segments.push(i);
}
if (!segments.length) continue;
} else if (shape.kind === "body" && flatDistance(x, y, guide.axis[0], guide.axis[1]) > guide.reach + step) continue;
const t = rayDepth(shape, c, cam.V, 0.02, segments);
if (t !== null && !(t <= best)) best = t;
}
raster.depth[cell] = best;
raster.done[cell] = 1;
return best;
}
function regionOf(flags, gw, gh, value, step) {
const n = gw * gh;
const on = new Uint8Array(n);
let all = 0;
let inner = 0;
for (let cell = 0; cell < n; cell++) if (flags[cell] === value) (on[cell] = 1), all++;
if (!all) return { all, inner, area: 0 };
const grow = new Uint8Array(n);
for (let y = 0; y < gh; y++)
for (let x = 0; x < gw; x++) {
const cell = y * gw + x;
if (on[cell] && x > 0 && x < gw - 1 && y > 0 && y < gh - 1 && on[cell - 1] && on[cell + 1] && on[cell - gw] && on[cell + gw]) inner++;
if (on[cell] || (x > 0 && on[cell - 1]) || (x < gw - 1 && on[cell + 1]) || (y > 0 && on[cell - gw]) || (y < gh - 1 && on[cell + gw])) grow[cell] = 1;
}
const shut = new Uint8Array(n);
for (let y = 0; y < gh; y++)
for (let x = 0; x < gw; x++) {
const cell = y * gw + x;
shut[cell] = on[cell] || (grow[cell] && (x === 0 || grow[cell - 1]) && (x === gw - 1 || grow[cell + 1]) && (y === 0 || grow[cell - gw]) && (y === gh - 1 || grow[cell + gw])) ? 1 : 0;
}
const core = new Uint8Array(n);
for (let y = 1; y < gh - 1; y++)
for (let x = 1; x < gw - 1; x++) {
const cell = y * gw + x;
core[cell] = shut[cell] && shut[cell - 1] && shut[cell + 1] && shut[cell - gw] && shut[cell + gw] ? 1 : 0;
}
const seen = new Uint8Array(n);
const stack = new Int32Array(n);
let largest = 0;
for (let start = 0; start < n; start++) {
if (!core[start] || seen[start]) continue;
let top = 0;
let size = 0;
stack[top++] = start;
seen[start] = 1;
while (top) {
const cell = stack[--top];
size++;
const x = cell % gw;
const y = (cell - x) / gw;
const visit = (next) => {
if (core[next] && !seen[next]) (seen[next] = 1), (stack[top++] = next);
};
if (x > 0) visit(cell - 1);
if (x < gw - 1) visit(cell + 1);
if (y > 0) visit(cell - gw);
if (y < gh - 1) visit(cell + gw);
}
if (size > largest) largest = size;
}
return { all, inner, area: largest * step * step };
}
function measure(ra, rb, dx, dy, dz, cam, step, tolerance, least) {
if (ra.x1 < rb.x0 + dx || rb.x1 + dx < ra.x0 || ra.y1 < rb.y0 + dy || rb.y1 + dy < ra.y0) return null;
const ix0 = Math.max(ra.x0, rb.x0 + dx);
const ix1 = Math.min(ra.x1, rb.x1 + dx);
const iy0 = Math.max(ra.y0, rb.y0 + dy);
const iy1 = Math.min(ra.y1, rb.y1 + dy);
const gw = ix1 - ix0 + 1;
const gh = iy1 - iy0 + 1;
const flags = new Int8Array(gw * gh);
const worst = [0, 0];
const at = [null, null];
let any = false;
for (let y = iy0; y <= iy1; y++) {
for (let x = ix0; x <= ix1; x++) {
const ta = depthAt(ra, cam, step, x, y);
if (Number.isNaN(ta)) continue;
const tb = depthAt(rb, cam, step, x - dx, y - dy) + dz;
if (Number.isNaN(tb)) continue;
const cell = (y - iy0) * gw + (x - ix0);
if (ta > tb + tolerance) {
flags[cell] = 1;
any = true;
if (ta - tb > worst[0]) (worst[0] = ta - tb), (at[0] = [x * step, y * step]);
} else if (tb > ta + tolerance) {
flags[cell] = -1;
any = true;
if (tb - ta > worst[1]) (worst[1] = tb - ta), (at[1] = [x * step, y * step]);
}
}
}
if (!any) return null;
const front = [regionOf(flags, gw, gh, 1, step), regionOf(flags, gw, gh, -1, step)];
if (front[0].area < least && front[1].area < least) return null;
return front.map((region, side) => ({ ...region, depth: worst[side], at: at[side] }));
}
export function overlapsOf(items, P, { step = 0.25, tolerance = 0.3, least = 0.25, states = [0], skip = () => false } = {}) {
const cam = cameraBasis(P);
const live = items.map((item, index) => ({ item, index })).filter(({ item }) => item.shapes && item.shapes.length);
const homes = live.map(() => null);
let uid = 0;
const stamp = (raster) => Object.assign(raster, { uid: uid++ });
const home = (index) => homes[index] ?? (homes[index] = stamp(rasterOf(live[index].item, cam, step, [0, 0, 0])));
const sliding = live.map(({ item }) => item.shapes.some((shape) => shape.slide));
const slid = new Map();
const rasterAt = (index, offset) => {
if (!sliding[index]) return home(index);
const id = `${index}|${offset.map((v) => v.toFixed(2)).join(",")}`;
if (!slid.has(id)) slid.set(id, stamp(rasterOf(live[index].item, cam, step, offset)));
return slid.get(id);
};
const shiftOf = (offset) => ({ gx: Math.round((dot3(offset, cam.R) * cam.k) / step), gy: Math.round((dot3(offset, cam.D) * cam.k) / step), dz: dot3(offset, cam.V) });
const memo = new Map();
const pairs = [];
for (const state of states) {
const offsets = live.map(({ item }) => offsetOf(item, state));
const shifts = live.map((_, index) => (sliding[index] ? { gx: 0, gy: 0, dz: 0 } : shiftOf(offsets[index])));
for (let a = 0; a < live.length; a++) {
const ra = rasterAt(a, offsets[a]);
const sa = shifts[a];
for (let b = a + 1; b < live.length; b++) {
const rb = rasterAt(b, offsets[b]);
const sb = shifts[b];
if (ra.x1 + sa.gx < rb.x0 + sb.gx || rb.x1 + sb.gx < ra.x0 + sa.gx || ra.y1 + sa.gy < rb.y0 + sb.gy || rb.y1 + sb.gy < ra.y0 + sa.gy) continue;
if (skip(live[a].item, live[b].item)) continue;
const dx = sb.gx - sa.gx;
const dy = sb.gy - sa.gy;
const dz = sb.dz - sa.dz;
const id = `${ra.uid}|${rb.uid}|${dx},${dy},${dz.toFixed(3)}`;
let hit = memo.get(id);
if (hit === undefined) {
hit = measure(ra, rb, dx, dy, dz, cam, step, tolerance, least);
memo.set(id, hit);
}
if (!hit) continue;
pairs.push({ state, a: live[a].index, b: live[b].index, front: hit.map((side) => ({ ...side, at: side.at && [side.at[0] + sa.gx * step, side.at[1] + sa.gy * step] })) });
}
}
}
return { pairs, least, states, step, V: cam.V };
}
const liftOf = (item, V) => dot3(item.move ?? [0, 0, 0], V);
export const keyAt = (item, state, V) => item.key + liftOf(item, V) * shareOf(item, state);
export function orderKeys(items, overlaps, { gap = 0.02, rounds = 0 } = {}) {
const { pairs, least, V } = overlaps;
const start = items.map((item) => item.key);
const strongest = new Map();
const cycles = [];
for (const pair of pairs) {
const aFront = pair.front[0].area >= least;
const bFront = pair.front[1].area >= least;
if (aFront && bFront) {
cycles.push(pair);
continue;
}
const [front, back] = aFront ? [pair.a, pair.b] : [pair.b, pair.a];
const weight = pair.front[aFront ? 0 : 1].area;
const need = gap + shareOf(items[back], pair.state) * liftOf(items[back], V) - shareOf(items[front], pair.state) * liftOf(items[front], V);
const id = `${front}|${back}`;
const prior = strongest.get(id);
if (!prior) strongest.set(id, { front, back, weight, pair, need });
else {
prior.weight = Math.max(prior.weight, weight);
if (need > prior.need) (prior.need = need), (prior.pair = pair);
}
}
const rules = [...strongest.values()];
const limit = rounds || items.length + 1;
const dropped = [];
let keys = start.slice();
let active = rules.slice();
for (let attempt = 0; attempt < 400; attempt++) {
keys = start.slice();
const by = new Array(items.length).fill(null);
let changed = true;
let round = 0;
let last = -1;
for (; changed && round < limit; round++) {
changed = false;
for (const rule of active) {
if (keys[rule.front] - keys[rule.back] >= rule.need - 1e-9) continue;
keys[rule.front] = keys[rule.back] + rule.need;
by[rule.front] = rule;
last = rule.front;
changed = true;
}
}
if (!changed) break;
const seen = new Map();
let node = last;
let step = 0;
while (node !== -1 && by[node] && !seen.has(node) && step < items.length * 2) {
seen.set(node, step++);
node = by[node].back;
}
const loop = [];
if (node !== -1 && seen.has(node)) {
let walk = node;
do {
loop.push(by[walk]);
walk = by[walk].back;
} while (walk !== node && loop.length <= items.length);
}
const candidates = loop.length ? loop : active.filter((rule) => keys[rule.front] - keys[rule.back] < rule.need - 1e-9);
if (!candidates.length) break;
const victim = candidates.reduce((low, rule) => (rule.weight < low.weight ? rule : low));
dropped.push(victim);
active = active.filter((rule) => rule !== victim);
}
return { keys, rules: rules.length, cycles, dropped };
}
export function depthOrder(items, P, options = {}) {
const overlaps = options.overlaps ?? overlapsOf(items, P, options);
const { pairs, least, states, V } = overlaps;
const allow = options.allow ?? [];
const dropped = new Set((options.solved?.dropped ?? []).map((rule) => `${rule.front}|${rule.back}`));
const missing = items.filter((item) => !item.shapes || !item.shapes.length).map((item) => item.name);
const ranks = new Map();
for (const state of states) {
const order = items.map((item, index) => ({ index, key: keyAt(item, state, V) })).sort((x, y) => x.key - y.key || x.index - y.index);
const rank = new Int32Array(items.length);
order.forEach(({ index }, position) => (rank[index] = position));
ranks.set(state, rank);
}
const rest = options.rest ?? states.filter((state) => state === 0 || state === 1);
const problems = [];
const passing = [];
for (const pair of pairs) {
const rank = ranks.get(pair.state);
const aFirst = rank[pair.a] < rank[pair.b];
const wrong = pair.front[aFirst ? 0 : 1];
const right = pair.front[aFirst ? 1 : 0];
if (wrong.area < least) continue;
const front = items[aFirst ? pair.a : pair.b];
const back = items[aFirst ? pair.b : pair.a];
const excused = allow.find(([x, y]) => (matches([x], front.name) && matches([y], back.name)) || (matches([y], front.name) && matches([x], back.name)));
const entry = {
state: pair.state,
label: labelOf(pair.state),
front: front.name,
back: back.name,
frontKey: keyAt(front, pair.state, V),
backKey: keyAt(back, pair.state, V),
cells: wrong.all,
area: wrong.area,
against: right.area,
cycle: right.area >= least,
depth: wrong.depth,
at: wrong.at,
};
const front_ = aFirst ? pair.a : pair.b;
const back_ = aFirst ? pair.b : pair.a;
entry.unorderable = !rest.includes(pair.state) && dropped.has(`${front_}|${back_}`);
const replayed = typeof pair.state !== "number";
(!excused && (rest.includes(pair.state) || replayed || (!entry.cycle && !entry.unorderable)) ? problems : passing).push(entry);
}
return { problems, passing, missing };
}
function samplesOf(shape, spacing) {
const dense = resample(shape.points, spacing);
const total = pathLength(shape.points) || 1;
const lengths = [0];
for (let index = 1; index < shape.points.length; index++) lengths.push(lengths[index - 1] + len3(sub3(shape.points[index], shape.points[index - 1])));
const radiusAt = (at) => {
let index = 1;
while (index < lengths.length - 1 && lengths[index] < at) index++;
const span = lengths[index] - lengths[index - 1] || 1;
const t = Math.max(0, Math.min(1, (at - lengths[index - 1]) / span));
return shape.radii[index - 1] + (shape.radii[index] - shape.radii[index - 1]) * t;
};
const step = total / Math.max(1, dense.length - 1);
return dense.map((p, index) => {
const t = unit3(sub3(dense[Math.min(dense.length - 1, index + 1)], dense[Math.max(0, index - 1)]));
return { p, t, along: index * step, edge: Math.min(index * step, total - index * step), r: radiusAt(index * step) };
});
}
const overlaps = (a, b, pad) => a.min.every((v, i) => v - pad <= b.max[i] && b.min[i] - pad <= a.max[i]);
function centreline(shape, p) {
let best = { d: BIG, r: 0 };
for (let index = 0; index < shape.points.length - 1; index++) {
const { d, t } = segmentPoint(p, shape.points[index], shape.points[index + 1]);
if (d < best.d) best = { d, r: shape.radii[index] + (shape.radii[index + 1] - shape.radii[index]) * t };
}
return best;
}
const matches = (list, name) =>
(list ?? []).some((entry) => {
if (typeof entry === "function") return entry(name);
if (entry.endsWith("*")) return name.startsWith(entry.slice(0, -1));
return name === entry || name.startsWith(entry + ".") || name.startsWith(entry + ":") || name.startsWith(entry + "#");
});
const sameOffset = (a, b) => Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) + Math.abs(a[2] - b[2]) < 1e-6;
const placed = (shape, state) => (state === undefined || !shape.move ? shape : moved(shape, offsetOf(shape, state)));
const offsetAt = (shape, state) => (state === undefined || !shape.move ? [0, 0, 0] : offsetOf(shape, state));
function tipDistance(other, p) {
if (other.kind === "tube") {
const { d, r } = centreline(other, p);
return d - r;
}
return sdf(other, p);
}
function rimOf(tube, index) {
const tip = tube.tips[index];
const axis = tube.tipAxes ? tube.tipAxes[index] : unit3(index ? sub3(tube.points[tube.points.length - 1], tube.points[tube.points.length - 2]) : sub3(tube.points[1], tube.points[0]));
const radius = tube.tipRims ? tube.tipRims[index] : tube.radii[index ? tube.radii.length - 1 : 0];
const helper = Math.abs(axis[2]) > 0.9 ? [1, 0, 0] : [0, 0, 1];
const u = unit3([helper[1] * axis[2] - helper[2] * axis[1], helper[2] * axis[0] - helper[0] * axis[2], helper[0] * axis[1] - helper[1] * axis[0]]);
const v = [axis[1] * u[2] - axis[2] * u[1], axis[2] * u[0] - axis[0] * u[2], axis[0] * u[1] - axis[1] * u[0]];
return Array.from({ length: 12 }, (_, k) => add3(tip, add3(mul3(u, radius * Math.cos((k * Math.PI) / 6)), mul3(v, radius * Math.sin((k * Math.PI) / 6)))));
}
export function mountsOf(tubes, solids, { tolerance = 0.15 } = {}) {
const byName = new Map(tubes.map((tube) => [tube.name, tube]));
const out = new Map();
for (const tube of tubes) {
const found = [null, null];
(tube.tips ?? []).forEach((tip, index) => {
if (!tip) return;
const rim = rimOf(tube, index);
let best = null;
const consider = (other) => {
if (other === tube || (other.owner && other.owner === tube.owner) || other.name === tube.owner || other.anchor === false) return;
const { min, max } = boundsOf(other);
if (!overlaps({ min: tip, max: tip }, { min, max }, 3 + (tube.tipRims ? tube.tipRims[index] : 0))) return;
const ds = rim.map((p) => tipDistance(other, p));
const score = (Math.abs(tipDistance(other, tip)) + ds.reduce((sum, d) => sum + Math.abs(d), 0) / ds.length) / 2;
if (!best || score < best.score) best = { shape: other, score, d: tipDistance(other, tip), high: Math.max(...ds), low: Math.min(...ds) };
};
solids.forEach(consider);
tubes.forEach(consider);
if (best && byName.get(best.shape.owner) && best.shape.kind !== "tube") best.host = byName.get(best.shape.owner);
found[index] = best && { ...best, tip, landed: best.high <= tolerance && best.low >= -tolerance };
});
out.set(tube, found);
}
return out;
}
function ringAround(sample, r) {
const axis = sample.t;
const helper = Math.abs(axis[2]) > 0.9 ? [1, 0, 0] : [0, 0, 1];
const u = unit3([helper[1] * axis[2] - helper[2] * axis[1], helper[2] * axis[0] - helper[0] * axis[2], helper[0] * axis[1] - helper[1] * axis[0]]);
const v = [axis[1] * u[2] - axis[2] * u[1], axis[2] * u[0] - axis[0] * u[2], axis[0] * u[1] - axis[1] * u[0]];
return Array.from({ length: 12 }, (_, k) => add3(sample.p, add3(mul3(u, r * Math.cos((k * Math.PI) / 6)), mul3(v, r * Math.sin((k * Math.PI) / 6)))));
}
export function clearances(tubes, solids, { ratio = 0.5, least = 0.2, spacing = 0.5, touching = -0.05, through = -0.1, state, only, mounts = mountsOf(tubes, solids) } = {}) {
const gapOf = (r) => Math.max(least, ratio * r);
const problems = new Map();
const note = (tube, other, kind, clearance, need, sample) => {
if (only && kind !== only) return;
const id = `${tube.name}|${other.name}`;
const prior = problems.get(id);
if (prior && prior.clearance <= clearance) {
prior.from = Math.min(prior.from, sample.along);
prior.to = Math.max(prior.to, sample.along);
return;
}
problems.set(id, { tube: tube.name, other: other.name, kind, clearance, need, at: sample.p, from: prior ? Math.min(prior.from, sample.along) : sample.along, to: prior ? Math.max(prior.to, sample.along) : sample.along, length: pathLength(tube.points), state: state === undefined ? "" : labelOf(state) });
};
const poseOf = new Map([...tubes, ...solids].map((shape) => [shape, placed(shape, state)]));
const offsets = new Map([...tubes, ...solids].map((shape) => [shape, offsetAt(shape, state)]));
const widest = new Map(tubes.map((tube) => [tube, poseOf.get(tube).radii.reduce((r, next) => Math.max(r, next), 0)]));
const together = (a, b) => len3(sub3(offsets.get(a), offsets.get(b))) < 0.05;
const runsBy = new Map();
for (const tube of tubes) runsBy.set(tube.owner, [...(runsBy.get(tube.owner) ?? []), tube]);
const tipsOf = (owner) => (runsBy.get(owner) ?? []).flatMap((run) => (mounts.get(run) ?? []).filter(Boolean).map((mount) => ({ run, mount })));
const seatedOn = (shape, owner) => shape && shape.cut && [shape.cut].flat().some((cut) => cut.owner === owner);
const zone = (r) => r + gapOf(r) + 1;
const ownerOf = (other) => other.owner ?? other.name;
const related = (tube, other, sample) => {
if (seatedOn(other, tube.owner)) return true;
const tips = tipsOf(tube.owner);
const near = (entry) => len3(sub3(sample.p, add3(entry.mount.tip, offsets.get(entry.run)))) <= zone(sample.r) + (entry.run.tipRims ? Math.max(...entry.run.tipRims) : 0);
for (const entry of tips) {
if (!near(entry) || !together(tube, entry.mount.shape)) continue;
const mount = entry.mount.shape;
if (mount === other || (entry.mount.host && (entry.mount.host === other || other.owner === entry.mount.host.owner))) return true;
if (tipsOf(ownerOf(other)).some((theirs) => theirs.mount.shape === mount)) return true;
}
for (const entry of tipsOf(ownerOf(other))) {
const mount = entry.mount.shape;
const lands = mount.owner === tube.owner || seatedOn(mount, tube.owner);
if (!lands || !together(entry.run, tube)) continue;
if (len3(sub3(sample.p, add3(entry.mount.tip, offsets.get(entry.run)))) <= zone(sample.r) + (entry.run.tipRims ? Math.max(...entry.run.tipRims) : 0) + sample.r) return true;
}
return false;
};
const nearTip = (tube, sample) => {
const at = (tube.offset ?? 0) + sample.along;
const total = tube.total ?? pathLength(tube.points);
const tips = mounts.get(tube) ?? [null, null];
return (tips[0] && at <= zone(sample.r)) || (tips[1] && total - at <= zone(sample.r));
};
const clearanceTo = (other, sample) => {
if (sample.edge >= sample.r) return sdf(other, sample.p) - sample.r;
return Math.min(...ringAround(sample, sample.r).map((q) => sdf(other, q)));
};
for (const tube of tubes) {
const posed = poseOf.get(tube);
const samples = samplesOf(posed, spacing);
const tb = boundsOf(posed);
for (const shape of solids) {
if (shape.owner && shape.owner === tube.owner) continue;
if (matches(tube.touch, shape.name) || matches(shape.touch, tube.name)) continue;
const other = poseOf.get(shape);
const ob = boundsOf(other);
if (!overlaps(tb, ob, Math.max(4, gapOf(widest.get(tube))))) continue;
for (const sample of samples) {
if (!overlaps({ min: sample.p, max: sample.p }, ob, sample.r + Math.max(3, gapOf(sample.r)))) continue;
const gap = gapOf(sample.r);
const clearance = clearanceTo(other, sample);
if (clearance >= gap) continue;
if (related(tube, shape, sample)) continue;
if (nearTip(tube, sample) && clearance >= through) continue;
note(tube, shape, clearance < 0 ? "through" : "close", clearance, gap, sample);
}
}
}
for (let a = 0; a < tubes.length; a++) {
const ta = poseOf.get(tubes[a]);
const samples = samplesOf(ta, spacing);
for (let b = 0; b < tubes.length; b++) {
if (a === b) continue;
const tb = poseOf.get(tubes[b]);
if (tubes[a].owner && tubes[a].owner === tubes[b].owner && tubes[a].joined) continue;
if (matches(tubes[a].touch, tubes[b].name) || matches(tubes[b].touch, tubes[a].name)) continue;
const bundled = tubes[a].bundle && tubes[a].bundle === tubes[b].bundle;
const widestB = widest.get(tubes[b]);
const envelope = bundled ? 3 : Math.max(3, gapOf(Math.min(widest.get(tubes[a]), widestB)));
if (!overlaps(boundsOf(ta), boundsOf(tb), envelope)) continue;
for (const sample of samples) {
const envelope = bundled ? 3 : Math.max(3, gapOf(Math.min(sample.r, widestB)));
if (!overlaps({ min: sample.p, max: sample.p }, boundsOf(tb), sample.r + envelope)) continue;
const clearance = sample.edge >= sample.r ? sdf(tb, sample.p) - sample.r : Math.min(...ringAround(sample, sample.r).map((q) => sdf(tb, q)));
const r = centreline(tb, sample.p).r;
const gap = bundled ? touching : gapOf(Math.min(sample.r, r));
if (clearance >= gap) continue;
if (related(tubes[a], tubes[b], sample)) continue;
if (nearTip(tubes[a], sample) && clearance >= through) continue;
if (a > b && problems.has(`${tubes[b].name}|${tubes[a].name}`)) continue;
note(tubes[a], tubes[b], clearance < 0 ? "through" : "close", clearance, gap, sample);
}
}
}
const seen = new Set();
return [...problems.values()]
.sort((x, y) => x.clearance - y.clearance)
.filter((c) => {
const id = [c.tube, c.other].sort().join("|");
if (seen.has(id)) return false;
seen.add(id);
return true;
});
}
export function terminals(tubes, solids, { tolerance = 0.15, mounts = mountsOf(tubes, solids, { tolerance }) } = {}) {
const out = [];
for (const tube of tubes) {
(mounts.get(tube) ?? []).forEach((mount, index) => {
if (!tube.tips || !tube.tips[index] || (mount && mount.landed)) return;
out.push({ tube: tube.name, end: index ? "end" : "start", at: tube.tips[index], d: mount ? mount.d : Infinity, high: mount ? mount.high : Infinity, low: mount ? mount.low : -Infinity, nearest: mount ? mount.shape.name : "nothing" });
});
}
return out;
}
export function looseEnds(tubes, solids, { state = 1, tolerance = 0.15 } = {}) {
const out = [];
for (const tube of tubes) {
const offset = offsetAt(tube, state);
(tube.tips ?? []).forEach((tip, index) => {
if (!tip) return;
const hit = solids.some((shape) => {
if ((shape.owner && shape.owner === tube.owner) || shape.name === tube.owner) return false;
if (!sameOffset(offsetAt(shape, state), offset)) return false;
const { min, max } = boundsOf(shape);
return overlaps({ min: tip, max: tip }, { min, max }, 1) && sdf(shape, tip) <= tolerance;
});
if (!hit) out.push({ tube: tube.name, end: index ? "end" : "start", at: add3(tip, offset), state: labelOf(state), free: Boolean(tube.free && tube.free[index]) });
});
}
return out;
}
function surfaceOf(shape, spacing = 0.6) {
const points = [];
if (shape.kind === "body") {
const { F, poly } = shape;
const u = F.u ?? unit3(Math.abs(F.a[2]) > 0.9 ? [1, 0, 0] : [-F.a[1], F.a[0], 0]);
const v = F.v ?? [F.a[1] * u[2] - F.a[2] * u[1], F.a[2] * u[0] - F.a[0] * u[2], F.a[0] * u[1] - F.a[1] * u[0]];
for (let i = 0; i < poly.length - 1; i++) {
const [s0, r0] = poly[i];
const [s1, r1] = poly[i + 1];
const steps = Math.max(1, Math.ceil(Math.hypot(s1 - s0, r1 - r0) / spacing));
for (let j = 0; j <= steps; j++) {
const s = s0 + ((s1 - s0) * j) / steps;
const r = r0 + ((r1 - r0) * j) / steps;
const around = Math.max(1, Math.min(160, Math.ceil((2 * Math.PI * r) / spacing)));
for (let k = 0; k < around; k++) {
const t = (k / around) * 2 * Math.PI;
points.push(add3(add3(F.o, mul3(F.a, s)), add3(mul3(u, r * Math.cos(t)), mul3(v, r * Math.sin(t)))));
}
}
}
} else if (shape.kind === "box") {
for (let axis = 0; axis < 3; axis++)
for (const sign of [-1, 1]) {
const o1 = (axis + 1) % 3;
const o2 = (axis + 2) % 3;
const n1 = Math.max(1, Math.ceil((2 * shape.half[o1]) / spacing));
const n2 = Math.max(1, Math.ceil((2 * shape.half[o2]) / spacing));
for (let i = 0; i <= n1; i++)
for (let j = 0; j <= n2; j++) {
const c = [0, 0, 0];
c[axis] = sign * shape.half[axis];
c[o1] = -shape.half[o1] + (2 * shape.half[o1] * i) / n1;
c[o2] = -shape.half[o2] + (2 * shape.half[o2] * j) / n2;
points.push(add3(shape.o, add3(add3(mul3(shape.axes[0], c[0]), mul3(shape.axes[1], c[1])), mul3(shape.axes[2], c[2]))));
}
}
} else if (shape.kind === "prism") {
const { F, poly, s0, s1 } = shape;
const at = (s, x, y) => add3(add3(F.o, mul3(F.a, s)), add3(mul3(F.u, x), mul3(F.v, y)));
const rows = Math.max(1, Math.ceil((s1 - s0) / spacing));
for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
const [x0, y0] = poly[j];
const [x1, y1] = poly[i];
const steps = Math.max(1, Math.ceil(Math.hypot(x1 - x0, y1 - y0) / spacing));
for (let k = 0; k < steps; k++)
for (let row = 0; row <= rows; row++) points.push(at(s0 + ((s1 - s0) * row) / rows, x0 + ((x1 - x0) * k) / steps, y0 + ((y1 - y0) * k) / steps));
}
const xs = poly.map(([x]) => x);
const ys = poly.map(([, y]) => y);
for (let x = Math.min(...xs); x <= Math.max(...xs); x += spacing)
for (let y = Math.min(...ys); y <= Math.max(...ys); y += spacing) if (polygonDistance(poly, x, y) < 0) points.push(at(s0, x, y), at(s1, x, y));
} else if (shape.kind === "ball") {
const count = Math.max(24, Math.min(600, Math.ceil((4 * Math.PI * shape.r * shape.r) / (spacing * spacing))));
for (let i = 0; i < count; i++) {
const z = 1 - (2 * (i + 0.5)) / count;
const ring = Math.sqrt(1 - z * z);
const t = i * 2.399963;
points.push(add3(shape.o, mul3([ring * Math.cos(t), ring * Math.sin(t), z], shape.r)));
}
if (shape.flats) {
const kept = points.filter((p) => shape.flats.every(([nx, ny, nz, cut]) => nx * (p[0] - shape.o[0]) + ny * (p[1] - shape.o[1]) + nz * (p[2] - shape.o[2]) <= cut + 1e-9));
points.length = 0;
points.push(...kept);
for (const [nx, ny, nz, cut] of shape.flats) {
const n = [nx, ny, nz];
const helper = Math.abs(nz) > 0.9 ? [1, 0, 0] : [0, 0, 1];
const u = unit3([helper[1] * nz - helper[2] * ny, helper[2] * nx - helper[0] * nz, helper[0] * ny - helper[1] * nx]);
const v = [ny * u[2] - nz * u[1], nz * u[0] - nx * u[2], nx * u[1] - ny * u[0]];
const rho = Math.sqrt(Math.max(0, shape.r * shape.r - cut * cut));
const centre = add3(shape.o, mul3(n, cut));
for (let x = -rho; x <= rho; x += spacing)
for (let y = -rho; y <= rho; y += spacing) {
if (x * x + y * y > rho * rho) continue;
const p = add3(centre, add3(mul3(u, x), mul3(v, y)));
if (shape.flats.every(([mx, my, mz, other]) => mx * (p[0] - shape.o[0]) + my * (p[1] - shape.o[1]) + mz * (p[2] - shape.o[2]) <= other + 1e-6)) points.push(p);
}
}
}
} else {
for (const sample of samplesOf(shape, spacing)) points.push(...ringAround(sample, sample.r));
}
return shape.cut ? points.filter((p) => cutDistance(shape, p) >= -1e-3) : points;
}
const seatedOn = (shape, host) => Boolean(shape.seated && shape.cut && [shape.cut].flat().some((cut) => cut === host || (cut.name && cut.name === host.name)));
export const grounded = (shape) => Boolean(shape.ground) || (shape.name ?? "").startsWith("stand.");
export function supports(solids, tubes, { ground = grounded, touch = 0.15, sunk = 0.5 } = {}) {
const nodes = [...solids, ...tubes.filter((tube) => !tube.limp)];
const surfaces = nodes.map((shape) => surfaceOf(shape));
const links = nodes.map(() => []);
const deep = [];
for (let a = 0; a < nodes.length; a++) {
const ba = boundsOf(nodes[a]);
for (let b = a + 1; b < nodes.length; b++) {
const bb = boundsOf(nodes[b]);
if (!overlaps(ba, bb, touch + 0.05)) continue;
const same = (nodes[a].owner && (nodes[a].owner === nodes[b].owner || nodes[a].owner === nodes[b].name)) || (nodes[b].owner && nodes[b].owner === nodes[a].name);
let gap = BIG;
for (const p of surfaces[a]) gap = Math.min(gap, sdf(nodes[b], p));
for (const p of surfaces[b]) gap = Math.min(gap, sdf(nodes[a], p));
if (gap <= touch) links[a].push(b), links[b].push(a);
const solidPair = nodes[a].kind !== "tube" && nodes[b].kind !== "tube";
if (solidPair && !same && gap < -sunk && !seatedOn(nodes[a], nodes[b]) && !seatedOn(nodes[b], nodes[a])) deep.push({ a: nodes[a].name, b: nodes[b].name, depth: -gap });
}
}
const held = new Uint8Array(nodes.length);
const queue = [];
nodes.forEach((shape, index) => ground(shape) && ((held[index] = 1), queue.push(index)));
while (queue.length) {
const index = queue.pop();
for (const next of links[index]) if (!held[next]) (held[next] = 1), queue.push(next);
}
const loose = nodes.filter((_, index) => !held[index] && nodes[index].kind !== "tube").map((shape) => shape.name);
const hanging = nodes.filter((_, index) => !held[index] && nodes[index].kind === "tube").map((shape) => shape.name);
return { loose, hanging, sunk: deep.sort((x, y) => y.depth - x.depth) };
}
export function folds(routes, P, { fold = 140, turn = 110, pinch = 2, items = null } = {}) {
const cam = cameraBasis(P);
const entries = items ? entriesOf(items, cam) : null;
const shown = (name, p) => !entries || frontAt(entries, cam, cam.origin[0] + dot3(p, cam.R) * cam.k, cam.origin[1] + dot3(p, cam.D) * cam.k) === name;
const flat = (p) => [dot3(p, cam.R) * cam.k, dot3(p, cam.D) * cam.k];
const angle = (a, b) => (Math.acos(Math.max(-1, Math.min(1, (a[0] * b[0] + a[1] * b[1]) / (Math.hypot(a[0], a[1]) * Math.hypot(b[0], b[1]) || 1)))) * 180) / Math.PI;
const out = [];
for (const { name, points, r } of routes) {
const step = Math.max(0.25, r * 0.5);
const dense = resample(points, step);
const screen = dense.map(flat);
const reach = Math.max(2, Math.round((4 * r) / step));
const width = r * cam.k;
let worst = null;
for (const span of [1.5, 3, 6]) {
const near = Math.max(1, Math.round((span * r) / step));
for (let i = near; i < dense.length - near; i++) {
const p0 = screen[i - near];
const p1 = screen[i];
const p2 = screen[i + near];
const a = [p1[0] - p0[0], p1[1] - p0[1]];
const b = [p2[0] - p1[0], p2[1] - p1[1]];
const c = [p2[0] - p0[0], p2[1] - p0[1]];
const la = Math.hypot(a[0], a[1]);
const lb = Math.hypot(b[0], b[1]);
if (la < width * 0.3 || lb < width * 0.3) continue;
const bend = angle(a, b);
const area = Math.abs(a[0] * b[1] - a[1] * b[0]) / 2;
const radius = area > 1e-9 ? (la * lb * Math.hypot(c[0], c[1])) / (4 * area) : Infinity;
if (bend > 90 && radius < pinch * width && (!worst || radius < worst.radius) && shown(name, dense[i])) worst = { name, kind: "pinch", flatTurn: bend, radius, width, at: dense[i], index: i };
}
}
if (worst) {
let toStart = 0;
for (let i = 1; i <= worst.index; i++) toStart += Math.hypot(screen[i][0] - screen[i - 1][0], screen[i][1] - screen[i - 1][1]);
let toEnd = 0;
for (let i = worst.index + 1; i < screen.length; i++) toEnd += Math.hypot(screen[i][0] - screen[i - 1][0], screen[i][1] - screen[i - 1][1]);
if (Math.min(toStart, toEnd) > 3 * width) out.push(worst);
}
for (let i = reach; i < dense.length - reach; i++) {
const a = [screen[i][0] - screen[i - reach][0], screen[i][1] - screen[i - reach][1]];
const b = [screen[i + reach][0] - screen[i][0], screen[i + reach][1] - screen[i][1]];
if (Math.hypot(a[0], a[1]) < 1e-6 || Math.hypot(b[0], b[1]) < 1e-6) continue;
const flatTurn = angle(a, b);
const A3 = sub3(dense[i], dense[i - reach]);
const B3 = sub3(dense[i + reach], dense[i]);
const realTurn = (Math.acos(Math.max(-1, Math.min(1, dot3(A3, B3) / (len3(A3) * len3(B3) || 1)))) * 180) / Math.PI;
if (flatTurn > fold && realTurn < turn && shown(name, dense[i])) {
out.push({ name, kind: "fold", flatTurn, realTurn, at: dense[i] });
i += 2 * reach;
}
}
}
return out;
}
export function linksOf(tubes, mounts) {
const links = new Map();
const link = (a, b) => {
if (!a || !b || a === b) return;
if (!links.has(a)) links.set(a, new Set());
if (!links.has(b)) links.set(b, new Set());
links.get(a).add(b);
links.get(b).add(a);
};
const ownerOf = (shape) => shape.owner ?? shape.name;
const seats = new Map();
for (const tube of tubes)
for (const mount of mounts.get(tube) ?? []) {
if (!mount) continue;
const host = ownerOf(mount.shape);
link(tube.owner, host);
if (!seats.has(host)) seats.set(host, []);
seats.get(host).push(tube.owner);
if (mount.shape.cut) for (const cut of [mount.shape.cut].flat()) link(tube.owner, ownerOf(cut));
}
for (const owners of seats.values()) for (const a of owners) for (const b of owners) link(a, b);
return links;
}
const entriesOf = (items, cam) => items.flatMap((item) => (item.shapes ?? []).map((shape) => ({ shape, box: screenBox(shape, cam, [0, 0, 0]).map((v, i) => v + (i < 2 ? -1 : 1)), owner: item.route ?? shape.owner ?? item.name, bundle: shape.bundle ?? null, item: item.name })));
function frontEntry(entries, cam, x, y) {
const c = add3(mul3(cam.R, (x - cam.origin[0]) / cam.k), mul3(cam.D, (y - cam.origin[1]) / cam.k));
let best = -BIG;
let who = null;
for (const entry of entries) {
const { shape, box } = entry;
if (x < box[0] || x > box[2] || y < box[1] || y > box[3]) continue;
const t = rayDepth(shape, c, cam.V, 0.02, null);
if (t !== null && t > best) (best = t), (who = entry);
}
return who;
}
function frontAt(entries, cam, x, y) {
const entry = frontEntry(entries, cam, x, y);
return entry ? entry.owner : null;
}
const belongs = (entry, name, bundle) => Boolean(entry) && (entry.owner === name || entry.item === name || (bundle && entry.bundle === bundle));
export function slenderOf(solids, { ratio = 4, least = 0.3 } = {}) {
const out = [];
const axisLine = (centre, axis, half, r, shape) => {
out.push({ name: shape.owner ?? shape.name, solid: shape.name, owners: new Set([shape.name, shape.owner].filter(Boolean)), points: [add3(centre, mul3(axis, -half)), add3(centre, mul3(axis, half))], r, move: shape.move, ride: shape.ride, piece: shape.piece, rod: true });
};
for (const shape of solids) {
if (!shape || shape.kind === "tube" || shape.kind === "ball" || shape.fitting) continue;
if (shape.kind === "body") {
const s = shape.poly.map(([value]) => value);
const s0 = Math.min(...s);
const s1 = Math.max(...s);
const r = Math.max(...shape.poly.map(([, value]) => value));
if (r >= least && s1 - s0 >= ratio * r) axisLine(add3(shape.F.o, mul3(shape.F.a, (s0 + s1) / 2)), shape.F.a, (s1 - s0) / 2, r, shape);
continue;
}
let axes;
let half;
let centre;
if (shape.kind === "prism") {
const xs = shape.poly.map(([x]) => x);
const ys = shape.poly.map(([, y]) => y);
const [x0, x1, y0, y1] = [Math.min(...xs), Math.max(...xs), Math.min(...ys), Math.max(...ys)];
axes = [shape.F.u, shape.F.v, shape.F.a];
half = [(x1 - x0) / 2, (y1 - y0) / 2, (shape.s1 - shape.s0) / 2];
centre = add3(shape.F.o, add3(add3(mul3(shape.F.u, (x0 + x1) / 2), mul3(shape.F.v, (y0 + y1) / 2)), mul3(shape.F.a, (shape.s0 + shape.s1) / 2)));
} else if (shape.kind === "box") {
axes = shape.axes;
half = shape.half;
centre = shape.o;
} else continue;
const order = [0, 1, 2].sort((a, b) => half[b] - half[a]);
const r = half[order[1]];
if (r >= least && half[order[0]] >= ratio * r) axisLine(centre, axes[order[0]], half[order[0]], r, shape);
}
return out;
}
export function crowding(routes, P, { gap = 1, bend = 30, links = new Map(), items = null, allow = [], state, clear = 2, rods = [] } = {}) {
const cam = cameraBasis(P);
const shift = (thing) => (state === undefined ? [0, 0, 0] : offsetOf(thing, state));
const entries = items ? entriesOf(items.map((item) => ({ ...item, shapes: (item.shapes ?? []).map((shape) => moved(shape, shift(item))) })), cam) : null;
const bundles = new Map(routes.map((route) => [route.name, route.bundle]));
const shown = (owner, x, y, rod) => {
if (!entries) return true;
const entry = frontEntry(entries, cam, x, y);
if (rod) return Boolean(entry) && (entry.shape.name === rod.solid || (!entry.shape.name && entry.item === rod.solid));
return belongs(entry, owner, bundles.get(owner));
};
const flat = (p) => [cam.origin[0] + dot3(p, cam.R) * cam.k, cam.origin[1] + dot3(p, cam.D) * cam.k];
const lines = [...routes, ...rods].map((route) => {
const step = Math.max(0.25, route.r * 0.5);
const offset = shift(route);
const dense = resample(route.points.map((p) => add3(p, offset)), step);
return { ...route, step, dense, screen: dense.map(flat), width: route.r * cam.k };
});
const marksOf = (line) => {
const out = [];
const reach = Math.max(2, Math.round((2 * line.r) / line.step));
const last = line.dense.length - 1;
for (let i = 0; i <= last; i++) {
if (i <= reach || i >= last - reach) {
out.push({ i, where: i <= reach ? "start" : "end" });
continue;
}
const A = sub3(line.dense[i], line.dense[i - reach]);
const B = sub3(line.dense[i + reach], line.dense[i]);
const turn = (Math.acos(Math.max(-1, Math.min(1, dot3(A, B) / (len3(A) * len3(B) || 1)))) * 180) / Math.PI;
if (turn > bend) out.push({ i, where: "bend" });
}
return out;
};
const found = new Map();
for (const a of lines) {
if (a.rod) continue;
const marks = marksOf(a);
for (const b of lines) {
if (a === b || (a.bundle && a.bundle === b.bundle) || links.get(a.name)?.has(b.name)) continue;
if (b.rod && [...b.owners].some((name) => name === a.name || links.get(a.name)?.has(name))) continue;
if (allow.some(([x, y]) => [b.name, b.solid].filter(Boolean).some((name) => (matches([x], a.name) && matches([y], name)) || (matches([y], a.name) && matches([x], name))))) continue;
for (const { i, where } of marks) {
const [x, y] = a.screen[i];
let best = { d: BIG, j: -1 };
for (let j = 0; j < b.screen.length; j++) {
const d = Math.hypot(b.screen[j][0] - x, b.screen[j][1] - y);
if (d < best.d) best = { d, j };
}
const touch = best.d - a.width - b.width;
if (touch >= gap) continue;
if (where !== "bend" && touch <= -2 * Math.min(a.width, b.width)) {
const tip = a.screen[where === "start" ? 0 : a.screen.length - 1];
let clearTip = BIG;
for (const q of b.screen) clearTip = Math.min(clearTip, Math.hypot(q[0] - tip[0], q[1] - tip[1]));
const reachB = Math.max(2, Math.round((2 * b.r) / b.step));
const j0 = Math.max(0, best.j - reachB);
const j1 = Math.min(b.dense.length - 1, best.j + reachB);
const straight = j1 - j0 >= 2 && dot3(unit3(sub3(b.dense[best.j], b.dense[j0])), unit3(sub3(b.dense[j1], b.dense[best.j]))) > Math.cos((bend * Math.PI) / 180);
if (straight && clearTip > b.width + a.width + 1) continue;
}
const [bx, by] = b.screen[best.j];
const u = [(bx - x) / (best.d || 1), (by - y) / (best.d || 1)];
const inA = Math.max(0.2, a.width - 0.35);
const inB = Math.max(0.2, b.width - 0.35);
if (!shown(a.name, x + u[0] * inA, y + u[1] * inA)) continue;
if (b.rod) {
if (!shown(b.name, bx - u[0] * inB, by - u[1] * inB, b) && !shown(b.name, bx + u[0] * inB, by + u[1] * inB, b)) continue;
} else if (!shown(b.name, bx - u[0] * inB, by - u[1] * inB)) continue;
const depth = Math.abs(dot3(sub3(a.dense[i], b.dense[best.j]), cam.V));
const need = 2 * (a.r + b.r);
const id = [a.name, b.name].sort().join("|");
const prior = found.get(id);
if (!prior || Math.abs(touch) < Math.abs(prior.gap)) found.set(id, { a: a.name, b: b.rod ? `${b.solid} (rod)` : b.name, where, gap: touch, depth, need, screen: [x, y], at: a.dense[i], state: state === undefined ? "" : labelOf(state) });
}
}
}
if (entries)
for (const fitting of entries.filter((entry) => entry.shape.fitting && entry.shape.kind === "body")) {
const { shape } = fitting;
const reach = Math.max(...shape.poly.map(([, r]) => r));
const [x, y] = flat(shape.F.o);
for (const b of lines) {
if (b.rod) continue;
if ((fitting.bundle && b.bundle === fitting.bundle) || b.name === fitting.owner || links.get(fitting.owner)?.has(b.name)) continue;
if (allow.some(([p, q]) => (matches([p], fitting.item) && matches([q], b.name)) || (matches([q], fitting.item) && matches([p], b.name)))) continue;
let best = { d: BIG, j: -1 };
for (let j = 0; j < b.screen.length; j++) {
const d = Math.hypot(b.screen[j][0] - x, b.screen[j][1] - y);
if (d < best.d) best = { d, j };
}
const touch = best.d - reach * cam.k - b.width;
if (touch >= clear) continue;
const front = frontEntry(entries, cam, x, y);
if (!(front === fitting || belongs(front, fitting.owner, fitting.bundle))) continue;
const id = [fitting.item, b.name].sort().join("|");
const prior = found.get(id);
if (!prior || Math.abs(touch) < Math.abs(prior.gap)) found.set(id, { a: fitting.item, b: b.name, where: "fitting", gap: touch, depth: Math.abs(dot3(sub3(shape.F.o, b.dense[best.j]), cam.V)), need: 0, screen: [x, y], at: shape.F.o, state: state === undefined ? "" : labelOf(state) });
}
}
return [...found.values()].sort((x, y) => Math.abs(x.gap) - Math.abs(y.gap));
}
const multiply = (m, n) => [m[0] * n[0] + m[2] * n[1], m[1] * n[0] + m[3] * n[1], m[0] * n[2] + m[2] * n[3], m[1] * n[2] + m[3] * n[3], m[0] * n[4] + m[2] * n[5] + m[4], m[1] * n[4] + m[3] * n[5] + m[5]];
function matrixOf(text) {
let m = [1, 0, 0, 1, 0, 0];
if (!text) return m;
for (const [, kind, args] of text.matchAll(/(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/g)) {
const v = (args.match(/-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/gi) ?? []).map(Number);
let n = [1, 0, 0, 1, 0, 0];
if (kind === "matrix" && v.length === 6) n = v;
else if (kind === "translate") n = [1, 0, 0, 1, v[0] ?? 0, v[1] ?? 0];
else if (kind === "scale") n = [v[0] ?? 1, 0, 0, v[1] ?? v[0] ?? 1, 0, 0];
else if (kind === "rotate") {
const a = ((v[0] ?? 0) * Math.PI) / 180;
const [cx, cy] = [v[1] ?? 0, v[2] ?? 0];
n = multiply(multiply([1, 0, 0, 1, cx, cy], [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0]), [1, 0, 0, 1, -cx, -cy]);
}
else if (kind === "skewX") n = [1, 0, Math.tan((v[0] ?? 0) * Math.PI / 180), 1, 0, 0];
else if (kind === "skewY") n = [1, Math.tan((v[0] ?? 0) * Math.PI / 180), 0, 1, 0, 0];
m = multiply(m, n);
}
return m;
}
const NUMBER = /-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/gi;
const attributeOf = (attrs, name) => {
const hit = [...attrs.matchAll(/(?:^|\s)([^\s=/>]+)\s*=\s*(["'])([\s\S]*?)\2/g)].find((match) => match[1] === name);
if (!hit) return null;
const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
return hit[3].replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (all, code) => {
if (code[0] !== "#") return named[code];
const value = code[1] === "x" ? parseInt(code.slice(2), 16) : Number(code.slice(1));
return value > 0 && value <= 0x10ffff ? String.fromCodePoint(value) : all;
});
};
function pointsOfShape(tag, attrs) {
const get = (name) => attributeOf(attrs, name);
const num = (name) => Number(get(name) ?? 0);
if (tag === "path") {
const d = get("d") ?? "";
const out = [];
let x = 0;
let y = 0;
let sx = 0;
let sy = 0;
for (const [, command, args] of d.matchAll(/([MmLlHhVvCcSsQqTtAaZz])([^MmLlHhVvCcSsQqTtAaZz]*)/g)) {
const v = (args.match(NUMBER) ?? []).map(Number);
const rel = command === command.toLowerCase();
const C = command.toUpperCase();
const pair = (i) => [v[i] + (rel ? x : 0), v[i + 1] + (rel ? y : 0)];
const take = (p) => {
out.push(p);
return p;
};
if (C === "H") for (const value of v) [x] = take([value + (rel ? x : 0), y]);
else if (C === "V") for (const value of v) [, y] = take([x, value + (rel ? y : 0)]);
else if (C === "A") for (let i = 0; i + 6 < v.length; i += 7) [x, y] = take([v[i + 5] + (rel ? x : 0), v[i + 6] + (rel ? y : 0)]);
else if (C === "Z") {
x = sx;
y = sy;
} else {
const width = C === "C" ? 6 : C === "S" || C === "Q" ? 4 : 2;
for (let i = 0; i + 1 < v.length; i += width) {
for (let j = 0; j < width; j += 2) out.push(pair(i + j));
[x, y] = pair(i + width - 2);
if (C === "M" && i === 0) {
sx = x;
sy = y;
}
}
}
}
return out;
}
if (tag === "circle" || tag === "ellipse") {
const r = Number(get("r") ?? get("rx") ?? 0);
const ry = Number(get("r") ?? get("ry") ?? 0);
return [[num("cx") - r, num("cy") - ry], [num("cx") + r, num("cy") + ry]];
}
if (tag === "line") return [[num("x1"), num("y1")], [num("x2"), num("y2")]];
if (tag === "rect") return cornersOfBox([num("x"), num("y"), num("x") + num("width"), num("y") + num("height")]);
if (tag === "polyline" || tag === "polygon") {
const v = (get("points") ?? "").match(NUMBER)?.map(Number) ?? [];
const out = [];
for (let i = 0; i + 1 < v.length; i += 2) out.push([v[i], v[i + 1]]);
return out;
}
return [];
}
const boxOfPoints = (points, m) => {
let box = null;
for (const [x, y] of points) {
const px = m[0] * x + m[2] * y + m[4];
const py = m[1] * x + m[3] * y + m[5];
box = box ? [Math.min(box[0], px), Math.min(box[1], py), Math.max(box[2], px), Math.max(box[3], py)] : [px, py, px, py];
}
return box;
};
const cornersOfBox = ([x0, y0, x1, y1]) => [[x0, y0], [x1, y0], [x1, y1], [x0, y1]];
const boxOfShape = (tag, attrs, m) => {
if (tag !== "circle" && tag !== "ellipse") return boxOfPoints(pointsOfShape(tag, attrs), m);
const num = (name) => Number(attributeOf(attrs, name) ?? 0);
const rx = tag === "circle" ? num("r") : num("rx");
const ry = tag === "circle" ? rx : num("ry");
const x = m[0] * num("cx") + m[2] * num("cy") + m[4];
const y = m[1] * num("cx") + m[3] * num("cy") + m[5];
const dx = Math.hypot(m[0] * rx, m[2] * ry);
const dy = Math.hypot(m[1] * rx, m[3] * ry);
return [x - dx, y - dy, x + dx, y + dy];
};
const unionBox = (a, b) => (!a ? b : !b ? a : [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.max(a[2], b[2]), Math.max(a[3], b[3])]);
const meetBox = (a, b) => {
if (!a || !b) return a ?? null;
const box = [Math.max(a[0], b[0]), Math.max(a[1], b[1]), Math.min(a[2], b[2]), Math.min(a[3], b[3])];
return box[0] <= box[2] && box[1] <= box[3] ? box : null;
};
const areaOf = (box) => (box ? Math.max(0, box[2] - box[0]) * Math.max(0, box[3] - box[1]) : 0);
export function markupBox(svg) {
const tags = [...svg.matchAll(/<(\/?)([a-zA-Z]+)((?:"[^"]*"|'[^']*'|[^'">])*?)(\/?)>/g)];
const clips = new Map();
let clipId = null;
for (const [, close, tag, attrs, self] of tags) {
if (tag === "clipPath" && !close) {
const id = attributeOf(attrs, "id");
if (id) clips.set(id, null);
clipId = self ? null : id;
continue;
}
if (clipId) {
if (tag === "clipPath" && close) {
clipId = null;
continue;
}
clips.set(clipId, unionBox(clips.get(clipId), boxOfShape(tag, attrs, matrixOf(attributeOf(attrs, "transform")))));
}
}
const stack = [{ m: [1, 0, 0, 1, 0, 0], clip: null, skip: false }];
let box = null;
for (const [, close, tag, attrs, self] of tags) {
const top = stack[stack.length - 1];
if (close) {
if (stack.length > 1) stack.pop();
continue;
}
const m = multiply(top.m, matrixOf(attributeOf(attrs, "transform")));
const ref = ((attributeOf(attrs, "clip-path") ?? "").match(/url\(#([^)]*)\)/) ?? [])[1];
const own = ref && clips.get(ref) ? boxOfPoints(cornersOfBox(clips.get(ref)), m) : null;
const clip = own ? meetBox(top.clip ?? own, own) : top.clip;
const empty = ref && clips.has(ref) && (!own || areaOf(own) === 0 || (top.clip && (!clip || areaOf(clip) === 0)));
const frame = { m, clip, skip: Boolean(empty) || top.skip || ["defs", "clipPath", "mask", "linearGradient", "radialGradient", "pattern", "text", "title"].includes(tag) || (attributeOf(attrs, "class") ?? "").includes("iso-halo") };
if (!frame.skip) {
const shape = boxOfShape(tag, attrs, m);
if (shape) box = unionBox(box, frame.clip ? meetBox(shape, frame.clip) : shape);
}
if (!self) stack.push(frame);
}
return box;
}
export function footprintOf(shape, cam) {
const flat = (p) => [cam.origin[0] + dot3(p, cam.R) * cam.k, cam.origin[1] + dot3(p, cam.D) * cam.k];
if (shape.kind === "body") {
const { F } = shape;
const points = [];
for (const [s, r] of shape.poly) {
if (r <= 0) {
points.push(flat(add3(F.o, mul3(F.a, s))));
continue;
}
for (let i = 0; i < 16; i++) {
const a = (i / 16) * Math.PI * 2;
points.push(flat(add3(add3(F.o, mul3(F.a, s)), add3(mul3(F.u, r * Math.cos(a)), mul3(F.v, r * Math.sin(a))))));
}
}
return boxOfPoints(points, [1, 0, 0, 1, 0, 0]);
}
if (shape.kind === "prism") {
const { F } = shape;
const points = [];
for (const s of [shape.s0, shape.s1]) for (const [x, y] of shape.poly) points.push(flat(add3(add3(F.o, mul3(F.a, s)), add3(mul3(F.u, x), mul3(F.v, y)))));
return boxOfPoints(points, [1, 0, 0, 1, 0, 0]);
}
const [x0, y0, x1, y1] = screenBox(shape, cam, [0, 0, 0]);
return [x0, y0, x1, y1];
}
export function coverage(items, P, { least = 0.6, pad = 1, allow = [] } = {}) {
const cam = cameraBasis(P);
const out = [];
for (const item of items) {
if (typeof item.svg !== "string" || !item.shapes || !item.shapes.length || matches(allow, item.name)) continue;
const drawn = markupBox(item.svg);
if (!drawn) continue;
const grow = (box) => [box[0] - pad, box[1] - pad, box[2] + pad, box[3] + pad];
const shapes = item.shapes.map((shape) => footprintOf(shape, cam)).reduce(unionBox, null);
const share = areaOf(meetBox(grow(drawn), grow(shapes))) / (areaOf(grow(drawn)) || 1);
if (share < least) out.push({ name: item.name, share, drawn, shapes });
}
return out.sort((a, b) => a.share - b.share);
}
export function selfOverlaps(items, P, { entries: given = null, fold = 0.25, least = 0.5 } = {}) {
const cam = cameraBasis(P);
const entries = given ?? entriesOf(items, cam);
const flat = (p) => [cam.origin[0] + dot3(p, cam.R) * cam.k, cam.origin[1] + dot3(p, cam.D) * cam.k];
const out = [];
for (const item of items) {
if (!item.route || !item.shapes || !item.shapes.length || item.shapes[0].kind !== "tube") continue;
const shape = item.shapes[0];
const r = shape.radii.reduce((sum, value) => sum + value, 0) / shape.radii.length;
const dense = resample(shape.points, Math.max(0.1, r * 0.2));
const screen = dense.map(flat);
const n = screen.length;
if (n < 4) continue;
const width = r * cam.k;
const span = 3;
const normals = screen.map((_, i) => {
const a = screen[Math.max(0, i - span)];
const b = screen[Math.min(n - 1, i + span)];
const length = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
return [-(b[1] - a[1]) / length, (b[0] - a[0]) / length];
});
let worst = null;
for (const side of [1, -1]) {
const edge = screen.map((p, i) => [p[0] + side * normals[i][0] * width, p[1] + side * normals[i][1] * width]);
for (let i = span; i < n - span - 1; i++) {
const along = [screen[i + 1][0] - screen[i][0], screen[i + 1][1] - screen[i][1]];
const step = [edge[i + 1][0] - edge[i][0], edge[i + 1][1] - edge[i][1]];
const length = Math.hypot(along[0], along[1]);
if (length < 1e-6) continue;
const forward = (step[0] * along[0] + step[1] * along[1]) / length;
if (forward > -fold * length) continue;
const x = (screen[i][0] + screen[i + 1][0]) / 2;
const y = (screen[i][1] + screen[i + 1][1]) / 2;
const front = frontEntry(entries, cam, x, y);
if (front && front.owner !== item.route && front.item !== item.name) continue;
const radius = Math.abs(forward / length - 1) > 1e-6 ? width / Math.abs(1 - forward / length) : Infinity;
if (width - radius < least) continue;
if (!worst || radius < worst.radius) worst = { name: item.name, route: item.route, radius, width, at: dense[i], screen: [x, y] };
}
}
if (worst) out.push(worst);
}
return out;
}
export function solidClearances(solids, { state, sunk = 0.5, spacing = 0.6, cell = 4 } = {}) {
const stretched = new Set();
const list = solids.filter((shape) => shape.kind !== "tube").map((shape) => {
if (!(shape.slide && state !== undefined && shape.move)) return shape;
const next = { ...moved(shape, offsetOf(shape, state)), move: undefined };
if (next.slide.to !== shape.slide.to) stretched.add(next);
return next;
});
if (!solidClearances.cache) solidClearances.cache = new WeakMap();
const cache = solidClearances.cache;
const gridOf = (shape) => {
let samples = cache.get(shape);
if (!samples) cache.set(shape, samples = new Map());
const key = `${spacing}:${cell}`;
let grid = samples.get(key);
if (grid) return grid;
grid = new Map();
for (const p of surfaceOf(shape, spacing)) {
const key = p.map((v) => Math.floor(v / cell)).join(",");
if (!grid.has(key)) grid.set(key, []);
grid.get(key).push(p);
}
samples.set(key, grid);
return grid;
};
const pointsIn = (shape, box) => {
const grid = gridOf(shape);
const lo = box.min.map((v) => Math.floor(v / cell));
const hi = box.max.map((v) => Math.floor(v / cell));
const out = [];
if ((hi[0] - lo[0] + 1) * (hi[1] - lo[1] + 1) * (hi[2] - lo[2] + 1) > grid.size) {
for (const points of grid.values()) for (const p of points) if (p.every((v, i) => v >= box.min[i] && v <= box.max[i])) out.push(p);
return out;
}
for (let x = lo[0]; x <= hi[0]; x++)
for (let y = lo[1]; y <= hi[1]; y++)
for (let z = lo[2]; z <= hi[2]; z++) {
const points = grid.get(`${x},${y},${z}`);
if (points) for (const p of points) if (p.every((v, i) => v >= box.min[i] && v <= box.max[i])) out.push(p);
}
return out;
};
const offsets = list.map((shape) => offsetAt(shape, state));
const bounds = list.map((shape) => boundsOf(shape));
const found = [];
for (let a = 0; a < list.length; a++)
for (let b = a + 1; b < list.length; b++) {
const rel = sub3(offsets[a], offsets[b]);
if (Math.abs(rel[0]) + Math.abs(rel[1]) + Math.abs(rel[2]) < 1e-6 && !stretched.has(list[a]) && !stretched.has(list[b])) continue;
const box = { min: [0, 1, 2].map((i) => Math.max(bounds[a].min[i] + rel[i], bounds[b].min[i])), max: [0, 1, 2].map((i) => Math.min(bounds[a].max[i] + rel[i], bounds[b].max[i])) };
if (box.min.some((v, i) => v > box.max[i] - sunk)) continue;
if (seatedOn(list[a], list[b]) || seatedOn(list[b], list[a])) continue;
let worst = -sunk;
let at = null;
const local = { min: sub3(box.min, rel), max: sub3(box.max, rel) };
for (const p of pointsIn(list[a], local)) {
const d = sdf(list[b], add3(p, rel));
if (d < worst) (worst = d), (at = add3(p, offsets[a]));
}
for (const p of pointsIn(list[b], box)) {
const d = sdf(list[a], sub3(p, rel));
if (d < worst) (worst = d), (at = add3(p, offsets[b]));
}
if (at) found.push({ tube: list[a].name, other: list[b].name, kind: "through", solid: true, clearance: worst, need: -sunk, at, from: 0, to: 0, length: 0, state: state === undefined ? "" : labelOf(state) });
}
return found.sort((x, y) => x.clearance - y.clearance);
}
export function wobble(solids, { samples = 20 } = {}) {
const out = [];
for (const shape of solids) {
const profile = shape.curve;
if (!profile) continue;
const segments = curveRuns(profile);
let run = [];
const flush = () => {
if (run.length) {
const values = [];
for (const index of run) {
const [s0] = profile[index];
const [s1] = profile[index + 1];
for (let j = values.length ? 1 : 0; j <= samples; j++) {
const s = s0 + ((s1 - s0) * j) / samples;
values.push([s, segments[index].slope(s)]);
}
}
const scale = Math.max(1, ...values.map(([, g]) => Math.abs(g))) * 1e-6;
const turns = [];
let last = 0;
for (let i = 1; i < values.length; i++) {
const d = values[i][1] - values[i - 1][1];
if (Math.abs(d) <= scale) continue;
const sign = Math.sign(d);
if (last && sign !== last) turns.push(Math.round(values[i - 1][0] * 100) / 100);
last = sign;
}
if (turns.length) out.push({ name: shape.name, at: turns, from: profile[run[0]][0], to: profile[run[run.length - 1] + 1][0] });
}
run = [];
};
segments.forEach((segment, index) => (segment ? run.push(index) : flush()));
flush();
}
return out;
}
export function seats(solids) {
const out = [];
for (const shape of solids) {
if (!shape.seated || !shape.cut) continue;
for (const host of [shape.cut].flat()) {
const mine = mul3(shape.move ?? [0, 0, 0], 1);
const theirs = mul3(host.move ?? [0, 0, 0], 1);
if ((shape.ride ?? shape.piece) === (host.ride ?? host.piece) && sameOffset(mine, theirs)) continue;
out.push({ name: shape.name, host: host.name, piece: shape.ride ?? shape.piece, hostPiece: host.ride ?? host.piece });
}
}
return out;
}
export function report({ clearance = [], depth = { problems: [], missing: [] }, terminals: ends, folds: bends, supports: held, loose, apart, flight, crowding: crowded, self, wobble: wobbly, seats: seated, cover: covered } = {}, { limit = 4000 } = {}) {
const lines = [];
const f = (v) => (Math.round(v * 100) / 100).toFixed(2);
const p3 = (p) => `[${p.map((v) => v.toFixed(1)).join(", ")}]`;
const clash = (c) => (c.solid ? ` solid ${c.state ? c.state + " " : ""}${c.tube} × ${c.other} sunk ${f(-c.clearance)} deep at ${p3(c.at)}` : ` ${c.kind.padEnd(7)} ${c.state ? c.state + " " : ""}${c.tube} × ${c.other} clearance ${f(c.clearance)} < ${f(c.need)} along ${f(c.from)}–${f(c.to)} of ${f(c.length)} at ${p3(c.at)}`);
lines.push(`clearance: ${clearance.length} problem${clearance.length === 1 ? "" : "s"}`);
for (const c of clearance.slice(0, limit)) lines.push(clash(c));
if (apart) {
lines.push(`clearance apart: ${apart.length} problem${apart.length === 1 ? "" : "s"}`);
for (const c of apart.slice(0, limit)) lines.push(clash(c));
}
if (ends) {
lines.push(`terminals: ${ends.length} end${ends.length === 1 ? "" : "s"} not on a mount`);
for (const e of ends.slice(0, limit)) lines.push(` ${e.tube} ${e.end} ${Number.isFinite(e.d) ? f(e.d) : "∞"} from ${e.nearest} (rim ${Number.isFinite(e.high) ? `${f(e.low)}…${f(e.high)}` : "-"}) at ${p3(e.at)}`);
}
if (loose) {
const hanging = loose.filter((e) => !e.free);
lines.push(`loose ends: ${hanging.length}`);
for (const e of hanging.slice(0, limit)) lines.push(` ${e.state} ${e.tube} ${e.end} touches nothing that moves with it at ${p3(e.at)}`);
}
if (bends) {
lines.push(`screen folds: ${bends.length}`);
for (const b of bends.slice(0, limit))
lines.push(b.kind === "pinch" ? ` ${b.name} turns ${b.flatTurn.toFixed(0)}° on screen round a ${f(b.radius)} px bend, under ${f(b.width * 2)} px for a ${f(b.width)} px tube at ${p3(b.at)}` : ` ${b.name} turns ${b.flatTurn.toFixed(0)}° on screen for ${b.realTurn.toFixed(0)}° in 3D at ${p3(b.at)}`);
}
if (held) {
const hanging = held.hanging ?? [];
lines.push(`support: ${held.loose.length} unsupported solid${held.loose.length === 1 ? "" : "s"} · ${hanging.length} hanging tube${hanging.length === 1 ? "" : "s"} · ${held.sunk.length} sunk pair${held.sunk.length === 1 ? "" : "s"}`);
for (const name of held.loose.slice(0, limit)) lines.push(` loose ${name}`);
for (const name of hanging.slice(0, limit)) lines.push(` hanging ${name}`);
for (const d of held.sunk.slice(0, limit)) lines.push(` sunk ${d.a} × ${d.b} ${f(d.depth)} deep`);
}
lines.push(`depth order: ${depth.problems.length} problem${depth.problems.length === 1 ? "" : "s"}`);
for (const d of depth.problems.slice(0, limit))
lines.push(` ${d.cycle ? "cycle " : "order "} ${d.label} ${d.front} (k ${f(d.frontKey)}) is in front of ${d.back} (k ${f(d.backKey)}) but drawn first ${f(d.area)} px²${d.against ? ` (${f(d.against)} px² the other way)` : ""}, up to ${f(d.depth)} nearer, at ${d.at.map((v) => v.toFixed(1)).join(",")}`);
if (flight) {
lines.push(`through in mid-flight: ${flight.length} pair${flight.length === 1 ? "" : "s"}`);
for (const c of flight.slice(0, limit)) lines.push(clash(c));
}
if (self) {
lines.push(`self-overlap: ${self.length} chunk${self.length === 1 ? "" : "s"} whose outline crosses itself on screen`);
for (const c of self.slice(0, limit)) lines.push(` ${c.name} its outline folds back on screen: the line turns on a ${f(c.radius)} px radius, under its ${f(c.width)} px half-width at ${p3(c.at)}, screen ${c.screen.map((v) => v.toFixed(1)).join(",")}`);
}
if (wobbly) {
lines.push(`wobble: ${wobbly.length} smoothed profile${wobbly.length === 1 ? "" : "s"} whose slope turns between its ends`);
for (const w of wobbly.slice(0, limit)) lines.push(` ${w.name} dr/ds turns at s = ${w.at.join(", ")} on the run ${f(w.from)}–${f(w.to)}; give it an analytic profile and smooth.slope`);
}
if (seated) {
lines.push(`saddles off their host apart: ${seated.length}`);
for (const d of seated.slice(0, limit)) lines.push(` ${d.name} (${d.piece}) is cut to ${d.host} (${d.hostPiece}); apart, its cut base is on show`);
}
if (covered) {
lines.push(`stand-in shapes: ${covered.length} item${covered.length === 1 ? "" : "s"} whose recorded shape covers too little of what it draws`);
for (const c of covered.slice(0, limit)) lines.push(` ${c.name} its shapes cover ${Math.round(c.share * 100)}% of its drawing (drawn ${c.drawn.map((v) => v.toFixed(0)).join(",")}, recorded ${c.shapes.map((v) => v.toFixed(0)).join(",")}); record the true shape of what you draw`);
}
if (crowded) {
lines.push(`crowding: ${crowded.length} pair${crowded.length === 1 ? "" : "s"} where a bend or end touches another line on screen`);
for (const c of crowded.slice(0, limit)) lines.push(` ${c.state ? c.state + " " : ""}${c.a} ${c.where} × ${c.b} outlines ${c.gap < 0 ? `overlap ${f(-c.gap)}` : `${f(c.gap)} apart`} px, ${f(c.depth)} apart in depth at screen ${c.screen.map((v) => v.toFixed(1)).join(",")}`);
}
if (depth.passing && depth.passing.length) {
const pairs = (list) => new Set(list.map((d) => [d.front, d.back].sort().join("|"))).size;
lines.push(`in passing (uniform explode states only, not failing): ${pairs(depth.passing.filter((d) => d.cycle))} interlocked pairs, ${pairs(depth.passing.filter((d) => !d.cycle))} pairs no linear key can order`);
for (const d of depth.passing.slice(0, limit)) lines.push(` ${d.cycle ? "cycle " : "unorderable"} ${d.label} ${d.front} / ${d.back} ${f(d.area)} px²`);
}
if (depth.missing.length) lines.push(`items with no shape: ${depth.missing.length} ${depth.missing.slice(0, 20).join(", ")}`);
if (loose && loose.some((e) => e.free)) {
const free = loose.filter((e) => e.free);
lines.push(`free ends apart (marked free, not failing): ${free.length}`);
for (const e of free.slice(0, limit)) lines.push(` ${e.tube} ${e.end} at ${p3(e.at)}`);
}
return lines.join("\n");
}
export const failures = ({ clearance = [], depth = { problems: [], missing: [] }, terminals: ends = [], folds: bends = [], supports: held = { loose: [], sunk: [] }, loose = [], apart = [], flight = [], crowding: crowded = [], self = [], wobble: wobbly = [], seats: seated = [], cover: covered = [] }) =>
covered.length + clearance.length + apart.length + flight.length + crowded.length + ends.length + loose.filter((e) => !e.free).length + bends.length + held.loose.length + (held.hanging ?? []).length + held.sunk.length + depth.problems.length + depth.missing.length + self.length + wobbly.length + seated.length;
export const sameRun = (a, b) => Boolean(a.route) && a.route === b.route && Math.abs(a.chunk - b.chunk) <= 1;
export function recorder(P, { order = [], spring = {}, ground = grounded } = {}) {
const V = cameraBasis(P).V;
const counts = new Map();
const R = { P, V, order, spring, ground, items: [], solids: [], tubes: [], routes: [], settled: null };
R.nameFor = (base) => {
const count = (counts.get(base) ?? 0) + 1;
counts.set(base, count);
return count === 1 ? base : `${base}#${count}`;
};
R.solid = (shape) => {
R.solids.push(shape);
return shape;
};
R.put = ({ at = null, bias = 0, key, name, piece = "", move = [0, 0, 0], ride, shapes = [], ...rest } = {}) => {
const item = { ...rest, piece, ride: ride ?? piece, key: key ?? (at ? dot3(at, V) : 0) + bias, move, shapes, name: name ?? R.nameFor(`${piece || "item"}.item`) };
for (const shape of shapes) (shape.move = item.move), (shape.ride = item.ride), (shape.piece = piece);
R.items.push(item);
return item;
};
R.route = (name, points, radius, { owner = name, touch, bundle, limp = false, gaps = [], closed = false, ends = [true, true], rims, free = [false, false], piece = "", move = [0, 0, 0], ride = piece } = {}) => {
const total = pathLength(points);
const radiusOf = typeof radius === "function" ? radius : () => radius;
const runs = runsOf(total, gaps);
const recorded = runs.map(([from, to], index) => ({
...tube(cutAlong(points, from, to), (t) => radiusOf((from + (to - from) * t) / total), { name, owner, touch, bundle, limp, joined: true }),
tips: closed ? [null, null] : [index === 0 && ends[0] ? points[0] : null, index === runs.length - 1 && ends[1] ? points[points.length - 1] : null],
tipAxes: [tangentAlong(points, 0), tangentAlong(points, total)],
tipRims: rims ?? [radiusOf(0), radiusOf(1)],
free: [index === 0 && free[0], index === runs.length - 1 && free[1]],
offset: from,
total,
move,
ride,
piece,
}));
R.tubes.push(...recorded);
R.routes.push({ name, points, r: radiusOf(0.5), bundle, move, ride, piece });
return recorded;
};
return R;
}
export function explodeStates(order = [], spring = {}, { uniform = 10, stride = 4 } = {}) {
if (!order.length) return { depth: [0], frames: [], apart: false };
const reversals = reversalsOf(order, spring.stagger ?? 0.035);
const prefix = prefixStates(order);
return {
depth: [...uniformStates(uniform), ...springStates(order, { ...spring, stride, reversals }), ...prefix],
frames: [...springStates(order, { ...spring, reversals }), ...prefix],
apart: true,
};
}
export function settle(R, P = R.P, { states = explodeStates(R.order, R.spring).depth, skip = sameRun, ...options } = {}) {
const items = R.items.slice();
const overlaps = overlapsOf(items, P, { states, skip, ...options });
const solved = orderKeys(items, overlaps);
items.forEach((item, index) => (item.key = solved.keys[index]));
R.settled = { items, overlaps, solved, states };
return R.settled;
}
const worstOf = (lists) => [...lists.flat().reduce((all, c) => (all.has(`${c.tube}|${c.other}`) && all.get(`${c.tube}|${c.other}`).clearance <= c.clearance ? all : all.set(`${c.tube}|${c.other}`, c)), new Map()).values()].sort((x, y) => x.clearance - y.clearance);
export function audit(R, P = R.P, { allow = [], crowd = [], cover = [], ground = R.ground, frames = explodeStates(R.order, R.spring).frames, apart = R.order.length > 0 } = {}) {
const { items, overlaps, solved } = R.settled ?? settle(R, P);
const mounts = mountsOf(R.tubes, R.solids);
const links = linksOf(R.tubes, mounts);
return {
clearance: clearances(R.tubes, R.solids, { mounts }),
apart: apart ? [...clearances(R.tubes, R.solids, { state: 1, mounts, only: "through" }), ...solidClearances(R.solids, { state: 1 })] : [],
flight: worstOf(frames.map((state) => [...clearances(R.tubes, R.solids, { state, mounts, only: "through" }), ...solidClearances(R.solids, { state })])),
crowding: (apart ? [0, 1] : [0]).flatMap((state) => crowding(R.routes, P, { links, items, allow: crowd, state, rods: slenderOf(R.solids) })),
cover: coverage(items, P, { allow: cover }),
terminals: terminals(R.tubes, R.solids, { mounts }),
loose: looseEnds(R.tubes, R.solids, { state: 1 }),
folds: folds(R.routes, P, { items }),
self: selfOverlaps(items, P),
wobble: wobble(R.solids),
seats: seats(R.solids),
supports: supports(R.solids, R.tubes, { ground }),
depth: depthOrder(items, P, { overlaps, solved, allow }),
};
}
export function auditOrExit(R, P = R.P, { flag = "--audit", argv = process.argv, ...options } = {}) {
if (!argv.includes(flag)) return null;
const started = Date.now();
const result = audit(R, P, options);
const { overlaps, solved, states } = R.settled;
console.log(report(result));
console.log(`audit · ${R.tubes.length} tubes · ${R.solids.length} solids · ${R.items.length} items · ${states.length} depth states · ${overlaps.pairs.length} overlaps · ${solved.rules} order rules · ${((Date.now() - started) / 1000).toFixed(1)} s`);
const count = failures(result);
console.log(count ? `audit failed: ${count} problem${count === 1 ? "" : "s"}` : "audit passed");
if (count) process.exitCode = 1;
return result;
}