prographs 0.12.0 → 0.13.0

package/dist/charts/threefields/TerrainRoute3DChart.js

@@ -0,0 +1,201 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { ElevationMath } from "../machinecharts/ElevationMath.js";
+import { ColorRamp } from "../threesurfaces/ColorRamp.js";
+import { SurfaceField } from "../threesurfaces/SurfaceField.js";
+import { SurfaceGeometry } from "../threesurfaces/SurfaceGeometry.js";
+import { SurfaceMesh } from "../threesurfaces/SurfaceMesh.js";
+import { CEIL, FLOOR, SurfaceSpace } from "../threesurfaces/SurfaceSpace.js";
+import { TubeBatch } from "../threesurfaces/TubeBatch.js";
+import { FieldGrid } from "./FieldGrid.js";
+import { TerrainRouteMath } from "./TerrainRouteMath.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { ThreeFieldsSamples } from "./ThreeFieldsSamples.js";
+import { interpolateRgb } from "d3";
+// src/charts/threefields/TerrainRoute3DChart.ts
+/** `Tube` lays the route on the ground. `Curtain` also hangs a ribbon from it to the base and fades the terrain, so the profile reads along the route. */
+var TerrainRoute3DForm = /* @__PURE__ */ function(TerrainRoute3DForm) {
+	TerrainRoute3DForm["Tube"] = "route-tube";
+	TerrainRoute3DForm["Curtain"] = "route-curtain";
+	return TerrainRoute3DForm;
+}({});
+var STEEP = [
+	{
+		steep: -1,
+		label: "Descent",
+		tone: -.6
+	},
+	{
+		steep: 0,
+		label: "Under 3%",
+		tone: 0
+	},
+	{
+		steep: 1,
+		label: "3 to 6%",
+		tone: .4
+	},
+	{
+		steep: 2,
+		label: "6 to 9%",
+		tone: .72
+	},
+	{
+		steep: 3,
+		label: "Over 9%",
+		tone: 1
+	}
+];
+var SIDES = 6;
+var tenth = (value) => (+value.toFixed(1)).toLocaleString("en");
+/**
+* A route over the ground it crosses: the terrain as a surface and the route as a tube that follows it, coloured by
+* steepness, with the climbs named. Use it when where a climb lies matters as much as how steep it is; an elevation
+* profile reads the gradients more exactly.
+*/
+var TerrainRoute3DChart = class extends ThreeFieldBase {
+	static meta = {
+		id: "terrain-route-3d",
+		name: "Terrain route profile",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Draws an elevation grid as terrain with a route laid over it as a tube coloured by gradient class, the climbs pinned, and optionally a curtain from the route down to the base.",
+		tags: [
+			"route profile",
+			"elevation",
+			"gradient",
+			"climb",
+			"cycling",
+			"hiking",
+			"dem",
+			"track"
+		],
+		sample: (seed) => ThreeFieldsSamples.terrainRoute(seed),
+		variants: {
+			form: Object.values(TerrainRoute3DForm),
+			climbs: [true, false],
+			contours: [false, true],
+			solidBase: [true, false]
+		},
+		valid: ({ form, solidBase }) => form === "route-tube" || solidBase === false
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			elevation: 32,
+			form: "route-tube",
+			climbs: true,
+			contours: false,
+			solidBase: true,
+			segment: 1,
+			rise: 1e3,
+			distanceUnit: "km",
+			elevationUnit: "m"
+		};
+	}
+	table() {
+		return this.gridTable(SurfaceField.from(this.options.data));
+	}
+	build(ctx) {
+		const { form, climbs, contours, solidBase, segment, rise, distanceUnit, elevationUnit } = this.options;
+		const curtain = form === "route-curtain", { theme, palette } = ctx;
+		const field = SurfaceField.from(this.options.data).capped(110);
+		const bottom = FLOOR + (solidBase && !curtain ? .2 : .02);
+		const space = new SurfaceSpace(field, ScaleKind.Linear, [bottom, bottom + .85]), grid = new FieldGrid(field, space);
+		const [low, high] = field.zDomain, [x0, x1] = field.xDomain, [y0, y1] = field.yDomain;
+		const ground = new ColorRamp(interpolateRgb(theme.grid, theme.axis));
+		const shade = (value) => ground.at((value - low) / (high - low));
+		const whole = (value) => `${Math.round(value).toLocaleString("en")} ${elevationUnit}`, far = (value) => `${tenth(value)} ${distanceUnit}`;
+		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: this.ticks(field.zDomain, space.level, 3)
+		}, { bottom: FLOOR });
+		const lift = this.rise(ctx);
+		this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => shade(field.at(i, j))), lift, (k) => {
+			const i = k % field.nx, j = Math.floor(k / field.nx);
+			return { rows: [
+				["Elevation", whole(field.at(i, j))],
+				["East", far(field.x[i])],
+				["North", far(field.y[j])]
+			] };
+		}, curtain ? {
+			roughness: .85,
+			transparent: true,
+			opacity: .4,
+			depthWrite: false
+		} : { roughness: .85 });
+		if (!field.hasData) return;
+		if (solidBase && !curtain) this.skirt(ctx, space, () => ctx.color(theme.grid), lift);
+		if (contours) this.contourLines(ctx, space, lift, 7);
+		const steps = TerrainRouteMath.profile(grid, this.options.data?.route), length = segment > 0 ? segment : 1;
+		const segments = TerrainRouteMath.grade(steps, length, rise);
+		const laid = steps.map((step) => ({
+			step,
+			at: grid.at(step.x, step.y, .014)
+		})).filter(({ at }, k, all) => {
+			const before = all[k - 1]?.at;
+			return !before || (at[0] - before[0]) ** 2 + (at[1] - before[1]) ** 2 + (at[2] - before[2]) ** 2 > 1e-8;
+		});
+		if (laid.length < 2) return;
+		const tones = new Map(STEEP.map(({ steep, tone }) => [steep, ctx.color(palette.diverging(tone))]));
+		const tone = (k) => tones.get(laid[k].step.steep);
+		const told = (k) => {
+			const { step } = laid[Math.min(laid.length - 1, k)], part = segments[Math.min(segments.length - 1, Math.floor(step.distance / length))];
+			return {
+				title: `${far(step.distance)} along the route`,
+				rows: [["Elevation", whole(step.elevation)], ...part ? [["Gradient", `${tenth(part.grade)}%`]] : []]
+			};
+		};
+		const tube = new SurfaceMesh(new TubeBatch(.011, SIDES).add(laid.map(({ at }) => at), tone).geometry(), this.material({
+			side: 0,
+			roughness: .5
+		}));
+		tube.castShadow = true;
+		lift.add(tube);
+		this.casing(laid.map(({ at }) => at), .011, theme.ink, lift);
+		ctx.pick(tube, (vertex) => told(Math.floor(vertex / SIDES)));
+		if (curtain) this.solid(ctx, SurfaceGeometry.curtain(laid.map(({ at }) => at), FLOOR + .002, tone, tone), lift, (vertex) => told(vertex % laid.length));
+		this.rings(ctx, [laid[0].at], .034, () => ctx.color(theme.ink), lift, () => ({
+			title: "Start",
+			rows: [["Elevation", whole(laid[0].step.elevation)]]
+		}));
+		this.dots(ctx, [laid.at(-1).at], .03, () => ctx.color(theme.ink), lift, () => ({
+			title: "Finish",
+			rows: [["Distance", far(laid.at(-1).step.distance)], ["Elevation", whole(laid.at(-1).step.elevation)]]
+		}));
+		const points = steps.map((step) => [step.distance, step.elevation]);
+		const name = ({ category }) => category === null ? "Climb" : category === 0 ? "HC" : `Cat ${category}`;
+		const found = climbs ? ElevationMath.climbs(points, { rise }).sort((a, b) => b.gain - a.gain).slice(0, 3).sort((a, b) => a.to - b.to) : [];
+		const tip = (climb) => () => ({
+			title: name(climb),
+			rows: [
+				["Length", far(climb.length)],
+				["Gain", whole(climb.gain)],
+				["Mean gradient", `${tenth(climb.grade)}%`],
+				["Summit", whole(climb.end)]
+			]
+		});
+		const on = (distance) => {
+			const step = TerrainRouteMath.near(steps, distance);
+			return grid.at(step.x, step.y, .014);
+		};
+		this.dots(ctx, found.map((climb) => on(climb.from)), .02, () => ctx.color(theme.ink), lift, (k) => tip(found[k])());
+		this.pins(ctx, found.map((climb) => ({
+			at: on(climb.to),
+			text: `${name(climb)} · ${far(climb.length)} at ${tenth(climb.grade)}%`,
+			pick: tip(climb)
+		})), lift);
+		const used = new Set(laid.map(({ step }) => step.steep));
+		this.key(ctx, STEEP.filter(({ steep }) => used.has(steep)).map(({ label, tone: share }) => ({
+			label,
+			color: palette.diverging(share)
+		})));
+		ctx.label(`Total ascent ${whole(ElevationMath.ascent(points, 3))} over ${far(steps.at(-1).distance)}`, [
+			0,
+			CEIL + .16,
+			-1
+		], "ink", 11);
+	}
+};
+export { TerrainRoute3DChart, TerrainRoute3DForm };

