@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/threesurfaces/SurfaceGeometry.js

@@ -0,0 +1,121 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+import { mergeGeometries } from "three/addons/utils/BufferGeometryUtils.js";
+// src/charts/threesurfaces/SurfaceGeometry.ts
+/** Builders for the triangle soups the surface charts share. */
+var SurfaceGeometry = class SurfaceGeometry {
+	/** `nx × ny` vertex lattice. A vertex with a non-finite coordinate is a hole and its triangles are skipped. */
+	static grid(nx, ny, place, paint, wrap = {}) {
+		const positions = new Float32Array(nx * ny * 3), colors = new Float32Array(nx * ny * 3), solid = new Uint8Array(nx * ny);
+		for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+			const point = place(i, j), k = i + j * nx;
+			if (!point.every(Number.isFinite)) continue;
+			solid[k] = 1;
+			positions.set(point, k * 3);
+			const color = paint(i, j);
+			colors.set([
+				color.r,
+				color.g,
+				color.b
+			], k * 3);
+		}
+		const indices = [];
+		const cellsX = wrap.x ? nx : nx - 1, cellsY = wrap.y ? ny : ny - 1;
+		for (let j = 0; j < cellsY; j++) for (let i = 0; i < cellsX; i++) {
+			const a = i + j * nx, b = (i + 1) % nx + j * nx, c = i + (j + 1) % ny * nx, d = (i + 1) % nx + (j + 1) % ny * nx;
+			if (solid[a] && solid[b] && solid[d]) indices.push(a, d, b);
+			if (solid[a] && solid[d] && solid[c]) indices.push(a, c, d);
+		}
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.setIndex(indices);
+		geometry.computeVertexNormals();
+		return geometry;
+	}
+	/** Split shared vertices so each triangle shades flat. `userData.source` keeps the way back to the grid for picking. */
+	static faceted(geometry) {
+		const source = Uint32Array.from(geometry.getIndex()?.array ?? []);
+		const flat = geometry.toNonIndexed();
+		flat.computeVertexNormals();
+		flat.userData.source = source;
+		return flat;
+	}
+	/** Vertical wall hanging from a polyline to `base`, with colours for its top and bottom edges. */
+	static curtain(top, base, upper, lower) {
+		const floor = typeof base === "number" ? () => base : base;
+		const finite = top.map((point) => point.every(Number.isFinite));
+		return SurfaceGeometry.grid(top.length, 2, (k, row) => finite[k] ? row ? top[k] : [
+			top[k][0],
+			floor(k),
+			top[k][2]
+		] : [
+			NaN,
+			NaN,
+			NaN
+		], (k, row) => row ? upper(k) : lower(k));
+	}
+	/** A curtain with thickness along `(dx, dz)`: front, back and lid. */
+	static slab(top, [dx, dz], base, upper, lower) {
+		const shift = (sign) => top.map(([x, y, z]) => [
+			x + dx * sign / 2,
+			y,
+			z + dz * sign / 2
+		]);
+		const front = shift(1), back = shift(-1);
+		const lid = SurfaceGeometry.grid(top.length, 2, (k, row) => (row ? back : front)[k], upper);
+		const ends = [0, top.length - 1].map((k) => {
+			const floor = typeof base === "number" ? base : base(k);
+			const wall = (point) => [[
+				point[0],
+				floor,
+				point[2]
+			], point];
+			return SurfaceGeometry.grid(2, 2, (i, row) => wall((i ? back : front)[k])[row], (_, row) => row ? upper(k) : lower(k));
+		});
+		return SurfaceGeometry.merge([
+			SurfaceGeometry.curtain(front, base, upper, lower),
+			SurfaceGeometry.curtain(back, base, upper, lower),
+			lid,
+			...ends
+		]);
+	}
+	/** Drop vertices no triangle uses. `userData.source` maps the survivors back to their original index. */
+	static compact(geometry) {
+		const index = geometry.getIndex();
+		const source = [...new Set(index.array)], renumber = new Map(source.map((vertex, k) => [vertex, k]));
+		const out = new BufferGeometry();
+		for (const name of Object.keys(geometry.attributes)) {
+			const attribute = geometry.getAttribute(name), size = attribute.itemSize;
+			const values = new Float32Array(source.length * size);
+			source.forEach((vertex, k) => {
+				for (let c = 0; c < size; c++) values[k * size + c] = attribute.array[vertex * size + c];
+			});
+			out.setAttribute(name, new Float32BufferAttribute(values, size));
+		}
+		out.setIndex(Array.from(index.array, (vertex) => renumber.get(vertex)));
+		out.userData.source = Uint32Array.from(source);
+		return out;
+	}
+	/** Give a three.js primitive the uniform vertex colour that lets it merge with painted geometry. */
+	static tinted(geometry, color) {
+		const count = geometry.getAttribute("position").count;
+		const colors = new Float32Array(count * 3);
+		for (let k = 0; k < count; k++) colors.set([
+			color.r,
+			color.g,
+			color.b
+		], k * 3);
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.deleteAttribute("uv");
+		return geometry;
+	}
+	static merge(parts) {
+		const unified = parts.filter((part) => part.getAttribute("position").count).map((part) => part.index ? part : indexed(part));
+		return (unified.length ? mergeGeometries(unified) : null) ?? new BufferGeometry();
+	}
+};
+function indexed(geometry) {
+	geometry.setIndex(Array.from({ length: geometry.getAttribute("position").count }, (_, k) => k));
+	return geometry;
+}
+export { SurfaceGeometry };

