prographs 0.12.0 → 0.13.0

package/dist/charts/threefields/CompressorMap3DChart.js

@@ -0,0 +1,217 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { MachineChart } from "../machinecharts/MachineChart.js";
+import { MachineMesh } from "../machinecharts/MachineMesh.js";
+import { MachineSamples } from "../machinecharts/MachineSamples.js";
+import { ColorRamp } from "../threesurfaces/ColorRamp.js";
+import { SurfaceGeometry } from "../threesurfaces/SurfaceGeometry.js";
+import { CEIL, FLOOR } from "../threesurfaces/SurfaceSpace.js";
+import { TubeBatch } from "../threesurfaces/TubeBatch.js";
+import { MapSheet } from "./MapSheet.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { group, max, mean, scaleLinear } from "d3";
+// src/charts/threefields/CompressorMap3DChart.ts
+/** The surge line as a wall from floor to ceiling, as a ribbon standing on the edge of the surface, or left out. */
+var CompressorMap3DSurge = /* @__PURE__ */ function(CompressorMap3DSurge) {
+	CompressorMap3DSurge["Wall"] = "surge-wall";
+	CompressorMap3DSurge["Ribbon"] = "surge-ribbon";
+	CompressorMap3DSurge["None"] = "no-surge";
+	return CompressorMap3DSurge;
+}({});
+var EFFICIENCY = "Efficiency";
+var SPEED = "Speed lines";
+var PEAK = "Peak efficiency";
+var BETWEEN = 5;
+/**
+* A compressor map with efficiency as height: the operating range as a sheet over corrected flow and pressure ratio, the
+* speed lines drawn across it and the surge line as a wall. Use it to show how sharply efficiency falls away from the
+* design point; the 2D compressor map takes the same rows and reads values more exactly.
+*/
+var CompressorMap3DChart = class extends ThreeFieldBase {
+	static meta = {
+		id: "compressor-map-3d",
+		name: "3D compressor map",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Raises isentropic efficiency into a surface over corrected mass flow and pressure ratio, with the speed lines drawn on it and the surge line as a wall or ribbon.",
+		tags: [
+			"turbomachinery",
+			"turbocharger",
+			"surge line",
+			"efficiency island",
+			"speed line",
+			"gas turbine",
+			"performance map"
+		],
+		sample: (seed) => MachineSamples.compressor(seed),
+		variants: {
+			surge: Object.values(CompressorMap3DSurge),
+			ridge: [false, true],
+			markers: [true, false],
+			floorMap: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			x: "flow",
+			y: "pressureRatio",
+			series: "speed",
+			efficiency: "efficiency",
+			surge: "surge-wall",
+			ridge: false,
+			markers: true,
+			floorMap: true,
+			xLabel: "Mass flow (kg/s)",
+			yLabel: "Pressure ratio",
+			zLabel: "Efficiency"
+		};
+	}
+	get rows() {
+		return (Array.isArray(this.options.data) ? this.options.data : []).filter((row) => row !== null && typeof row === "object");
+	}
+	/** Speed lines from surge to choke, slowest first: lower speeds pass less flow. */
+	lines() {
+		const { x, y, series, efficiency } = this.options;
+		const points = this.rows.flatMap((row) => {
+			const flow = MachineChart.number(row[x]), ratio = MachineChart.number(row[y]);
+			return flow === null || ratio === null ? [] : [{
+				speed: String(row[series] ?? "Speed"),
+				x: flow,
+				y: ratio,
+				z: MachineChart.number(row[efficiency]) ?? NaN
+			}];
+		});
+		return [...group(points, (d) => d.speed)].map(([speed, own]) => ({
+			speed,
+			points: own.sort((a, b) => a.x - b.x)
+		})).sort((a, b) => mean(a.points, (d) => d.x) - mean(b.points, (d) => d.x));
+	}
+	table() {
+		const { x, y, series, efficiency } = this.options;
+		return {
+			columns: [
+				series,
+				x,
+				y,
+				efficiency
+			],
+			rows: this.lines().flatMap((line) => line.points.map((d) => [
+				d.speed,
+				d.x,
+				d.y,
+				Number.isFinite(d.z) ? d.z : null
+			]))
+		};
+	}
+	build(ctx) {
+		const { surge, ridge, markers, floorMap } = this.options, { theme, palette } = ctx;
+		const lines = this.lines().map((line) => line.points.every((d) => Number.isFinite(d.z)) ? line : {
+			...line,
+			points: line.points.map((d) => ({
+				...d,
+				z: NaN
+			}))
+		});
+		const all = lines.flatMap((line) => line.points), measured = lines.filter((line) => line.points.length > 1 && Number.isFinite(line.points[0].z));
+		const mesh = new MachineMesh(measured.map((line) => line.points), 24, BETWEEN), sheet = new MapSheet(mesh, all, false, [FLOOR + (floorMap ? .42 : .3), CEIL]);
+		const percent = (max(all, (d) => d.z) ?? 0) <= 1.5;
+		const efficiency = (value) => percent ? `${MachineChart.short(value * 100)}%` : MachineChart.short(value);
+		const ramp = new ColorRamp(palette.sequential), [low, high] = sheet.z;
+		const paint = (value) => ramp.at(.08 + .9 * (value - low) / (high - low));
+		palette.color(EFFICIENCY);
+		const ink = palette.color(SPEED), dark = ctx.color(theme.ink);
+		this.box(ctx, {
+			x: this.ticks(sheet.x, sheet.across),
+			y: this.ticks(sheet.y, sheet.depth),
+			z: mesh.rows ? scaleLinear(sheet.z, [0, 1]).ticks(4).map((value) => [sheet.level(value), efficiency(value)]) : []
+		});
+		if (!all.length) return;
+		const lift = this.rise(ctx);
+		const tip = (d) => ({
+			title: `Speed ${d.speed}`,
+			color: ink,
+			rows: [
+				["Flow", MachineChart.short(d.x, 4)],
+				["Pressure ratio", MachineChart.short(d.y, 4)],
+				...Number.isFinite(d.z) ? [["Efficiency", efficiency(d.z)]] : []
+			]
+		});
+		if (mesh.rows) this.solid(ctx, sheet.geometry(paint), lift, (k) => {
+			const node = mesh.nodes[Math.floor(k / mesh.columns)][k % mesh.columns];
+			return { rows: [
+				["Efficiency", efficiency(node.z)],
+				["Flow", MachineChart.short(node.x, 4)],
+				["Pressure ratio", MachineChart.short(node.y, 4)]
+			] };
+		});
+		const traced = lines.filter((line) => line.points.length > 1).map((line) => {
+			const row = measured.indexOf(line);
+			return {
+				line,
+				nodes: row < 0 || !mesh.rows ? line.points : mesh.nodes[row * BETWEEN]
+			};
+		});
+		for (const { line, nodes } of traced) {
+			const tube = this.tubes(new TubeBatch(.007).add(nodes.map((node) => sheet.place(node, .008))), lift, ink);
+			if (tube) ctx.pick(tube, () => ({
+				title: `Speed ${line.speed}`,
+				color: ink,
+				rows: [["Flow at surge", MachineChart.short(line.points[0].x)], ["Flow at choke", MachineChart.short(line.points.at(-1).x)]]
+			}));
+			const [x, y, z] = nodes.map((node) => sheet.place(node)).reduce((crest, point) => point[1] > crest[1] ? point : crest);
+			ctx.label(line.speed, [
+				x,
+				y + .085,
+				z
+			], "secondary", 10, lift);
+		}
+		const shown = markers ? all : [];
+		this.dots(ctx, shown.map((d) => sheet.place(d, .008)), .014, () => ctx.color(ink), lift, (k) => tip(shown[k]));
+		const ends = (pick) => (mesh.rows && measured.length === traced.length ? mesh.nodes : traced.map(({ nodes }) => nodes)).map(pick);
+		const surged = traced.length > 1 ? ends((nodes) => nodes[0]) : [], choked = traced.length > 1 ? ends((nodes) => nodes[nodes.length - 1]) : [];
+		if (surge !== "no-surge" && surged.length) {
+			const edge = surged.map((node) => sheet.place(node, .01));
+			this.tubes(new TubeBatch(.011).add(edge), lift, theme.ink);
+			const wall = surge === "surge-wall";
+			const band = wall ? SurfaceGeometry.curtain(edge.map(([x, , z]) => [
+				x,
+				CEIL + .06,
+				z
+			]), FLOOR + .002, () => dark, () => dark) : SurfaceGeometry.curtain(edge.map(([x, y, z]) => [
+				x,
+				y + .07,
+				z
+			]), (k) => edge[k][1] - .07, () => dark, () => dark);
+			this.solid(ctx, band, lift, void 0, wall ? {
+				transparent: true,
+				opacity: .16,
+				depthWrite: false
+			} : {}).castShadow = !wall;
+			const [x, y, z] = edge[Math.floor(edge.length / 2)];
+			this.tag(ctx, "Surge line", [
+				x,
+				wall ? CEIL + .14 : y + .21,
+				z
+			], lift);
+		}
+		const peaks = ridge ? measured.map((line) => line.points.reduce((best, d) => d.z > best.z ? d : best)) : [];
+		const crest = peaks.length ? palette.color(PEAK) : "";
+		if (peaks.length > 1) this.tubes(new TubeBatch(.006).add(peaks.map((d) => sheet.place(d, .012))), lift, crest);
+		this.dots(ctx, peaks.map((d) => sheet.place(d, .012)), .024, () => ctx.color(crest), lift, (k) => ({
+			...tip(peaks[k]),
+			title: `Peak efficiency at ${peaks[k].speed}`,
+			color: crest
+		}));
+		if (!floorMap) return;
+		const flat = new TubeBatch(.004);
+		for (const { nodes } of traced) flat.add(nodes.map((node) => sheet.floor(node, .006)));
+		this.tubes(flat, ctx.root, ink);
+		const islands = new TubeBatch(.004);
+		for (const { value, paths } of sheet.contours(mesh.levels())) for (const path of paths) islands.add(path.map((node) => sheet.floor(node, .006)), paint(value));
+		this.tubes(islands, ctx.root);
+		this.tubes(new TubeBatch(.007).add(surged.map((node) => sheet.floor(node, .007))), ctx.root, theme.ink);
+		this.tubes(new TubeBatch(.004).add(choked.map((node) => sheet.floor(node, .007))), ctx.root, theme.inkMuted);
+	}
+};
+export { CompressorMap3DChart, CompressorMap3DSurge };

