@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/threesurfaces/TubeBatch.js

@@ -0,0 +1,72 @@
+import { BufferGeometry, Color, Float32BufferAttribute, Vector3 } from "three";
+// src/charts/threesurfaces/TubeBatch.ts
+var WHITE = new Color(1, 1, 1);
+/** Scales every radius: below about 1.5px on screen a thin tube breaks into dashes. */
+var WEIGHT = 1.6;
+/** Many thin tubes in one mesh. WebGL lines are stuck at 1px and unlit; tubes hold their weight and shade like the surface they sit on. */
+var TubeBatch = class {
+	radius;
+	sides;
+	positions = [];
+	normals = [];
+	colors = [];
+	indices = [];
+	constructor(radius = .0065, sides = 5) {
+		this.radius = radius;
+		this.sides = sides;
+	}
+	/** Add a polyline. A non-finite point breaks it into separate runs. */
+	add(path, paint = WHITE, radius = this.radius) {
+		radius *= WEIGHT;
+		let run = [], first = 0;
+		const flush = (start) => {
+			if (run.length > 1) this.tube(run, start, paint, radius);
+			run = [];
+		};
+		path.forEach((point, k) => {
+			if (!point.every(Number.isFinite)) return flush(first);
+			const next = new Vector3(...point);
+			if (run.length && run.at(-1).distanceToSquared(next) < 1e-10) return;
+			if (!run.length) first = k;
+			run.push(next);
+		});
+		flush(first);
+		return this;
+	}
+	tube(run, start, paint, radius) {
+		const { sides } = this;
+		const base = this.positions.length / 3;
+		const tangent = new Vector3(), side = new Vector3(), up = new Vector3(), ring = new Vector3();
+		tangent.subVectors(run[1], run[0]).normalize();
+		side.set(Math.abs(tangent.y) > .9 ? 1 : 0, Math.abs(tangent.y) > .9 ? 0 : 1, 0);
+		run.forEach((point, k) => {
+			tangent.subVectors(run[Math.min(k + 1, run.length - 1)], run[Math.max(k - 1, 0)]).normalize();
+			side.addScaledVector(tangent, -side.dot(tangent)).normalize();
+			up.crossVectors(tangent, side);
+			const color = typeof paint === "function" ? paint(start + k) : paint;
+			for (let s = 0; s < sides; s++) {
+				const angle = s / sides * Math.PI * 2;
+				ring.copy(side).multiplyScalar(Math.cos(angle)).addScaledVector(up, Math.sin(angle));
+				this.positions.push(point.x + ring.x * radius, point.y + ring.y * radius, point.z + ring.z * radius);
+				this.normals.push(ring.x, ring.y, ring.z);
+				this.colors.push(color.r, color.g, color.b);
+			}
+		});
+		for (let k = 0; k < run.length - 1; k++) for (let s = 0; s < sides; s++) {
+			const a = base + k * sides + s, b = base + k * sides + (s + 1) % sides, c = a + sides, d = b + sides;
+			this.indices.push(a, b, c, b, d, c);
+		}
+	}
+	get empty() {
+		return !this.indices.length;
+	}
+	geometry() {
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(this.positions, 3));
+		geometry.setAttribute("normal", new Float32BufferAttribute(this.normals, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(this.colors, 3));
+		geometry.setIndex(this.indices);
+		return geometry;
+	}
+};
+export { TubeBatch };

package/dist/charts/threesurfaces/Waterfall3DSpectrum.js