package/dist/charts/threefields/TerrainRouteMath.js

@@ -0,0 +1,40 @@
+import { ElevationMath } from "../machinecharts/ElevationMath.js";
+// src/charts/threefields/TerrainRouteMath.ts
+/** Turns a route over an elevation grid into the profile a rider or a vehicle meets. Distances are in the grid's own units. */
+var TerrainRouteMath = class {
+	/**
+	* The route cut into pieces no longer than `cell` grid cells, each with its distance over the ground and the elevation
+	* under it. Points that repeat the one before, or that sit over a gap in the grid, are left out.
+	*/
+	static profile(grid, route, cell = .5) {
+		const track = (Array.isArray(route) ? route : []).map((point) => [+point?.[0], +point?.[1]]).filter(([x, y]) => Number.isFinite(x) && Number.isFinite(y));
+		const steps = [];
+		const add = (x, y) => {
+			const last = steps[steps.length - 1], elevation = grid.value(x, y), run = last ? Math.hypot(x - last.x, y - last.y) : 0;
+			if (Number.isFinite(elevation) && (!last || run > 0)) steps.push({
+				x,
+				y,
+				distance: (last?.distance ?? 0) + run,
+				elevation,
+				steep: 0
+			});
+		};
+		track.forEach(([x, y], k) => {
+			const [px, py] = track[k - 1] ?? [x, y], from = grid.index(px, py), to = grid.index(x, y);
+			const pieces = Math.max(1, Math.ceil(Math.max(Math.abs(to[0] - from[0]), Math.abs(to[1] - from[1])) / cell));
+			for (let piece = 1; piece <= pieces; piece++) add(px + (x - px) * piece / pieces, py + (y - py) * piece / pieces);
+		});
+		return steps;
+	}
+	/** Stretches of `length` with their mean gradient, and each step tagged with the class of the stretch it falls in. */
+	static grade(steps, length, rise = 1e3) {
+		const segments = ElevationMath.segments(steps.map((step) => [step.distance, step.elevation]), length, rise);
+		for (const step of steps) step.steep = segments[Math.min(segments.length - 1, Math.floor(step.distance / length))]?.steep ?? 0;
+		return segments;
+	}
+	/** The step nearest a distance along the route. */
+	static near(steps, distance) {
+		return steps.reduce((best, step) => !best || Math.abs(step.distance - distance) < Math.abs(best.distance - distance) ? step : best, void 0);
+	}
+};
+export { TerrainRouteMath };