package/dist/charts/threefields/FieldGrid.js

@@ -0,0 +1,50 @@
+// src/charts/threefields/FieldGrid.ts
+/** Reads a gridded surface by data position, so paths given in the grid's own units can be laid on it. */
+var FieldGrid = class FieldGrid {
+	field;
+	space;
+	constructor(field, space) {
+		this.field = field;
+		this.space = space;
+	}
+	/** Fractional index of `value` along an axis that runs one way, held inside it. */
+	static index(axis, value) {
+		const last = axis.length - 1, falling = axis[0] > axis[last];
+		let i = 0;
+		while (i < last - 1 && (falling ? axis[i + 1] > value : axis[i + 1] < value)) i++;
+		const span = axis[i + 1] - axis[i];
+		return i + (span ? Math.max(0, Math.min(1, (value - axis[i]) / span)) : 0);
+	}
+	index(x, y) {
+		return [FieldGrid.index(this.field.x, x), FieldGrid.index(this.field.y, y)];
+	}
+	/** The gridded value under a point; a point past the grid reads its nearest edge. */
+	value(x, y) {
+		return this.field.sample(...this.index(x, y));
+	}
+	/** World position on the surface under a point. */
+	at(x, y, lift = 0) {
+		return this.space.at(...this.index(x, y), lift);
+	}
+	/** Lays a track on the surface, cutting each leg so no piece spans more than `cell` grid cells and the line cannot dive under a ridge. */
+	drape(track, lift = 0, cell = .5) {
+		const path = [], knots = [];
+		let before = null;
+		for (const [x, y] of track) {
+			const here = this.index(x, y);
+			const pieces = before ? Math.max(1, Math.ceil(Math.max(Math.abs(here[0] - before[0]), Math.abs(here[1] - before[1])) / cell)) : 1;
+			for (let piece = 1; piece < pieces; piece++) {
+				const t = piece / pieces;
+				path.push(this.space.at(before[0] + (here[0] - before[0]) * t, before[1] + (here[1] - before[1]) * t, lift));
+			}
+			knots.push(path.length);
+			path.push(this.space.at(here[0], here[1], lift));
+			before = here;
+		}
+		return {
+			path,
+			knots
+		};
+	}
+};
+export { FieldGrid };