@@ -0,0 +1,109 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { ShortTimeTransform, SpectrogramWindow } from "./ShortTimeTransform.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { FLOOR, SurfaceSpace } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+// src/charts/threesurfaces/Waterfall3DSpectrum.ts
+var SpectrumWaterfallMark = /* @__PURE__ */ function(SpectrumWaterfallMark) {
+	SpectrumWaterfallMark["Fins"] = "fins";
+	SpectrumWaterfallMark["Lines"] = "lines";
+	SpectrumWaterfallMark["Stems"] = "stems";
+	return SpectrumWaterfallMark;
+}({});
+var SpectrumAmplitude = /* @__PURE__ */ function(SpectrumAmplitude) {
+	SpectrumAmplitude["Linear"] = "linear";
+	SpectrumAmplitude["Decibel"] = "decibel";
+	return SpectrumAmplitude;
+}({});
+/** Stacked spectra running back in time: the classic view for machine vibration and audio, where one frame hides another. */
+var Waterfall3DSpectrum = class extends GridSurfaceBase {
+	static meta = {
+		id: "waterfall-3d-spectrum",
+		name: "3D waterfall spectrum",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Stacks successive spectra into depth so changes in frequency content over time form visible ridges.",
+		tags: [
+			"waterfall",
+			"spectrum",
+			"vibration",
+			"fft",
+			"cascade"
+		],
+		sample: (seed) => ShortTimeTransform.spectrogram(ShortTimeTransform.sampleSignal(seed).map((row) => row.value), 96, 12, SpectrogramWindow.Hann),
+		variants: {
+			mark: [
+				"fins",
+				"lines",
+				"stems"
+			],
+			scale: ["linear", "decibel"],
+			peakTrack: [true, false],
+			frames: [30, 18]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			mark: "fins",
+			scale: "linear",
+			peakTrack: true,
+			frames: 30,
+			elevation: 24
+		};
+	}
+	build(ctx) {
+		const { mark, scale, peakTrack, frames } = this.options;
+		const raw = this.field(128);
+		const peak = raw.hasData ? Math.max(Math.abs(raw.zMax), Math.abs(raw.zMin), 1e-12) : 1;
+		const field = scale === "decibel" ? raw.map((z) => Math.max(-48, 20 * Math.log10(Math.max(Math.abs(z) / peak, 1e-6)))) : raw;
+		const space = new SurfaceSpace(field, ScaleKind.Linear);
+		const zero = field.zDomain[0] < 0 && scale !== "decibel" ? space.level(0) : FLOOR;
+		const paint = this.painter(ctx, scale === "decibel" ? [0, 1] : field.zDomain);
+		const tone = (value) => paint(scale === "decibel" ? (value - field.zDomain[0]) / (field.zDomain[1] - field.zDomain[0]) : value);
+		this.box(ctx, this.axes(space));
+		const lift = this.rise(ctx);
+		const count = Math.min(field.ny, frames);
+		const order = Array.from({ length: count }, (_, k) => Math.round(k * (field.ny - 1) / Math.max(1, count - 1)));
+		const lines = new TubeBatch(.0048), stems = new TubeBatch(.0038);
+		const line = (j) => Array.from({ length: field.nx }, (_, i) => space.at(i, j));
+		const tip = this.gridTip(space);
+		for (const j of order) {
+			const top = line(j);
+			if (mark === "fins") {
+				const surface = ctx.color(ctx.theme.surface);
+				this.solid(ctx, SurfaceGeometry.curtain(top, zero, (k) => tone(field.at(k, j)).clone().lerp(surface, .12), () => surface), lift, (k) => tip(k % field.nx + j * field.nx), { roughness: .8 });
+			}
+			const quiet = field.zMin + (field.zMax - field.zMin) * .05;
+			const audible = top.map((point, k) => Math.max(field.at(k - 2, j), field.at(k - 1, j), field.at(k, j), field.at(k + 1, j), field.at(k + 2, j)) > quiet ? point : [
+				NaN,
+				NaN,
+				NaN
+			]);
+			if (mark !== "stems") lines.add(audible, (k) => tone(field.at(k, j)));
+			if (mark === "stems") {
+				for (let i = 0; i < field.nx; i += 2) if (field.at(i, j) > quiet) stems.add([top[i], [
+					top[i][0],
+					zero,
+					top[i][2]
+				]], tone(field.at(i, j)));
+			}
+		}
+		this.tubes(lines, lift);
+		this.tubes(stems, lift);
+		if (peakTrack && field.hasData) {
+			const track = order.map((j) => {
+				let best = 0, value = -Infinity;
+				for (let i = 0; i < field.nx; i++) if (field.at(i, j) > value) {
+					value = field.at(i, j);
+					best = i;
+				}
+				return space.at(best, j, .012);
+			});
+			this.tubes(new TubeBatch(.0095, 6).add(track), lift, ctx.theme.ink);
+		}
+	}
+};
+export { SpectrumAmplitude, SpectrumWaterfallMark, Waterfall3DSpectrum };