package/dist/charts/threefields/ThreeFieldBase.js

@@ -0,0 +1,117 @@
+import { SurfaceBase } from "../threesurfaces/SurfaceBase.js";
+import { CEIL } from "../threesurfaces/SurfaceSpace.js";
+import { TubeBatch } from "../threesurfaces/TubeBatch.js";
+import { color } from "d3";
+import { BackSide, BoxGeometry, InstancedMesh, Mesh, MeshStandardMaterial, Object3D, TorusGeometry } from "three";
+// src/charts/threefields/ThreeFieldBase.ts
+var RAD = Math.PI / 180;
+/** Marks the field charts share: tags and pins that name a point, the ring that opens a path, a casing that parts a tube from the ground, and a colour key. */
+var ThreeFieldBase = class extends SurfaceBase {
+	/** A label on a plate of the surface colour, for text that can lie over any tone of the field. */
+	tag(ctx, text, at, parent) {
+		const plate = color(ctx.theme.surface);
+		Object.assign(ctx.label(text, at, "ink", 11, parent).element.style, {
+			background: plate ? `${plate.copy({ opacity: .82 })}` : "",
+			padding: "1px 5px",
+			borderRadius: "4px"
+		});
+	}
+	/**
+	* A ball on each point, with a post up to its tag. A post grows until its tag clears the ones before it, as seen from
+	* where the camera starts; text is taken as 6.2px a character.
+	*/
+	pins(ctx, pins, parent) {
+		const { azimuth = 38, elevation = 26, distance = 5.4 } = this.options;
+		const turn = azimuth * RAD, tilt = elevation * RAD, unit = this.size.height / (2 * distance * Math.tan(19 * RAD));
+		const placed = [];
+		for (const { at, text, pick } of pins) {
+			if (!at.every(Number.isFinite)) continue;
+			const across = (at[0] * Math.cos(turn) - at[2] * Math.sin(turn)) * unit, half = (text.length * 6.2 + 12) / 2;
+			const up = (rise) => ((at[1] + rise) * Math.cos(tilt) - (at[0] * Math.sin(turn) + at[2] * Math.cos(turn)) * Math.sin(tilt)) * unit;
+			let rise = .17;
+			while (rise < .6 && placed.some((tag) => Math.abs(tag.across - across) < tag.half + half && Math.abs(tag.up - up(rise)) < 20)) rise += .04;
+			placed.push({
+				across,
+				up: up(rise),
+				half
+			});
+			const top = [
+				at[0],
+				at[1] + rise,
+				at[2]
+			];
+			this.tubes(new TubeBatch(.003).add([at, top]), parent, ctx.theme.ink);
+			this.dots(ctx, [at], .024, () => ctx.color(ctx.theme.ink), parent, pick);
+			this.tag(ctx, text, [
+				top[0],
+				top[1] + .055,
+				top[2]
+			], parent);
+		}
+	}
+	/** A second skin around a tube, seen only past its edges: the 3D form of the ring that parts a mark from what lies behind it. */
+	casing(path, radius, color, parent) {
+		const batch = new TubeBatch(radius * 1.5).add(path);
+		if (!batch.empty) parent.add(new Mesh(batch.geometry(), this.material({
+			vertexColors: false,
+			side: BackSide,
+			color,
+			roughness: 1
+		})));
+	}
+	/** Flat rings on one instanced mesh, for the points where paths begin. */
+	rings(ctx, points, radius, paint, parent, pick) {
+		const shown = points.map((point, k) => ({
+			point,
+			k
+		})).filter(({ point }) => point.every(Number.isFinite));
+		if (!shown.length) return;
+		const mesh = new InstancedMesh(new TorusGeometry(1, .3, 8, 28).rotateX(Math.PI / 2), new MeshStandardMaterial({ roughness: .45 }), shown.length);
+		const dummy = new Object3D();
+		shown.forEach(({ point, k }, at) => {
+			dummy.position.set(...point);
+			dummy.scale.setScalar(radius);
+			dummy.updateMatrix();
+			mesh.setMatrixAt(at, dummy.matrix);
+			mesh.setColorAt(at, paint(k));
+		});
+		mesh.castShadow = true;
+		parent.add(mesh);
+		if (pick) ctx.pick(mesh, (at) => pick(shown[at].k));
+	}
+	/** Colour key: a chip per class stacked beside the far right edge of the box, first entry lowest, each with its label to the right. */
+	key(ctx, entries) {
+		if (!entries.length) return;
+		const chips = new InstancedMesh(new BoxGeometry(.08, .08, .08), new MeshStandardMaterial({ roughness: .6 }), entries.length);
+		const dummy = new Object3D();
+		entries.forEach(({ label, color }, k) => {
+			const y = CEIL - (entries.length - 1 - k) * .15;
+			dummy.position.set(1.14, y, -1);
+			dummy.updateMatrix();
+			chips.setMatrixAt(k, dummy.matrix);
+			chips.setColorAt(k, ctx.color(color));
+			ctx.label(label, [
+				1.23,
+				y,
+				-1
+			], "muted", 10).center.set(0, .5);
+		});
+		ctx.root.add(chips);
+	}
+	/** One row per grid node, for CSV and keyboard access. */
+	gridTable(field) {
+		return {
+			columns: [
+				"x",
+				"y",
+				"z"
+			],
+			rows: Array.from({ length: field.ny }, (_, j) => Array.from({ length: field.nx }, (_, i) => [
+				field.x[i],
+				field.y[j],
+				field.at(i, j)
+			])).flat()
+		};
+	}
+};
+export { ThreeFieldBase };