package/dist/charts/threesurfaces/SurfaceMesh.js

@@ -0,0 +1,24 @@
+import { Mesh } from "three";
+// src/charts/threesurfaces/SurfaceMesh.ts
+/**
+* Mesh whose hits report the nearest vertex as `instanceId`, which is what `ctx.pick` receives,
+* so one continuous surface gets per-point tooltips without a lattice of invisible proxies.
+*/
+var SurfaceMesh = class extends Mesh {
+	raycast(raycaster, hits) {
+		const start = hits.length;
+		super.raycast(raycaster, hits);
+		const source = this.geometry.userData.source;
+		for (const hit of hits.slice(start)) {
+			if (!hit.face) continue;
+			const { x, y, z } = hit.barycoord ?? {
+				x: 1,
+				y: 0,
+				z: 0
+			};
+			const vertex = x >= y && x >= z ? hit.face.a : y >= z ? hit.face.b : hit.face.c;
+			hit.instanceId = source?.[vertex] ?? vertex;
+		}
+	}
+};
+export { SurfaceMesh };

package/dist/charts/threesurfaces/SurfaceSpace.js

@@ -0,0 +1,70 @@
+import { ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { scaleSymlog } from "d3";
+// src/charts/threesurfaces/SurfaceSpace.ts
+var FLOOR = -.7;
+var CEIL = .75;
+/** Maps grid indices to world space: data x → world x, data y → world depth, data z → world height. */
+var SurfaceSpace = class SurfaceSpace {
+	field;
+	range;
+	level;
+	constructor(field, kind = ScaleKind.Linear, range = [FLOOR, CEIL], domain = field.zDomain) {
+		this.field = field;
+		this.range = range;
+		this.level = SurfaceSpace.height(kind, domain, range);
+	}
+	/** Height scale. Log becomes symlog so zero and negative heights stay on the chart. */
+	static height(kind, [lo, hi], range) {
+		return (kind === ScaleKind.Log || kind === ScaleKind.Symlog ? scaleSymlog().constant(Math.max(hi - lo, 1e-9) / 8) : Scales.continuous(kind)).domain([lo, hi]).range(range);
+	}
+	/** Position of a fractional index along a possibly uneven axis, 0..1. */
+	fraction(axis, index) {
+		const i = Math.max(0, Math.min(axis.length - 2, Math.floor(index)));
+		const span = axis.at(-1) - axis[0] || 1;
+		return (axis[i] + (axis[i + 1] - axis[i]) * (index - i) - axis[0]) / span;
+	}
+	/** World x and z of a fractional grid index. */
+	ground(fi, fj) {
+		return [this.fraction(this.field.x, fi) * 2 - 1, 1 - this.fraction(this.field.y, fj) * 2];
+	}
+	at(fi, fj, lift = 0) {
+		const [x, z] = this.ground(fi, fj);
+		return [
+			x,
+			this.level(this.field.sample(fi, fj)) + lift,
+			z
+		];
+	}
+	floor(fi, fj, lift = 0) {
+		const [x, z] = this.ground(fi, fj);
+		return [
+			x,
+			this.range[0] + lift,
+			z
+		];
+	}
+};
+/** Wraps the grid around an annulus: x sweeps the angle, y runs out along the radius. */
+var PolarSurfaceSpace = class extends SurfaceSpace {
+	sweep;
+	inner;
+	swap;
+	constructor(field, kind, sweep, inner, swap = false) {
+		super(field, kind);
+		this.sweep = sweep;
+		this.inner = inner;
+		this.swap = swap;
+	}
+	polar(angle, radius) {
+		const a = ((angle - .5) * this.sweep - 90) * (Math.PI / 180);
+		return [Math.cos(a) * radius, Math.sin(a) * radius];
+	}
+	ground(fi, fj) {
+		const { x, y } = this.field;
+		const angular = this.swap ? y : x, radial = this.swap ? x : y;
+		const turn = this.fraction(angular, this.swap ? fj : fi) * (this.sweep === 360 ? (angular.length - 1) / angular.length : 1);
+		return this.polar(turn, this.inner + (1 - this.inner) * this.fraction(radial, this.swap ? fi : fj));
+	}
+};
+export { CEIL, FLOOR, PolarSurfaceSpace, SurfaceSpace };

package/dist/charts/threesurfaces/TerrainChart.js

@@ -0,0 +1,202 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ColorRamp } from "./ColorRamp.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { SurfaceField } from "./SurfaceField.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { CEIL, FLOOR, SurfaceSpace } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+import { BoxGeometry, CircleGeometry, Mesh, MeshStandardMaterial, PlaneGeometry } from "three";
+// src/charts/threesurfaces/TerrainChart.ts
+var TerrainBase = /* @__PURE__ */ function(TerrainBase) {
+	TerrainBase["Block"] = "block";
+	TerrainBase["Strata"] = "strata";
+	TerrainBase["Sheet"] = "sheet";
+	TerrainBase["Island"] = "island";
+	return TerrainBase;
+}({});
+var SEA = .3;
+var BEDROCK = .2;
+/** Layered ridged noise from three seeded sample surfaces. */
+function ridges(seed, n) {
+	const octaves = [
+		0,
+		1,
+		2
+	].map((k) => SurfaceField.from(SampleData.surface(seed + k * 2.3, n)));
+	const fold = (t) => {
+		const m = t % 2;
+		return m > 1 ? 2 - m : m;
+	};
+	const axis = Array.from({ length: n }, (_, i) => i / (n - 1));
+	const z = axis.map((v) => axis.map((u) => octaves.reduce((sum, octave, k) => {
+		const scale = 2 ** k, read = octave.sample(fold(u * scale * .9 + .05 * k) * (n - 1), fold(v * scale * .9 + .08 * k) * (n - 1));
+		return sum + (k ? .5 - Math.abs(read) * 1.6 : read * 1.5 + .4) / scale ** 1.8;
+	}, 0)));
+	return {
+		x: axis.map((t) => t * 100),
+		y: axis.map((t) => t * 100),
+		z
+	};
+}
+/** Elevation model as a physical object: for landscapes, bathymetry and any real height map worth showing in relief. */
+var TerrainChart = class extends GridSurfaceBase {
+	static meta = {
+		id: "terrain-3d",
+		name: "Terrain",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Renders an elevation grid as a landscape, cut as a block, a strata section, a sheet or an island, with water and drainage.",
+		tags: [
+			"dem",
+			"elevation",
+			"relief",
+			"block diagram",
+			"landscape"
+		],
+		sample: (seed) => ridges(seed, 96),
+		variants: {
+			base: [
+				"block",
+				"strata",
+				"sheet",
+				"island"
+			],
+			water: [true, false],
+			rivers: [true, false],
+			contours: [false, true],
+			relief: [1, .6]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			base: "block",
+			water: true,
+			rivers: true,
+			contours: false,
+			relief: 1
+		};
+	}
+	shaped() {
+		const field = this.field(110);
+		if (this.options.base !== "island" || !field.hasData) return field;
+		const { nx, ny, zMin, zMax } = field;
+		return field.map((z, i, j) => {
+			const u = i / (nx - 1) * 2 - 1, v = j / (ny - 1) * 2 - 1, r = Math.hypot(u, v), wobble = .82 + .1 * Math.sin(Math.atan2(v, u) * 5);
+			if (r > 1) return NaN;
+			const edge = Math.min(1, Math.max(0, (1 - r / wobble) * 3.2));
+			return zMin + (z - zMin) * edge * edge * (3 - 2 * edge) * (zMax > zMin ? 1 : 0);
+		});
+	}
+	/** D8: every cell drains to its lowest neighbour; cells that collect enough flow become channels. */
+	channels(space, batch) {
+		const { field } = space;
+		const coarse = field.capped(72), { nx, ny } = coarse;
+		const order = Array.from(coarse.z.keys()).filter((k) => !Number.isNaN(coarse.z[k])).sort((a, b) => coarse.z[b] - coarse.z[a]);
+		const flow = new Float64Array(nx * ny).fill(1), next = new Int32Array(nx * ny).fill(-1);
+		for (const k of order) {
+			const i = k % nx, j = Math.floor(k / nx);
+			let low = coarse.z[k], target = -1;
+			for (const dj of [
+				-1,
+				0,
+				1
+			]) for (const di of [
+				-1,
+				0,
+				1
+			]) {
+				const u = i + di, v = j + dj;
+				if (u < 0 || v < 0 || u >= nx || v >= ny) continue;
+				const value = coarse.z[u + v * nx];
+				if (value < low) {
+					low = value;
+					target = u + v * nx;
+				}
+			}
+			next[k] = target;
+			if (target >= 0) flow[target] += flow[k];
+		}
+		const threshold = nx * ny / 220, seen = new Uint8Array(nx * ny);
+		const sx = (field.nx - 1) / (nx - 1), sy = (field.ny - 1) / (ny - 1);
+		const main = order.filter((k) => flow[k] > threshold);
+		for (const start of main) {
+			if (seen[start]) continue;
+			const path = [];
+			let k = start;
+			while (k >= 0) {
+				path.push(space.at(k % nx * sx, Math.floor(k / nx) * sy, .008));
+				if (seen[k]) break;
+				seen[k] = 1;
+				k = next[k];
+			}
+			batch.add(path, void 0, .0016 + 22e-5 * Math.sqrt(flow[start]));
+		}
+	}
+	strata(ctx, space, lift) {
+		const { nx, ny } = space.field;
+		const edges = [
+			Array.from({ length: nx }, (_, i) => [i, 0]),
+			Array.from({ length: ny }, (_, j) => [nx - 1, j]),
+			Array.from({ length: nx }, (_, i) => [i, ny - 1]),
+			Array.from({ length: ny }, (_, j) => [0, j])
+		];
+		const beds = 4, gap = .008, top = space.range[0];
+		const parts = [];
+		edges.forEach((edge) => {
+			const crest = edge.map(([i, j]) => space.at(i, j));
+			for (let bed = 0; bed < beds; bed++) {
+				const color = ctx.color(ctx.palette.sequential(.28 + .16 * bed));
+				const depth = (k, share) => {
+					const y = crest[k][1];
+					return FLOOR + ((Number.isFinite(y) ? y : top) - FLOOR) * share;
+				};
+				const upper = (beds - bed) / beds, lower = (beds - bed - 1) / beds;
+				parts.push(SurfaceGeometry.curtain(crest.map(([x, _y, z], k) => [
+					x,
+					depth(k, upper) - (bed ? gap / 2 : 0),
+					z
+				]), (k) => depth(k, lower) + (bed < 3 ? gap / 2 : 0), () => color, () => color));
+			}
+		});
+		this.solid(ctx, SurfaceGeometry.merge(parts), lift);
+	}
+	build(ctx) {
+		const { base, water, rivers, contours, relief } = this.options;
+		const field = this.shaped();
+		const bottom = FLOOR + (base === "block" || base === "strata" ? BEDROCK : .02);
+		const space = new SurfaceSpace(field, ScaleKind.Linear, [bottom, bottom + (CEIL - bottom) * relief]);
+		const [lo, hi] = field.zDomain, ramp = new ColorRamp(ctx.palette.sequential);
+		const tone = (value) => ramp.at(.1 + .8 * (value - lo) / (hi - lo));
+		this.box(ctx, this.axes(space), { walls: false });
+		const lift = this.rise(ctx);
+		this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => tone(field.at(i, j))), lift, this.gridTip(space), { roughness: .85 });
+		if (!field.hasData) return;
+		if (base === "block") this.skirt(ctx, space, () => ctx.color(ctx.palette.sequential(.3)), lift);
+		if (base === "strata") this.strata(ctx, space, lift);
+		const sea = field.zMin + (field.zMax - field.zMin) * SEA;
+		if (contours) this.contourLines(ctx, space, lift, 7);
+		if (rivers) {
+			const batch = new TubeBatch();
+			this.channels(space, batch);
+			this.tubes(batch, lift, ctx.theme.surface, .85);
+		}
+		if (water) this.flood(ctx, space, sea, lift);
+	}
+	flood(ctx, space, sea, lift) {
+		const y = space.level(sea);
+		const material = new MeshStandardMaterial({
+			color: ctx.palette.sequential(.55),
+			roughness: .25,
+			transparent: true,
+			opacity: .6,
+			depthWrite: false
+		});
+		const bed = this.options.base;
+		const body = bed === "island" ? new CircleGeometry(1, 72).rotateX(-Math.PI / 2).translate(0, y, 0) : bed === "sheet" ? new PlaneGeometry(2, 2).rotateX(-Math.PI / 2).translate(0, y, 0) : new BoxGeometry(1.996, y - FLOOR, 1.996).translate(0, (y + FLOOR) / 2, 0);
+		lift.add(new Mesh(body, material));
+	}
+};
+export { TerrainBase, TerrainChart };