package/dist/charts/threesurfaces/WireframeSurface.js

@@ -0,0 +1,105 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { SurfaceSpace } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+// src/charts/threesurfaces/WireframeSurface.ts
+var WireLines = /* @__PURE__ */ function(WireLines) {
+	WireLines["Both"] = "lattice";
+	WireLines["Rows"] = "rows";
+	WireLines["Columns"] = "columns";
+	WireLines["Triangles"] = "triangles";
+	WireLines["Diagonal"] = "diamond";
+	return WireLines;
+}({});
+/** Bare wire lattice: for seeing through a surface, and for comparing slope along rows or columns. */
+var WireframeSurface = class extends GridSurfaceBase {
+	static meta = {
+		id: "wireframe-surface",
+		name: "Wireframe surface",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Draws only the lattice of a height field, so the far side of the surface stays visible.",
+		tags: [
+			"wireframe",
+			"hidden line",
+			"mesh plot"
+		],
+		sample: (seed) => SampleData.surface(seed, 49),
+		variants: {
+			lines: [
+				"lattice",
+				"rows",
+				"columns",
+				"triangles",
+				"diamond"
+			],
+			hiddenLine: [true, false],
+			stride: [
+				3,
+				2,
+				6
+			],
+			nodes: [false, true]
+		},
+		valid: ({ nodes, stride }) => !(nodes && stride === 2)
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			lines: "lattice",
+			hiddenLine: true,
+			stride: 3,
+			nodes: false
+		};
+	}
+	build(ctx) {
+		const { lines, hiddenLine, stride, nodes } = this.options;
+		const field = this.field(73);
+		const space = new SurfaceSpace(field);
+		const paint = this.painter(ctx, field.zDomain);
+		const { nx, ny } = field, step = stride;
+		this.box(ctx, this.axes(space));
+		const lift = this.rise(ctx);
+		if (hiddenLine) this.solid(ctx, SurfaceGeometry.grid(nx, ny, (i, j) => space.at(i, j, -.006), () => ctx.color(ctx.theme.surface)), lift, this.gridTip(space), {
+			roughness: 1,
+			polygonOffset: true,
+			polygonOffsetFactor: 1,
+			polygonOffsetUnits: 1
+		});
+		const batch = new TubeBatch(.0055);
+		const wire = (count, read) => {
+			const path = Array.from({ length: count }, (_, k) => read(k));
+			batch.add(path.map(([i, j]) => space.at(i, j)), (k) => paint(field.sample(...path[k])));
+		};
+		const columns = lines === "lattice" || lines === "columns" || lines === "triangles";
+		const rows = lines === "lattice" || lines === "rows" || lines === "triangles";
+		if (columns) for (let i = 0; i < nx; i += step) wire(ny, (k) => [i, k]);
+		if (rows) for (let j = 0; j < ny; j += step) wire(nx, (k) => [k, j]);
+		if (lines === "triangles" || lines === "diamond") {
+			const reach = Math.max(nx, ny);
+			for (let d = -reach + step; d < reach; d += step) {
+				const start = Math.max(0, -d), count = Math.min(nx - d, ny) - start;
+				if (count > 1) wire(count, (k) => [start + k + d, start + k]);
+			}
+		}
+		if (lines === "diamond") for (let d = step; d < nx + ny - 2; d += step) {
+			const start = Math.max(0, d - (nx - 1)), count = Math.min(d, ny - 1) - start + 1;
+			if (count > 1) wire(count, (k) => [d - start - k, start + k]);
+		}
+		this.tubes(batch, lift);
+		if (nodes) {
+			const lattice = [];
+			for (let j = 0; j < ny; j += step) for (let i = 0; i < nx; i += step) if (!Number.isNaN(field.at(i, j))) lattice.push([i, j]);
+			const points = lattice.map(([i, j]) => space.at(i, j));
+			this.dots(ctx, points, .0125, (k) => paint(field.at(...lattice[k])), lift, this.nodeTip(space, lattice));
+		}
+	}
+	nodeTip(space, lattice) {
+		const tip = this.gridTip(space);
+		return (k) => tip(lattice[k][0] + lattice[k][1] * space.field.nx);
+	}
+};
+export { WireLines, WireframeSurface };