package/dist/charts/threefields/LossLandscape3DChart.js

@@ -0,0 +1,201 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { ModelSamples } from "../modelcharts/ModelSamples.js";
+import { ColorRamp } from "../threesurfaces/ColorRamp.js";
+import { SurfaceOverlay } from "../threesurfaces/SurfaceBase.js";
+import { SurfaceField } from "../threesurfaces/SurfaceField.js";
+import { SurfaceGeometry } from "../threesurfaces/SurfaceGeometry.js";
+import { CEIL, FLOOR, SurfaceSpace } from "../threesurfaces/SurfaceSpace.js";
+import { TubeBatch } from "../threesurfaces/TubeBatch.js";
+import { FieldGrid } from "./FieldGrid.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { format, mean, scaleLinear, scaleLog } from "d3";
+// src/charts/threefields/LossLandscape3DChart.ts
+/** How an optimiser's run is drawn: a tube with a ball on each step, the tube alone, or not at all. */
+var LossLandscape3DTrail = /* @__PURE__ */ function(LossLandscape3DTrail) {
+	LossLandscape3DTrail["Steps"] = "step-markers";
+	LossLandscape3DTrail["Path"] = "path-only";
+	LossLandscape3DTrail["None"] = "no-path";
+	return LossLandscape3DTrail;
+}({});
+var MOST_DOTS = 90;
+var figure = format(".3~g");
+/**
+* The loss over two directions in parameter space as a height surface, with each optimiser's run laid on it as a tube.
+* Use it when the depth of a valley or the sharpness of a minimum matters more than exact levels; the 2D loss
+* landscape takes the same data and reads levels more precisely.
+*/
+var LossLandscape3DChart = class LossLandscape3DChart extends ThreeFieldBase {
+	static meta = {
+		id: "loss-landscape-3d",
+		name: "3D loss landscape",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Raises a loss over two parameter directions into a surface on a linear or log height, and lays the path of each optimiser on it as a tube with a marker per step.",
+		tags: [
+			"machine learning",
+			"optimisation",
+			"gradient descent",
+			"loss surface",
+			"training",
+			"optimizer path"
+		],
+		sample: (seed) => ModelSamples.lossSurface(seed),
+		variants: {
+			scale: [ScaleKind.Linear, ScaleKind.Log],
+			trail: Object.values(LossLandscape3DTrail),
+			overlay: [
+				SurfaceOverlay.Contours,
+				SurfaceOverlay.Mesh,
+				SurfaceOverlay.None
+			],
+			floorMap: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			scale: ScaleKind.Linear,
+			trail: "step-markers",
+			overlay: SurfaceOverlay.Contours,
+			floorMap: false,
+			levels: 9,
+			xLabel: "Direction 1",
+			yLabel: "Direction 2",
+			zLabel: "Loss"
+		};
+	}
+	/** The grid, with its depth axis turned when that brings the lower of its two ends to the front, where no wall hides the valley floor. */
+	get losses() {
+		const field = SurfaceField.from(this.options.data).capped(90), { nx, ny } = field;
+		const end = (j) => mean(Array.from({ length: nx }, (_, i) => field.at(i, j)).filter(Number.isFinite)) ?? 0;
+		if (!(end(ny - 1) < end(0))) return field;
+		const turned = new Float64Array(nx * ny);
+		for (let j = 0; j < ny; j++) turned.set(field.z.subarray((ny - 1 - j) * nx, (ny - j) * nx), j * nx);
+		return new SurfaceField(field.x, [...field.y].reverse(), turned);
+	}
+	table() {
+		return this.gridTable(SurfaceField.from(this.options.data));
+	}
+	/** `Log` is log10 while every loss is positive, and asinh around zero otherwise, so zero and negative losses stay on the chart. */
+	static warp({ zMin, zMax, zDomain }, scale = ScaleKind.Linear) {
+		if (scale !== ScaleKind.Log) return {
+			to: (loss) => loss,
+			ticks: scaleLinear(zDomain, [0, 1]).ticks(4)
+		};
+		if (!(zMin > 0)) {
+			const bend = Math.max(zMax - zMin, 1e-9) / 50;
+			return {
+				to: (loss) => Math.asinh(loss / bend),
+				ticks: scaleLinear(zDomain, [0, 1]).ticks(4)
+			};
+		}
+		const all = scaleLog([zMin, Math.max(zMax, zMin * 1.0001)], [0, 1]).ticks(), tens = all.filter((tick) => Math.abs(Math.log10(tick) % 1) < 1e-9);
+		return {
+			to: Math.log10,
+			ticks: tens.length >= 2 ? tens : all.filter((_, i) => i % Math.ceil(all.length / 4) === 0)
+		};
+	}
+	/** Each run with the loss under every step. A step past the grid sits on its nearest edge, and one over a gap is left out. */
+	runs(ctx, losses, grid) {
+		const paths = this.options.data?.paths;
+		if (this.options.trail === "no-path" || !Array.isArray(paths)) return [];
+		return paths.filter((path) => path && Array.isArray(path.points)).map((path, i) => {
+			const name = String(path.name ?? `Path ${i + 1}`);
+			const read = path.points.map((point, index) => ({
+				index,
+				x: +point?.[0],
+				y: +point?.[1]
+			})).filter((step) => Number.isFinite(step.x) && Number.isFinite(step.y)).map((step) => ({
+				...step,
+				loss: losses.sample(...grid.index(step.x, step.y))
+			})).filter((step) => Number.isFinite(step.loss));
+			const { path: laid, knots } = grid.drape(read.map((step) => [step.x, step.y]), .012);
+			return {
+				name,
+				color: "",
+				steps: read.map((step, k) => ({
+					...step,
+					at: laid[knots[k]]
+				})),
+				path: laid
+			};
+		}).filter((run) => run.steps.length).map((run) => ({
+			...run,
+			color: ctx.palette.color(run.name)
+		}));
+	}
+	build(ctx) {
+		const { scale, trail, overlay, floorMap, levels, xLabel, yLabel, zLabel } = this.options;
+		const losses = this.losses, warp = LossLandscape3DChart.warp(losses, scale);
+		const field = losses.map(warp.to);
+		const space = new SurfaceSpace(field, ScaleKind.Linear, [FLOOR + (floorMap ? .42 : .04), CEIL]), grid = new FieldGrid(field, space);
+		const [low, high] = field.zDomain, ramp = new ColorRamp(ctx.palette.sequential);
+		const paint = (value) => ramp.at(.05 + .95 * (value - low) / (high - low));
+		const [x0, x1] = field.xDomain, [y0, y1] = field.yDomain, reach = losses.zDomain[1] - losses.zDomain[0];
+		this.box(ctx, {
+			x: this.ticks(field.xDomain, (v) => (v - x0) / (x1 - x0 || 1) * 2 - 1),
+			y: this.ticks(field.yDomain, (v) => 1 - (v - y0) / (y1 - y0 || 1) * 2),
+			z: warp.ticks.map((loss) => [space.level(warp.to(loss)), scale === ScaleKind.Log ? figure(loss) : Scales.format(loss, reach)])
+		});
+		const lift = this.rise(ctx);
+		this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => paint(field.at(i, j))), lift, (k) => {
+			const i = k % field.nx, j = Math.floor(k / field.nx);
+			return { rows: [
+				[zLabel, figure(losses.at(i, j))],
+				[xLabel, figure(field.x[i])],
+				[yLabel, figure(field.y[j])]
+			] };
+		});
+		if (!field.hasData) return;
+		if (overlay === SurfaceOverlay.Mesh) this.meshLines(ctx, space, lift);
+		if (overlay === SurfaceOverlay.Contours) this.contourLines(ctx, space, lift, levels);
+		if (floorMap) this.floorContours(ctx, space, paint, levels);
+		const runs = this.runs(ctx, losses, grid);
+		const tip = (run, step, title = `${run.name}, step ${step.index}`) => ({
+			title,
+			color: run.color,
+			rows: [
+				[zLabel, figure(step.loss)],
+				[xLabel, figure(step.x)],
+				[yLabel, figure(step.y)]
+			]
+		});
+		for (const run of runs) {
+			this.casing(run.path, .008, ctx.theme.surface, lift);
+			const tube = this.tubes(new TubeBatch(.008).add(run.path), lift, run.color);
+			if (tube) ctx.pick(tube, () => ({
+				title: run.name,
+				color: run.color,
+				rows: [
+					["Steps", run.steps.length - 1],
+					["Loss at start", figure(run.steps[0].loss)],
+					["Loss at end", figure(run.steps.at(-1).loss)]
+				]
+			}));
+			if (floorMap) this.tubes(new TubeBatch(.004).add(run.path.map(([x, , z]) => [
+				x,
+				FLOOR + .008,
+				z
+			])), ctx.root, run.color);
+		}
+		const between = trail === "step-markers" ? runs.flatMap((run) => {
+			const every = Math.max(1, Math.ceil(run.steps.length / MOST_DOTS));
+			return run.steps.slice(1, -1).filter((_, k) => (k + 1) % every === 0).map((step) => ({
+				run,
+				step
+			}));
+		}) : [];
+		this.dots(ctx, between.map(({ step }) => step.at), .014, (k) => ctx.color(between[k].run.color), lift, (k) => tip(between[k].run, between[k].step));
+		this.rings(ctx, runs.map((run) => run.steps[0].at), .03, (k) => ctx.color(runs[k].color), lift, (k) => tip(runs[k], runs[k].steps[0], `${runs[k].name}, start`));
+		const ended = runs.filter((run) => run.steps.length > 1);
+		this.dots(ctx, ended.map((run) => run.steps.at(-1).at), .03, (k) => ctx.color(ended[k].color), lift, (k) => tip(ended[k], ended[k].steps.at(-1), `${ended[k].name}, end after ${ended[k].steps.at(-1).index} steps`));
+		const lowest = losses.z.indexOf(losses.zMin);
+		if (lowest >= 0) this.pins(ctx, [{
+			at: space.at(lowest % field.nx, Math.floor(lowest / field.nx)),
+			text: `Lowest loss ${figure(losses.zMin)}`
+		}], lift);
+	}
+};
+export { LossLandscape3DChart, LossLandscape3DTrail };