package/dist/charts/threefields/ThreeFieldsSamples.js

@@ -0,0 +1,80 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/threefields/ThreeFieldsSamples.ts
+var HILLS = [
+	[
+		8,
+		6,
+		520,
+		4.2
+	],
+	[
+		14,
+		16,
+		760,
+		5
+	],
+	[
+		22,
+		8,
+		640,
+		4.6
+	],
+	[
+		25,
+		19,
+		880,
+		5.5
+	],
+	[
+		5,
+		19,
+		420,
+		3.8
+	],
+	[
+		17,
+		3,
+		300,
+		3.5
+	]
+];
+var WAYPOINTS = [
+	[2, 2],
+	[7, 9],
+	[12.5, 14],
+	[16.5, 11],
+	[20, 13.5],
+	[22.5, 17.5],
+	[25, 19]
+];
+var spline = (a, b, c, d, t) => .5 * (2 * b + (c - a) * t + (2 * a - 5 * b + 4 * c - d) * t * t + (3 * b - a - 3 * c + d) * t ** 3);
+/** Invented data for the field charts, seeded through `SampleData.rng`. No real place. */
+var ThreeFieldsSamples = class {
+	/** A 30 by 24 km block of hill country in metres, on a grid in km, with a road that crosses a shoulder and finishes on the highest summit. */
+	static terrainRoute(seed) {
+		const { u } = SampleData.rng(seed);
+		const hills = HILLS.map(([east, north, rise, width]) => [
+			east + (u() - .5) * 2,
+			north + (u() - .5) * 2,
+			rise * (.8 + u() * .4),
+			width * (.9 + u() * .25)
+		]);
+		const phase = u() * 6;
+		const x = Array.from({ length: 61 }, (_, i) => i * .5), y = Array.from({ length: 49 }, (_, j) => j * .5);
+		const ground = (east, north) => 420 + 4 * east + 6 * north + 24 * Math.sin(.8 * east + phase) * Math.cos(.7 * north) + hills.reduce((sum, [cx, cy, rise, width]) => sum + rise * Math.exp(-(((east - cx) ** 2 + (north - cy) ** 2) / width ** 2)), 0);
+		const summit = hills[3];
+		const via = WAYPOINTS.map(([east, north], k) => k === WAYPOINTS.length - 1 ? [summit[0], summit[1]] : [east + (u() - .5) * 1.2, north + (u() - .5) * 1.2]);
+		const knot = (k) => via[Math.max(0, Math.min(via.length - 1, k))];
+		const route = Array.from({ length: (via.length - 1) * 12 + 1 }, (_, step) => {
+			const k = Math.min(via.length - 2, Math.floor(step / 12)), t = step / 12 - k;
+			return [0, 1].map((axis) => +spline(knot(k - 1)[axis], knot(k)[axis], knot(k + 1)[axis], knot(k + 2)[axis], t).toFixed(2));
+		});
+		return {
+			x,
+			y,
+			z: y.map((north) => x.map((east) => Math.round(ground(east, north)))),
+			route
+		};
+	}
+};
+export { ThreeFieldsSamples };