package/dist/charts/threesurfaces/index.js

@@ -0,0 +1,49 @@
+import { SurfaceBase, SurfaceOverlay, SurfaceProjection } from "./SurfaceBase.js";
+import { SurfaceField } from "./SurfaceField.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { ComplexFunction, ComplexHeight, ComplexSurface } from "./ComplexSurface.js";
+import { ContourLevels, ContourMode, ContourSurface } from "./ContourSurface.js";
+import { DensitySurface, SurfaceDensityKernel, SurfaceDensityMark } from "./DensitySurface.js";
+import { HeightBarBaseline, HeightBarLayout, HeightBarShape, HeightfieldBars } from "./HeightfieldBars.js";
+import { ImplicitClip, ImplicitSurface, ImplicitSurfaceForm } from "./ImplicitSurface.js";
+import { LayerArrangement, LayerMark, LayeredSurfaces } from "./LayeredSurfaces.js";
+import { MeshBody, MeshPose, MeshSurface, MeshTile } from "./MeshSurface.js";
+import { ParametricSurfaceForm } from "./ParametricForms.js";
+import { ParametricCut, ParametricSurface } from "./ParametricSurface.js";
+import { PhaseMarks, PhaseSeeding, PhaseSurface, PhaseSurfaceSystem } from "./PhaseSurface.js";
+import { PolarAngleAxis, PolarSurface } from "./PolarSurface.js";
+import { RibbonForm, RibbonLayout, RibbonSmoothing, RibbonSurface } from "./RibbonSurface.js";
+import { Ridge3DMark, Ridge3DOrder, Ridge3DProfile, Ridge3DScaling, Ridgeline3DChart } from "./Ridgeline3DChart.js";
+import { SaddleFootprint, SaddleModel, SaddleSurface } from "./SaddleSurface.js";
+import { SliceAxis, SliceMark, SliceSurface } from "./SliceSurface.js";
+import { SpectrogramWindow } from "./ShortTimeTransform.js";
+import { Spectrogram3DChart, SpectrogramMark } from "./Spectrogram3DChart.js";
+import { SurfaceChart, SurfaceShading } from "./SurfaceChart.js";
+import { TerrainBase, TerrainChart } from "./TerrainChart.js";
+import { TriangulatedSurface, TriangulationMark, TriangulationTrim } from "./TriangulatedSurface.js";
+import { SpectrumAmplitude, SpectrumWaterfallMark, Waterfall3DSpectrum } from "./Waterfall3DSpectrum.js";
+import { WireLines, WireframeSurface } from "./WireframeSurface.js";
+// src/charts/threesurfaces/index.ts
+var threesurfacesCatalog = [
+	SurfaceChart,
+	WireframeSurface,
+	ContourSurface,
+	TerrainChart,
+	MeshSurface,
+	ParametricSurface,
+	RibbonSurface,
+	HeightfieldBars,
+	ImplicitSurface,
+	SaddleSurface,
+	Waterfall3DSpectrum,
+	Ridgeline3DChart,
+	Spectrogram3DChart,
+	TriangulatedSurface,
+	ComplexSurface,
+	PolarSurface,
+	PhaseSurface,
+	LayeredSurfaces,
+	SliceSurface,
+	DensitySurface
+];
+export { ComplexFunction, ComplexHeight, ComplexSurface, ContourLevels, ContourMode, ContourSurface, DensitySurface, GridSurfaceBase, HeightBarBaseline, HeightBarLayout, HeightBarShape, HeightfieldBars, ImplicitClip, ImplicitSurface, ImplicitSurfaceForm, LayerArrangement, LayerMark, LayeredSurfaces, MeshBody, MeshPose, MeshSurface, MeshTile, ParametricCut, ParametricSurface, ParametricSurfaceForm, PhaseMarks, PhaseSeeding, PhaseSurface, PhaseSurfaceSystem, PolarAngleAxis, PolarSurface, RibbonForm, RibbonLayout, RibbonSmoothing, RibbonSurface, Ridge3DMark, Ridge3DOrder, Ridge3DProfile, Ridge3DScaling, Ridgeline3DChart, SaddleFootprint, SaddleModel, SaddleSurface, SliceAxis, SliceMark, SliceSurface, Spectrogram3DChart, SpectrogramMark, SpectrogramWindow, SpectrumAmplitude, SpectrumWaterfallMark, SurfaceBase, SurfaceChart, SurfaceDensityKernel, SurfaceDensityMark, SurfaceField, SurfaceOverlay, SurfaceProjection, SurfaceShading, TerrainBase, TerrainChart, TriangulatedSurface, TriangulationMark, TriangulationTrim, Waterfall3DSpectrum, WireLines, WireframeSurface, threesurfacesCatalog };