package/dist/charts/threefields/MapSheet.js

@@ -0,0 +1,77 @@
+import { SurfaceField } from "../threesurfaces/SurfaceField.js";
+import { SurfaceGeometry } from "../threesurfaces/SurfaceGeometry.js";
+import { CEIL, FLOOR } from "../threesurfaces/SurfaceSpace.js";
+import { extent } from "d3";
+// src/charts/threefields/MapSheet.ts
+var span = (values) => {
+	const [low, high] = extent(values.filter(Number.isFinite));
+	return low === void 0 || high === void 0 ? [0, 1] : high > low ? [low, high] : [low - 1, low + 1];
+};
+var mix = (a, b, t) => ({
+	x: a.x + (b.x - a.x) * t,
+	y: a.y + (b.y - a.y) * t,
+	z: a.z + (b.z - a.z) * t
+});
+/**
+* A test-bench map as a sheet in the cube: the map's x runs across, its y runs into the depth and the mapped quantity is
+* the height. The sheet follows the mesh of the sweeps, so its outline is the operating range and not a rectangle.
+*/
+var MapSheet = class {
+	mesh;
+	near;
+	range;
+	x;
+	y;
+	z;
+	/** `points` are the measured nodes the axes must hold. `near` brings the high end of y to the front. */
+	constructor(mesh, points, near = false, range = [FLOOR + .3, CEIL]) {
+		this.mesh = mesh;
+		this.near = near;
+		this.range = range;
+		const all = [...mesh.nodes.flat(), ...points];
+		this.x = span(all.map((node) => node.x));
+		this.y = span(all.map((node) => node.y));
+		this.z = span(all.map((node) => node.z));
+	}
+	across = (x) => (x - this.x[0]) / (this.x[1] - this.x[0]) * 2 - 1;
+	depth = (y) => (1 - (y - this.y[0]) / (this.y[1] - this.y[0]) * 2) * (this.near ? -1 : 1);
+	level = (z) => this.range[0] + (z - this.z[0]) / (this.z[1] - this.z[0]) * (this.range[1] - this.range[0]);
+	/** A node on the sheet. One with no height lies on the floor. */
+	place(node, lift = 0) {
+		return [
+			this.across(node.x),
+			(Number.isFinite(node.z) ? this.level(node.z) : FLOOR) + lift,
+			this.depth(node.y)
+		];
+	}
+	floor(node, lift = 0) {
+		return [
+			this.across(node.x),
+			FLOOR + lift,
+			this.depth(node.y)
+		];
+	}
+	/** The map at fractional mesh coordinates. */
+	node(column, row) {
+		const { nodes, columns, rows } = this.mesh;
+		const i = Math.max(0, Math.min(columns - 2, Math.floor(column))), j = Math.max(0, Math.min(rows - 2, Math.floor(row)));
+		return mix(mix(nodes[j][i], nodes[j][i + 1], column - i), mix(nodes[j + 1][i], nodes[j + 1][i + 1], column - i), row - j);
+	}
+	geometry(paint) {
+		const { nodes, columns, rows } = this.mesh;
+		return SurfaceGeometry.grid(columns, rows, (i, j) => this.place(nodes[j][i]), (i, j) => paint(nodes[j][i].z));
+	}
+	/** Lines of equal height across the sheet, each node carrying the level as its z. */
+	contours(levels) {
+		const { columns, rows, values } = this.mesh;
+		if (!rows || !levels.length) return [];
+		return new SurfaceField(Array.from({ length: columns }, (_, i) => i), Array.from({ length: rows }, (_, j) => j), Float64Array.from(values)).lines(levels).map(({ value, paths }) => ({
+			value,
+			paths: paths.map((path) => path.map(([i, j]) => ({
+				...this.node(i, j),
+				z: value
+			})))
+		}));
+	}
+};
+export { MapSheet };