package/dist/charts/threefields/WaferMap3DChart.js

@@ -0,0 +1,218 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ReliabilitySamples } from "../reliabilitycharts/ReliabilitySamples.js";
+import { WaferMap } from "../reliabilitycharts/WaferMap.js";
+import { Marks3D } from "../threebars/Marks3D.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { BoxGeometry, CylinderGeometry, DoubleSide, ExtrudeGeometry, Mesh, Shape, Vector2 } from "three";
+// src/charts/threefields/WaferMap3DChart.ts
+/** `Value` raises and colours each die by a measurement. `Bin` lays flat tiles coloured by test bin. */
+var WaferMap3DEncoding = /* @__PURE__ */ function(WaferMap3DEncoding) {
+	WaferMap3DEncoding["Value"] = "value-height";
+	WaferMap3DEncoding["Bin"] = "bin-tiles";
+	return WaferMap3DEncoding;
+}({});
+/** The orientation mark on the wafer's edge. */
+var WaferMap3DMark = /* @__PURE__ */ function(WaferMap3DMark) {
+	WaferMap3DMark["Notch"] = "notch";
+	WaferMap3DMark["Flat"] = "flat";
+	return WaferMap3DMark;
+}({});
+/** `Fitted` spends the whole height on the spread between the lowest and highest die, `Zero` grows every die from 0. */
+var WaferMap3DBaseline = /* @__PURE__ */ function(WaferMap3DBaseline) {
+	WaferMap3DBaseline["Fitted"] = "fitted-base";
+	WaferMap3DBaseline["Zero"] = "zero-base";
+	return WaferMap3DBaseline;
+}({});
+var RADIUS = .98;
+var TOP = -.32;
+var SLAB = .035;
+var TALLEST = .62;
+var ZONES = [
+	"Centre",
+	"Middle",
+	"Edge"
+];
+var percent = (good, total) => total ? `${(100 * good / total).toFixed(1)}%` : "n/a";
+var figure = (value) => `${+value.toPrecision(4)}`;
+/**
+* A wafer with each die raised by a measurement, so a tilt, a bowl or an edge roll-off across the wafer shows as relief.
+* Use it for parametric data; for pass and fail the flat bin tiles, or the 2D wafer map of the same rows, read more plainly.
+*/
+var WaferMap3DChart = class WaferMap3DChart extends ThreeFieldBase {
+	static meta = {
+		id: "wafer-map-3d",
+		name: "3D wafer map",
+		family: ChartFamily.Matrix,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Stands the dies of a semiconductor wafer on a notched disc as boxes whose height and colour show a measured value, or as flat tiles coloured by test bin, with the yield. The sample wafer is invented.",
+		tags: [
+			"wafer",
+			"semiconductor",
+			"die",
+			"yield",
+			"bin map",
+			"probe",
+			"parametric"
+		],
+		sample: (seed) => ReliabilitySamples.wafer(seed),
+		variants: {
+			encoding: Object.values(WaferMap3DEncoding),
+			mark: Object.values(WaferMap3DMark),
+			baseline: Object.values(WaferMap3DBaseline),
+			zones: [false, true]
+		},
+		valid: ({ encoding, baseline }) => encoding === "value-height" || baseline === "fitted-base"
+	};
+	defaults() {
+		return {
+			azimuth: 24,
+			elevation: 40,
+			distance: 4.3,
+			x: "x",
+			y: "y",
+			bin: "bin",
+			value: "value",
+			passBin: "Pass",
+			encoding: "value-height",
+			mark: "notch",
+			baseline: "fitted-base",
+			zones: false
+		};
+	}
+	/** Dies, wafer radius in die pitches and yield, exactly as the 2D wafer map counts them. */
+	summary() {
+		const { data, x, y, bin, value, passBin } = this.options;
+		return new WaferMap({
+			data,
+			x,
+			y,
+			bin,
+			value,
+			passBin
+		}).summary();
+	}
+	table() {
+		const { x, y, bin, value } = this.options;
+		return {
+			columns: [
+				x,
+				y,
+				bin,
+				value
+			],
+			rows: this.summary().dies.map((die) => [
+				die.x,
+				die.y,
+				die.bin,
+				die.value
+			])
+		};
+	}
+	/**
+	* The wafer's edge as a polygon around the origin, with the orientation mark towards +y: a V notch, or a flat no
+	* nearer the centre than `floor`, the outermost die edge on that side.
+	*/
+	static outline(radius, mark, floor = 0, steps = 96) {
+		const flat = mark === "flat", depth = radius * .06;
+		const chord = Math.min(radius * .995, Math.max(radius * .93, floor + radius * .01));
+		const gap = flat ? Math.acos(chord / radius) : Math.asin(depth * .8 / radius);
+		const arc = Array.from({ length: steps + 1 }, (_, k) => {
+			const angle = Math.PI / 2 + gap + (2 * Math.PI - 2 * gap) * k / steps;
+			return [radius * Math.cos(angle), radius * Math.sin(angle)];
+		});
+		return flat ? arc : [...arc, [0, radius - depth]];
+	}
+	build(ctx) {
+		const { encoding, mark, baseline, zones, bin, value } = this.options, { theme, palette } = ctx;
+		const { dies, centre, radius, good, zones: rings } = this.summary();
+		if (!dies.length) return;
+		const pitch = RADIUS / radius, side = pitch * .9, byValue = encoding === "value-height";
+		const values = dies.map((die) => die.value).filter((v) => v !== null);
+		const low = Math.min(...values), high = Math.max(...values), spread = high - low || 1;
+		const zero = baseline === "zero-base", from = zero ? Math.min(0, low) : low, to = zero ? Math.max(0, high) : high;
+		const level = (v) => TOP + (zero ? 0 : .03) + (v - from) / (to - from || 1) * (TALLEST - (zero ? 0 : .03));
+		const counts = /* @__PURE__ */ new Map();
+		for (const die of dies) counts.set(die.bin, (counts.get(die.bin) ?? 0) + 1);
+		if (!byValue) [...counts].sort((a, b) => b[1] - a[1]).forEach(([name]) => palette.color(name || "Unbinned"));
+		const tiles = dies.map((die) => {
+			const measured = byValue && die.value !== null;
+			return {
+				die,
+				x: (die.x - centre[0]) * pitch,
+				z: (die.y - centre[1]) * pitch,
+				from: measured && zero ? level(0) : TOP,
+				to: measured ? level(die.value) : TOP + (byValue ? .012 : .03),
+				color: byValue ? die.value === null ? theme.grid : palette.sequential((die.value - low) / spread) : palette.color(die.bin || "Unbinned")
+			};
+		});
+		Marks3D.instanced(ctx, new BoxGeometry(1, 1, 1), tiles, {
+			place: (dummy, tile, progress) => {
+				const tall = Math.max(.004, Math.abs(tile.to - tile.from) * progress);
+				dummy.position.set(tile.x, tile.from + (tile.to < tile.from ? -tall : tall) / 2, tile.z);
+				dummy.scale.set(side, tall, side);
+			},
+			color: (tile) => tile.color,
+			tip: ({ die, color }) => ({
+				title: `Die ${die.x}, ${die.y}`,
+				color,
+				rows: [
+					[bin, die.bin || "n/a"],
+					...die.value === null ? [] : [[value, figure(die.value)]],
+					["Ring", ZONES[Math.min(2, Math.floor(die.reach * 3))]]
+				]
+			})
+		});
+		const floor = Math.max(0, ...tiles.map((tile) => tile.z + pitch / 2));
+		const shape = new Shape(WaferMap3DChart.outline(RADIUS, mark, floor).map(([x, y]) => new Vector2(x, y)));
+		const disc = new Mesh(new ExtrudeGeometry(shape, {
+			depth: SLAB,
+			bevelEnabled: false
+		}).rotateX(Math.PI / 2).translate(0, TOP, 0), Marks3D.matte({ color: theme.grid }));
+		disc.receiveShadow = true;
+		ctx.root.add(disc);
+		const crest = Math.max(...tiles.map((tile) => Math.max(tile.from, tile.to)));
+		if (zones) {
+			const tall = crest - TOP + .035;
+			for (const share of [1 / 3, 2 / 3]) {
+				const fence = new Mesh(new CylinderGeometry(share * RADIUS, share * RADIUS, tall, 72, 1, true).translate(0, TOP + tall / 2, 0), Marks3D.matte({
+					color: theme.ink,
+					transparent: true,
+					opacity: .22,
+					depthWrite: false,
+					side: DoubleSide
+				}));
+				ctx.root.add(fence);
+			}
+			ctx.label(rings.map((ring) => `${ring.name} ${percent(ring.good, ring.total)}`).join(" · "), [
+				0,
+				-.42000000000000004,
+				1.38
+			], "secondary", 11);
+		}
+		if (byValue && values.length > 1 && high > low) {
+			const peak = tiles.find((tile) => tile.die.value === high), trough = tiles.find((tile) => tile.die.value === low);
+			this.pins(ctx, [{
+				at: [
+					peak.x,
+					peak.to,
+					peak.z
+				],
+				text: `Highest ${figure(high)}`
+			}, {
+				at: [
+					trough.x,
+					trough.to,
+					trough.z
+				],
+				text: `Lowest ${figure(low)}`
+			}], ctx.root);
+		}
+		ctx.label(`Yield ${percent(good, dies.length)} · ${good} of ${dies.length} dies`, [
+			0,
+			-.42000000000000004,
+			1.2
+		], "ink", 11);
+	}
+};
+export { WaferMap3DBaseline, WaferMap3DChart, WaferMap3DEncoding, WaferMap3DMark };