package/dist/charts/threesurfaces/TriangulatedSurface.js

@@ -0,0 +1,252 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { short } from "./GridSurfaceBase.js";
+import { SurfaceBase } from "./SurfaceBase.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { SurfaceMesh } from "./SurfaceMesh.js";
+import { CEIL, FLOOR } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+import { extent, median, scaleLinear } from "d3";
+import { BufferGeometry, Float32BufferAttribute } from "three";
+import { Delaunay as Delaunay$1 } from "d3-delaunay";
+// src/charts/threesurfaces/TriangulatedSurface.ts
+var TriangulationMark = /* @__PURE__ */ function(TriangulationMark) {
+	TriangulationMark["Facets"] = "facets";
+	TriangulationMark["Smooth"] = "smooth";
+	TriangulationMark["Wire"] = "wire";
+	TriangulationMark["Cells"] = "voronoi-cells";
+	return TriangulationMark;
+}({});
+var TriangulationTrim = /* @__PURE__ */ function(TriangulationTrim) {
+	TriangulationTrim["Hull"] = "convex-hull";
+	TriangulationTrim["Alpha"] = "alpha-trim";
+	return TriangulationTrim;
+}({});
+/** A surface from scattered points with no grid: the honest form for irregular samples such as boreholes or sensors. */
+var TriangulatedSurface = class extends SurfaceBase {
+	static meta = {
+		id: "triangulated-surface",
+		name: "Triangulated surface",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Connects scattered x, y, z points with a Delaunay triangulation or Voronoi cells, without assuming a grid.",
+		tags: [
+			"tin",
+			"delaunay",
+			"voronoi",
+			"scattered",
+			"trisurf"
+		],
+		sample: (seed) => SampleData.points(seed, 260, 1).map((row) => {
+			const x = row.x, y = row.y - x * .8 - 10;
+			return {
+				x,
+				y: +y.toFixed(2),
+				value: +(Math.sin(x / 6) * Math.cos(y / 6) * 30 + row.size * .12).toFixed(2)
+			};
+		}),
+		variants: {
+			mark: [
+				"facets",
+				"smooth",
+				"wire",
+				"voronoi-cells"
+			],
+			trim: ["alpha-trim", "convex-hull"],
+			points: [true, false],
+			stems: [false, true]
+		},
+		valid: ({ mark, trim, stems, points }) => !(mark === "voronoi-cells" && trim === "convex-hull") && !(stems && !points)
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			x: "x",
+			y: "y",
+			z: "value",
+			mark: "facets",
+			trim: "alpha-trim",
+			points: true,
+			stems: false
+		};
+	}
+	build(ctx) {
+		const { data, x, y, z, mark, points, stems } = this.options;
+		const seen = /* @__PURE__ */ new Set();
+		const rows = (data ?? []).map((row) => ({
+			row,
+			x: +(row[x] ?? NaN),
+			y: +(row[y] ?? NaN),
+			z: +(row[z] ?? NaN)
+		})).filter((p) => Number.isFinite(p.x) && Number.isFinite(p.y) && Number.isFinite(p.z)).filter((p) => {
+			const key = `${p.x}|${p.y}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		const [x0 = 0, x1 = 1] = extent(rows, (p) => p.x), [y0 = 0, y1 = 1] = extent(rows, (p) => p.y), [z0 = 0, z1 = 1] = extent(rows, (p) => p.z);
+		const sx = scaleLinear([x0, x1 > x0 ? x1 : x0 + 1], [-1, 1]), sz = scaleLinear([y0, y1 > y0 ? y1 : y0 + 1], [1, -1]);
+		const zDomain = [z0, z1 > z0 ? z1 : z0 + 1], sy = scaleLinear(zDomain, [FLOOR, CEIL]);
+		const paint = this.painter(ctx, zDomain);
+		this.box(ctx, {
+			x: this.ticks(sx.domain(), sx),
+			y: this.ticks(sz.domain(), sz),
+			z: this.ticks(zDomain, sy, 3)
+		});
+		const lift = this.rise(ctx);
+		if (!rows.length) return;
+		const world = rows.map((p) => [
+			sx(p.x),
+			sy(p.z),
+			sz(p.y)
+		]);
+		const tip = (k) => {
+			const p = rows[Math.min(k, rows.length - 1)];
+			return { rows: [
+				[x, short(p.x)],
+				[y, short(p.y)],
+				[z, short(p.z)]
+			] };
+		};
+		if (rows.length >= 3) {
+			const delaunay = new Delaunay$1(Float64Array.from(world.flatMap(([a, , c]) => [a, c])));
+			if (mark === "voronoi-cells") this.cells(ctx, delaunay, world, rows.map((p) => p.z), paint, lift, tip);
+			else this.triangles(ctx, delaunay, world, rows.map((p) => p.z), paint, lift, tip);
+		}
+		if (points) this.dots(ctx, world, mark === "voronoi-cells" ? .012 : .016, () => ctx.color(ctx.theme.ink), lift, tip);
+		if (stems) {
+			const batch = new TubeBatch(.003, 4);
+			for (const [a, b, c] of world) batch.add([[
+				a,
+				b,
+				c
+			], [
+				a,
+				FLOOR,
+				c
+			]]);
+			this.tubes(batch, lift, ctx.theme.inkMuted, .7);
+		}
+	}
+	triangles(ctx, delaunay, world, values, paint, parent, tip) {
+		const { mark, trim } = this.options;
+		const edge = (a, b) => Math.hypot(world[a][0] - world[b][0], world[a][2] - world[b][2]);
+		const faces = [];
+		const lengths = [];
+		for (let t = 0; t < delaunay.triangles.length; t += 3) {
+			const [a, b, c] = [
+				delaunay.triangles[t],
+				delaunay.triangles[t + 1],
+				delaunay.triangles[t + 2]
+			];
+			faces.push([
+				a,
+				b,
+				c
+			]);
+			lengths.push(edge(a, b), edge(b, c), edge(c, a));
+		}
+		const limit = (median(lengths) ?? 1) * 2.6;
+		const kept = trim === "alpha-trim" ? faces.filter(([a, b, c]) => Math.max(edge(a, b), edge(b, c), edge(c, a)) < limit) : faces;
+		if (mark === "wire") {
+			const batch = new TubeBatch(.0048);
+			const drawn = /* @__PURE__ */ new Set();
+			for (const [a, b, c] of kept) for (const [p, q] of [
+				[a, b],
+				[b, c],
+				[c, a]
+			]) {
+				const key = p < q ? `${p}:${q}` : `${q}:${p}`;
+				if (drawn.has(key)) continue;
+				drawn.add(key);
+				batch.add([world[p], world[q]], (k) => paint(values[k ? q : p]));
+			}
+			this.tubes(batch, parent);
+			return;
+		}
+		const smooth = mark === "smooth";
+		const order = smooth ? Array.from(world.keys()) : kept.flat();
+		const painted = new BufferGeometry();
+		painted.setAttribute("position", new Float32BufferAttribute(order.flatMap((k) => world[k]), 3));
+		painted.setAttribute("color", new Float32BufferAttribute(order.flatMap((k) => {
+			const c = paint(values[k]);
+			return [
+				c.r,
+				c.g,
+				c.b
+			];
+		}), 3));
+		if (smooth) painted.setIndex(kept.flat());
+		const geometry = smooth && kept.length ? SurfaceGeometry.compact(painted) : painted;
+		geometry.computeVertexNormals();
+		if (!smooth) geometry.userData.source = Uint32Array.from(order);
+		const mesh = new SurfaceMesh(geometry, this.material());
+		mesh.castShadow = true;
+		parent.add(mesh);
+		ctx.pick(mesh, tip);
+	}
+	/** Each observation owns its Voronoi cell, drawn as a prism up to its height: nearest-neighbour honesty. */
+	cells(ctx, delaunay, world, values, paint, parent, tip) {
+		const voronoi = delaunay.voronoi([
+			-1,
+			-1,
+			1,
+			1
+		]);
+		const nearest = world.map(([ax, , az], k) => Math.min(...[...delaunay.neighbors(k)].map((other) => Math.hypot(world[other][0] - ax, world[other][2] - az)), Infinity));
+		const limit = (median(nearest.filter(Number.isFinite)) ?? 1) * 2.5;
+		const positions = [], colors = [], owners = [];
+		const push = (owner, ...points) => {
+			const c = paint(values[owner]);
+			for (const point of points) {
+				positions.push(...point);
+				colors.push(c.r, c.g, c.b);
+				owners.push(owner);
+			}
+		};
+		world.forEach(([cx, cy, cz], owner) => {
+			const polygon = voronoi.cellPolygon(owner);
+			if (!polygon) return;
+			const ring = polygon.slice(0, -1).map(([a, b]) => {
+				const reach = Math.hypot(a - cx, b - cz), shrink = (reach > limit ? limit / reach : 1) * .94;
+				return [cx + (a - cx) * shrink, cz + (b - cz) * shrink];
+			});
+			ring.forEach(([a, b], k) => {
+				const [c, d] = ring[(k + 1) % ring.length];
+				const p = [
+					a,
+					cy,
+					b
+				], q = [
+					c,
+					cy,
+					d
+				], r = [
+					a,
+					FLOOR,
+					b
+				];
+				push(owner, [
+					cx,
+					cy,
+					cz
+				], p, q, p, r, q, q, r, [
+					c,
+					FLOOR,
+					d
+				]);
+			});
+		});
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.computeVertexNormals();
+		geometry.userData.source = Uint32Array.from(owners);
+		const mesh = new SurfaceMesh(geometry, this.material());
+		mesh.castShadow = true;
+		parent.add(mesh);
+		ctx.pick(mesh, tip);
+	}
+};
+export { TriangulatedSurface, TriangulationMark, TriangulationTrim };