package/dist/charts/threevolume/AtomicOrbitalChart.js

@@ -0,0 +1,228 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { numeric } from "./PointRowsChart.js";
+import { AtomicOrbital, IsoAlgorithm, OrbitalDisplay } from "./volumeEnums.js";
+import { VolumeGrid } from "./VolumeGrid.js";
+import { VolumeIsoSurface } from "./VolumeIsoSurface.js";
+import { VolumeScene } from "./VolumeScene.js";
+import { VolumeSheet } from "./VolumeSheet.js";
+import { randomLcg } from "d3";
+import { BufferGeometry, Float32BufferAttribute, Group, Mesh, Points, PointsMaterial, SphereGeometry, Vector3 } from "three";
+// src/charts/threevolume/AtomicOrbitalChart.ts
+/** Real spherical harmonic on the unit vector, keyed by `l` then `m`. */
+var HARMONICS = {
+	"0:0": () => .282,
+	"1:-1": (_, y) => .488 * y,
+	"1:0": (_, __, z) => .488 * z,
+	"1:1": (x) => .488 * x,
+	"2:-2": (x, y) => 1.092 * x * y,
+	"2:-1": (_, y, z) => 1.092 * y * z,
+	"2:0": (_, __, z) => .315 * (3 * z * z - 1),
+	"2:1": (x, _, z) => 1.092 * x * z,
+	"2:2": (x, y) => .546 * (x * x - y * y),
+	"3:-2": (x, y, z) => 2.676 * x * y * z,
+	"3:0": (_, __, z) => .373 * z * (5 * z * z - 3),
+	"3:2": (x, y, z) => 1.338 * z * (x * x - y * y)
+};
+var PRESETS = {
+	[AtomicOrbital.S]: "0:0",
+	[AtomicOrbital.Pz]: "1:0",
+	[AtomicOrbital.Dz2]: "2:0",
+	[AtomicOrbital.Dxy]: "2:-2",
+	[AtomicOrbital.Dx2y2]: "2:2",
+	[AtomicOrbital.Fz3]: "3:0",
+	[AtomicOrbital.Fxyz]: "3:-2"
+};
+/** Spherical harmonics and their superpositions: for atomic orbitals, antenna patterns and any angular expansion. */
+var AtomicOrbitalChart = class extends VolumeScene {
+	static meta = {
+		id: "atomic-orbital",
+		name: "Atomic orbital",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Function,
+		description: "Shows the signed lobes of spherical harmonics, from single s, p, d and f orbitals to weighted sums.",
+		tags: [
+			"spherical harmonics",
+			"chemistry",
+			"quantum",
+			"lobes",
+			"wavefunction"
+		],
+		sample: (seed) => SampleData.categories(seed, 3, 1).map((row, i) => ({
+			l: [
+				1,
+				2,
+				2
+			][i],
+			m: [
+				0,
+				1,
+				0
+			][i],
+			weight: +row.value / 100
+		})),
+		variants: {
+			orbital: Object.values(AtomicOrbital),
+			display: Object.values(OrbitalDisplay)
+		}
+	};
+	defaults() {
+		return {
+			l: "l",
+			m: "m",
+			weight: "weight",
+			orbital: AtomicOrbital.Data,
+			display: OrbitalDisplay.Lobes
+		};
+	}
+	/** Angular part of the wavefunction as a function of a unit vector, y up. */
+	angular() {
+		const { data, orbital, l, m, weight } = this.options;
+		const preset = PRESETS[orbital];
+		const terms = preset ? [{
+			at: HARMONICS[preset],
+			weight: 1
+		}] : (Array.isArray(data) ? data : []).flatMap((row) => {
+			const key = `${numeric(row[l])}:${numeric(row[m])}`;
+			return key in HARMONICS ? [{
+				at: HARMONICS[key],
+				weight: numeric(row[weight]) || 0
+			}] : [];
+		});
+		return (x, y, z) => terms.reduce((sum, term) => sum + term.weight * term.at(x, z, y), 0);
+	}
+	build(ctx) {
+		const { display } = this.options;
+		this.stage(ctx);
+		const psi = this.angular();
+		const peak = this.peak(psi);
+		if (!peak) return;
+		const signed = this.diverging(ctx);
+		const body = new Group();
+		if (display === OrbitalDisplay.Lobes) this.lobes(ctx, psi, peak, signed, body);
+		else if (display === OrbitalDisplay.Cloud) this.cloud(psi, signed, body);
+		else if (display === OrbitalDisplay.Isosurface) this.iso(ctx, psi, signed, body);
+		else this.section(ctx, psi, signed, body);
+		ctx.root.add(body);
+		this.emerge(ctx, body);
+	}
+	peak(psi) {
+		let most = 0;
+		const unit = new Vector3();
+		for (let i = 0; i < 2e3; i++) {
+			const y = 1 - 2 * (i + .5) / 2e3, ring = Math.sqrt(1 - y * y), a = i * 2.39996;
+			unit.set(ring * Math.cos(a), y, ring * Math.sin(a));
+			most = Math.max(most, Math.abs(psi(unit.x, unit.y, unit.z)));
+		}
+		return most;
+	}
+	/** Radius equal to the amplitude in each direction. */
+	lobes(ctx, psi, peak, signed, body) {
+		const geometry = new SphereGeometry(1, 128, 96);
+		const position = geometry.getAttribute("position");
+		const colors = new Float32Array(position.count * 3), p = new Vector3();
+		for (let i = 0; i < position.count; i++) {
+			p.fromBufferAttribute(position, i).normalize();
+			const value = psi(p.x, p.y, p.z) / peak;
+			signed(value).toArray(colors, i * 3);
+			p.multiplyScalar(.015 + Math.abs(value) * .88);
+			position.setXYZ(i, p.x, p.y, p.z);
+		}
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.computeVertexNormals();
+		const mesh = new Mesh(geometry, this.surface({
+			vertexColors: true,
+			roughness: .4
+		}));
+		mesh.castShadow = true;
+		ctx.pick(mesh, () => ({
+			title: "Angular amplitude",
+			rows: [["Peak", +peak.toFixed(3)]]
+		}));
+		body.add(mesh);
+	}
+	/** Radial decay under the angular part: hydrogen-like amplitude at a world position. */
+	amplitude(psi, x, y, z) {
+		const r = Math.hypot(x, y, z) || 1e-6;
+		return psi(x / r, y / r, z / r) * Math.exp(-r * 5.2) * (r * 5.2) ** (this.options.orbital === AtomicOrbital.S ? 0 : 1.4);
+	}
+	/** Dots drawn with probability equal to the squared amplitude. */
+	cloud(psi, signed, body) {
+		const next = randomLcg(.42);
+		let top = 0;
+		for (let i = 0; i < 4e3; i++) top = Math.max(top, this.amplitude(psi, next() * 2 - 1, next() * 2 - 1, next() * 2 - 1) ** 2);
+		const position = [], color = [];
+		for (let i = 0; i < 4e5 && position.length < 21e3; i++) {
+			const x = (next() * 2 - 1) * .92, y = (next() * 2 - 1) * .92, z = (next() * 2 - 1) * .92;
+			const value = this.amplitude(psi, x, y, z);
+			if (next() * top > value * value) continue;
+			position.push(x, y, z);
+			color.push(...signed(Math.sign(value) * .92).toArray());
+		}
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(position, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(color, 3));
+		body.add(new Points(geometry, new PointsMaterial({
+			size: .014,
+			vertexColors: true,
+			map: VolumeScene.roundSprite,
+			alphaTest: .4,
+			transparent: true
+		})));
+	}
+	/** Positive and negative lobes as separate level sets of the amplitude. */
+	iso(ctx, psi, signed, body) {
+		const n = 40, values = new Float32Array(n ** 3);
+		const world = (i) => i / 39 * 2 - 1;
+		let top = 0;
+		for (let k = 0; k < n; k++) for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+			const value = this.amplitude(psi, world(i), world(j), world(k));
+			values[i + j * n + k * n * n] = value;
+			top = Math.max(top, Math.abs(value));
+		}
+		for (const sign of [1, -1]) {
+			const grid = new VolumeGrid([
+				n,
+				n,
+				n
+			], values.map((value) => value * sign));
+			const material = this.surface({
+				color: signed(sign * .9),
+				roughness: .35
+			});
+			const mesh = new Mesh(VolumeIsoSurface.geometry(grid, top * .3, IsoAlgorithm.MarchingCubes), material);
+			mesh.castShadow = true;
+			ctx.pick(mesh, () => ({ title: sign > 0 ? "Positive phase" : "Negative phase" }));
+			body.add(mesh);
+		}
+	}
+	/** Amplitude on an oblique plane through the nucleus, which no real harmonic has as a nodal plane; phase is colour, size is relief. */
+	section(ctx, psi, signed, body) {
+		const normal = new Vector3(.45, .55, .7).normalize();
+		const u = new Vector3().crossVectors(normal, new Vector3(0, 1, 0)).normalize(), v = new Vector3().crossVectors(normal, u);
+		const point = new Vector3();
+		const value = (a, b) => {
+			point.copy(u).multiplyScalar(a).addScaledVector(v, b);
+			return this.amplitude(psi, point.x, point.y, point.z);
+		};
+		let top = 0;
+		for (let i = 0; i <= 60; i++) for (let j = 0; j <= 60; j++) top = Math.max(top, Math.abs(value((i / 30 - 1) * .82, (j / 30 - 1) * .82)));
+		const geometry = VolumeSheet.grid(120, 120, (a, b, out) => {
+			const height = value((a * 2 - 1) * .82, (b * 2 - 1) * .82) / (top || 1);
+			point.addScaledVector(normal, height * .34);
+			out.x = point.x;
+			out.y = point.y;
+			out.z = point.z;
+			out.color.copy(signed(height * 1.3));
+			out.alpha = 1;
+		});
+		const mesh = new Mesh(geometry, this.surface({
+			vertexColors: true,
+			roughness: .5
+		}));
+		mesh.castShadow = true;
+		body.add(mesh);
+	}
+};
+export { AtomicOrbitalChart };