package/dist/charts/threefields/index.js

@@ -0,0 +1,19 @@
+import { MapSheet } from "./MapSheet.js";
+import { ThreeFieldBase } from "./ThreeFieldBase.js";
+import { BsfcMap3DBoundary, BsfcMap3DChart, BsfcMap3DContours, BsfcMap3DOptimum } from "./BsfcMap3DChart.js";
+import { CompressorMap3DChart, CompressorMap3DSurge } from "./CompressorMap3DChart.js";
+import { FieldGrid } from "./FieldGrid.js";
+import { LossLandscape3DChart, LossLandscape3DTrail } from "./LossLandscape3DChart.js";
+import { TerrainRouteMath } from "./TerrainRouteMath.js";
+import { ThreeFieldsSamples } from "./ThreeFieldsSamples.js";
+import { TerrainRoute3DChart, TerrainRoute3DForm } from "./TerrainRoute3DChart.js";
+import { WaferMap3DBaseline, WaferMap3DChart, WaferMap3DEncoding, WaferMap3DMark } from "./WaferMap3DChart.js";
+// src/charts/threefields/index.ts
+var threefieldsCatalog = [
+	LossLandscape3DChart,
+	CompressorMap3DChart,
+	BsfcMap3DChart,
+	TerrainRoute3DChart,
+	WaferMap3DChart
+];
+export { BsfcMap3DBoundary, BsfcMap3DChart, BsfcMap3DContours, BsfcMap3DOptimum, CompressorMap3DChart, CompressorMap3DSurge, FieldGrid, LossLandscape3DChart, LossLandscape3DTrail, MapSheet, TerrainRoute3DChart, TerrainRoute3DForm, TerrainRouteMath, ThreeFieldBase, ThreeFieldsSamples, WaferMap3DBaseline, WaferMap3DChart, WaferMap3DEncoding, WaferMap3DMark, threefieldsCatalog };