package/dist/charts/threevolume/Bubble3DCloud.js

@@ -0,0 +1,126 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { samplePoints3D } from "./PointCloudChart.js";
+import { PointRowsChart, numeric } from "./PointRowsChart.js";
+import { BubbleLayout, BubbleSizing } from "./volumeEnums.js";
+import { CylinderGeometry, IcosahedronGeometry, InstancedMesh, Vector3 } from "three";
+// src/charts/threevolume/Bubble3DCloud.ts
+/** Bubbles in 3D space: for four measures at once, with position on three axes and honest size on the fourth. */
+var Bubble3DCloud = class extends PointRowsChart {
+	static meta = {
+		id: "bubble-3d-cloud",
+		name: "3D bubble cloud",
+		family: ChartFamily.Relationship,
+		dimension: Dimension.Three,
+		shape: DataShape.Table,
+		description: "Places spheres by three measures and sizes them by a fourth, scattered or relaxed so they never overlap.",
+		tags: [
+			"bubble",
+			"packing",
+			"four measures",
+			"cluster"
+		],
+		sample: (seed) => samplePoints3D(seed, 70, 4),
+		variants: {
+			layout: Object.values(BubbleLayout),
+			sizing: Object.values(BubbleSizing),
+			scale: [
+				ScaleKind.Linear,
+				ScaleKind.Sqrt,
+				ScaleKind.Log
+			],
+			stems: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			size: "size",
+			layout: BubbleLayout.Scatter,
+			sizing: BubbleSizing.Volume,
+			scale: ScaleKind.Linear,
+			stems: true
+		};
+	}
+	warp(values) {
+		const { scale } = this.options;
+		if (scale === ScaleKind.Linear) return values;
+		const unit = this.unit(values);
+		return values.map((value) => scale === ScaleKind.Sqrt ? Math.sqrt(unit(value)) : Math.log1p(unit(value) * 9));
+	}
+	/** Pulls groups toward their own centre in the clustered layout and pushes overlapping spheres apart. */
+	relax(spots, radii, groups) {
+		const { layout } = this.options;
+		if (layout === BubbleLayout.Scatter) return;
+		const clustered = layout === BubbleLayout.Clustered;
+		const names = [...new Set(groups)];
+		const homes = new Map(names.map((name, g) => {
+			const angle = g / names.length * Math.PI * 2;
+			return [name, new Vector3(.5 * Math.cos(angle), g % 2 ? .25 : -.25, .5 * Math.sin(angle))];
+		}));
+		const push = new Vector3();
+		for (let round = 0; round < 90; round++) {
+			if (clustered) spots.forEach((spot, i) => spot.lerp(homes.get(groups[i]), .03));
+			for (let a = 0; a < spots.length; a++) for (let b = a + 1; b < spots.length; b++) {
+				const gap = radii[a] + radii[b] + .012;
+				const distance = spots[a].distanceTo(spots[b]);
+				if (distance >= gap) continue;
+				if (distance < 1e-6) push.set(Math.cos(a), Math.sin(b), Math.cos(a + b)).normalize();
+				else push.subVectors(spots[a], spots[b]).divideScalar(distance);
+				spots[a].addScaledVector(push, (gap - distance) / 2);
+				spots[b].addScaledVector(push, -(gap - distance) / 2);
+			}
+		}
+		spots.forEach((spot, i) => spot.clampScalar(-.96 + radii[i], .96 - radii[i]));
+	}
+	build(ctx) {
+		const { size, sizing, stems, layout, scale } = this.options;
+		const rows = this.rows();
+		this.rowStage(ctx, layout === BubbleLayout.Scatter && scale === ScaleKind.Linear ? rows : [], .85);
+		if (!rows.length) return;
+		const axes = [
+			"x",
+			"y",
+			"z"
+		].map((key) => {
+			const warped = this.warp(rows.map((row) => row[key]));
+			return warped.map(this.unit(warped));
+		});
+		const spots = rows.map((_, i) => new Vector3(axes[0][i] * 1.7 - .85, axes[1][i] * 1.7 - .85, axes[2][i] * 1.7 - .85));
+		const measures = rows.map((row) => Math.max(0, numeric(row.row[size]) || 0));
+		const top = Math.max(...measures) || 1;
+		const root = sizing === BubbleSizing.Volume ? Math.cbrt : Math.sqrt;
+		const radii = measures.map((value) => .012 + .135 * root(value / top));
+		this.relax(spots, radii, rows.map((row) => row.group));
+		const mesh = new InstancedMesh(new IcosahedronGeometry(1, 4), this.surface({
+			roughness: .3,
+			transparent: true,
+			opacity: .88
+		}), rows.length);
+		mesh.castShadow = true;
+		rows.forEach((row, i) => mesh.setColorAt(i, ctx.color(ctx.palette.color(row.group))));
+		this.populate(ctx, mesh, (i, dummy) => {
+			dummy.position.copy(spots[i]);
+			dummy.scale.setScalar(radii[i]);
+		}, (i) => 1 - measures[i] / top);
+		ctx.root.add(mesh);
+		ctx.pick(mesh, (i) => ({
+			title: rows[i].group,
+			color: ctx.palette.color(rows[i].group),
+			rows: [
+				["x", rows[i].x],
+				["y", rows[i].y],
+				["z", rows[i].z],
+				[size, measures[i]]
+			]
+		}));
+		if (!stems) return;
+		const stalks = new InstancedMesh(new CylinderGeometry(.0028, .0028, 1, 5), this.surface({ color: ctx.color(ctx.theme.axis) }), rows.length);
+		this.populate(ctx, stalks, (i, dummy) => {
+			const spot = spots[i], top = spot.y - radii[i];
+			dummy.position.set(spot.x, (top - 1) / 2, spot.z);
+			dummy.scale.set(1, Math.max(.001, top + 1), 1);
+		}, (i) => 1 - measures[i] / top);
+		ctx.root.add(stalks);
+	}
+};
+export { Bubble3DCloud };