@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/threevolume/VolumeSlicesChart.js

@@ -0,0 +1,134 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { SliceAnchor, SliceLayout } from "./volumeEnums.js";
+import { VolumeGridChart } from "./VolumeGridChart.js";
+import { VolumeSheet } from "./VolumeSheet.js";
+import { Mesh, Vector3 } from "three";
+// src/charts/threevolume/VolumeSlicesChart.ts
+var AXES = [
+	new Vector3(1, 0, 0),
+	new Vector3(0, 1, 0),
+	new Vector3(0, 0, 1)
+];
+/** Heatmap planes through a volume: for reading exact values inside it, as radiologists read scan slices. */
+var VolumeSlicesChart = class extends VolumeGridChart {
+	static meta = {
+		id: "volume-slices",
+		name: "Volume slices",
+		family: ChartFamily.Volumetric,
+		dimension: Dimension.Three,
+		shape: DataShape.Volume,
+		description: "Cuts planes through a scalar volume and colours each one by the value it passes through.",
+		tags: [
+			"slice",
+			"section",
+			"tomography",
+			"heatmap",
+			"mpr"
+		],
+		sample: (seed) => SampleData.volume(seed, 28),
+		variants: {
+			layout: Object.values(SliceLayout),
+			count: [
+				1,
+				3,
+				6
+			],
+			anchor: Object.values(SliceAnchor),
+			relief: [false, true]
+		},
+		valid: (values) => {
+			if (values.layout === SliceLayout.Orthogonal && values.count === 6) return false;
+			return values.anchor === SliceAnchor.Center || values.count === 1;
+		}
+	};
+	defaults() {
+		return {
+			layout: SliceLayout.Orthogonal,
+			count: 1,
+			anchor: SliceAnchor.Center,
+			relief: false,
+			resolution: 56
+		};
+	}
+	planes(grid) {
+		const { layout, count, anchor } = this.options;
+		const n = Math.max(1, Math.floor(count));
+		const peak = grid.peak();
+		const centre = anchor === SliceAnchor.Peak ? new Vector3(grid.worldAxis(0, peak[0]), grid.worldAxis(1, peak[1]), grid.worldAxis(2, peak[2])) : new Vector3();
+		const spread = (i) => n === 1 ? null : (i + .5) / n * 2 - 1;
+		const along = (axis, i) => {
+			const origin = new Vector3();
+			origin.setComponent(axis, spread(i) === null ? centre.getComponent(axis) : spread(i) * grid.half[axis]);
+			const [a, b] = [
+				0,
+				1,
+				2
+			].filter((other) => other !== axis);
+			return {
+				origin,
+				u: AXES[a].clone().multiplyScalar(grid.half[a]),
+				v: AXES[b].clone().multiplyScalar(grid.half[b]),
+				normal: AXES[axis].clone()
+			};
+		};
+		const each = Array.from({ length: n }, (_, i) => i);
+		if (layout === SliceLayout.Orthogonal) return [
+			0,
+			1,
+			2
+		].flatMap((axis) => each.map((i) => along(axis, i)));
+		if (layout === SliceLayout.StackX) return each.map((i) => along(0, i));
+		if (layout === SliceLayout.StackY) return each.map((i) => along(1, i));
+		if (layout === SliceLayout.StackZ) return each.map((i) => along(2, i));
+		const normal = new Vector3(1, 1, 1).normalize(), reach = Math.hypot(...grid.half);
+		const u = new Vector3(1, 0, -1).normalize().multiplyScalar(reach), v = new Vector3(-1, 2, -1).normalize().multiplyScalar(reach);
+		return each.map((i) => ({
+			origin: normal.clone().multiplyScalar(spread(i) === null ? centre.dot(normal) : spread(i) * reach * .62),
+			u,
+			v,
+			normal
+		}));
+	}
+	build(ctx) {
+		const { relief, resolution, layout } = this.options;
+		const grid = this.grid;
+		this.volumeStage(ctx, grid);
+		if (grid.empty) return;
+		const tone = this.sequential(ctx, 0);
+		const polar = grid.min < 0 && grid.max > 0;
+		const split = this.diverging(ctx);
+		const bound = Math.max(Math.abs(grid.min), Math.abs(grid.max));
+		const planes = this.planes(grid);
+		const stacked = planes.length > 3 || layout === SliceLayout.Oblique;
+		const lift = relief ? .22 : 0;
+		const point = new Vector3();
+		for (const plane of planes) {
+			const geometry = VolumeSheet.grid(resolution, resolution, (s, t, out) => {
+				point.copy(plane.origin).addScaledVector(plane.u, s * 2 - 1).addScaledVector(plane.v, t * 2 - 1);
+				const value = grid.sample(point.x, point.y, point.z);
+				const unit = value === null ? 0 : grid.unit(value);
+				point.addScaledVector(plane.normal, unit * lift);
+				out.x = point.x;
+				out.y = point.y;
+				out.z = point.z;
+				out.color.copy(polar ? split((value ?? 0) / bound) : tone(unit));
+				out.alpha = value === null ? 0 : stacked ? Math.min(1, .04 + unit * 1.5) : .25 + unit * 1.5;
+			});
+			const mesh = new Mesh(geometry, this.surface({
+				vertexColors: true,
+				transparent: true,
+				depthWrite: !stacked,
+				roughness: .9
+			}));
+			mesh.castShadow = !stacked;
+			ctx.pick(mesh, () => ({
+				title: "Slice",
+				rows: [["Offset", +plane.origin.dot(plane.normal).toFixed(3)]]
+			}));
+			ctx.reveal((progress) => mesh.scale.set(1, 1, 1).setScalar(.6 + .4 * progress), .8);
+			ctx.root.add(mesh);
+		}
+	}
+};
+export { VolumeSlicesChart };

package/dist/charts/threevolume/VolumeStrands.js

@@ -0,0 +1,73 @@
+import { BufferGeometry, Float32BufferAttribute, Vector3 } from "three";
+// src/charts/threevolume/VolumeStrands.ts
+var ROUND_SECTION = {
+	sides: 8,
+	squash: 1
+};
+var THIN_SECTION = {
+	sides: 5,
+	squash: 1
+};
+var RIBBON_SECTION = {
+	sides: 6,
+	squash: .14
+};
+/** Sweeps polylines into one lit, vertex-coloured mesh with parallel-transport frames and closed ends. */
+var VolumeStrands = class {
+	section;
+	position = [];
+	normal = [];
+	color = [];
+	index = [];
+	constructor(section = ROUND_SECTION) {
+		this.section = section;
+	}
+	add(raw, paint) {
+		const path = raw.map((p) => new Vector3(p[0], p[1], p[2])).filter((p, i, all) => Number.isFinite(p.x + p.y + p.z) && (i === 0 || p.distanceToSquared(all[i - 1]) > 1e-12));
+		if (path.length < 2) return this;
+		const { sides, squash } = this.section;
+		const start = this.position.length / 3;
+		const tangent = new Vector3(), side = new Vector3(), lift = new Vector3(), previous = new Vector3().subVectors(path[1], path[0]).normalize();
+		const axis = new Vector3(), offset = new Vector3();
+		side.set(Math.abs(previous.y) < .9 ? 0 : 1, Math.abs(previous.y) < .9 ? 1 : 0, 0).cross(previous).normalize();
+		const rings = [
+			0,
+			...path.keys(),
+			path.length - 1
+		];
+		rings.forEach((p, ring) => {
+			const capped = ring === 0 || ring === rings.length - 1;
+			const point = path[p];
+			tangent.subVectors(path[Math.min(p + 1, path.length - 1)], path[Math.max(p - 1, 0)]).normalize();
+			axis.crossVectors(previous, tangent);
+			if (axis.lengthSq() > 1e-12) side.applyAxisAngle(axis.normalize(), previous.angleTo(tangent));
+			previous.copy(tangent);
+			lift.crossVectors(tangent, side).normalize();
+			const fraction = p / (path.length - 1);
+			const radius = capped ? 0 : paint.radius(p, fraction);
+			const tint = paint.color(p, fraction);
+			for (let s = 0; s < sides; s++) {
+				const angle = s / sides * Math.PI * 2, c = Math.cos(angle), a = Math.sin(angle);
+				offset.copy(side).multiplyScalar(c * radius).addScaledVector(lift, a * radius * squash);
+				this.position.push(point.x + offset.x, point.y + offset.y, point.z + offset.z);
+				offset.copy(side).multiplyScalar(c * squash).addScaledVector(lift, a).normalize();
+				this.normal.push(offset.x, offset.y, offset.z);
+				this.color.push(tint.r, tint.g, tint.b);
+			}
+		});
+		for (let ring = 0; ring < rings.length - 1; ring++) for (let s = 0; s < sides; s++) {
+			const a = start + ring * sides + s, b = start + ring * sides + (s + 1) % sides;
+			this.index.push(a, b, a + sides, b, b + sides, a + sides);
+		}
+		return this;
+	}
+	build() {
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(this.position, 3));
+		geometry.setAttribute("normal", new Float32BufferAttribute(this.normal, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(this.color, 3));
+		geometry.setIndex(this.index);
+		return geometry;
+	}
+};
+export { RIBBON_SECTION, ROUND_SECTION, THIN_SECTION, VolumeStrands };

package/dist/charts/threevolume/VoxelChart.js

@@ -0,0 +1,86 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { VolumeAggregate, VoxelOccupancy, VoxelShape, VoxelSizing } from "./volumeEnums.js";
+import { VolumeGridChart } from "./VolumeGridChart.js";
+import { BoxGeometry, IcosahedronGeometry, InstancedMesh, OctahedronGeometry } from "three";
+// src/charts/threevolume/VoxelChart.ts
+/** Discrete cells of a volume: for reading values block by block where a smooth surface would hide the sampling. */
+var VoxelChart = class extends VolumeGridChart {
+	static meta = {
+		id: "voxel",
+		name: "Voxel chart",
+		family: ChartFamily.Volumetric,
+		dimension: Dimension.Three,
+		shape: DataShape.Volume,
+		description: "Draws each occupied cell of a volume as an instanced block coloured by magnitude.",
+		tags: [
+			"voxels",
+			"cubes",
+			"volume",
+			"occupancy",
+			"grid"
+		],
+		sample: (seed) => SampleData.volume(seed, 24),
+		variants: {
+			bin: [
+				2,
+				1,
+				3
+			],
+			aggregate: [VolumeAggregate.Max, VolumeAggregate.Mean],
+			shape: Object.values(VoxelShape),
+			sizing: Object.values(VoxelSizing),
+			occupancy: Object.values(VoxelOccupancy)
+		},
+		valid: (values) => values.bin !== 1 || values.aggregate === VolumeAggregate.Max
+	};
+	defaults() {
+		return {
+			cutoff: .2,
+			bin: 2,
+			aggregate: VolumeAggregate.Max,
+			shape: VoxelShape.Cube,
+			sizing: VoxelSizing.Uniform,
+			occupancy: VoxelOccupancy.Filled,
+			budget: 4e4
+		};
+	}
+	build(ctx) {
+		const { cutoff, bin, aggregate, shape, sizing, occupancy, budget } = this.options;
+		const source = this.grid;
+		this.volumeStage(ctx, source);
+		if (source.empty) return;
+		const fair = Math.ceil(Math.cbrt(source.values.length / budget));
+		const grid = source.coarsen(Math.max(1, Math.floor(bin), fair), aggregate);
+		const on = (i, j, k) => i >= 0 && j >= 0 && k >= 0 && i < grid.nx && j < grid.ny && k < grid.nz && grid.unit(grid.at(i, j, k)) >= cutoff;
+		const cells = [];
+		for (let k = 0; k < grid.nz; k++) for (let j = 0; j < grid.ny; j++) for (let i = 0; i < grid.nx; i++) {
+			if (!on(i, j, k)) continue;
+			if (occupancy === VoxelOccupancy.Layered && j % 2) continue;
+			if (occupancy === VoxelOccupancy.Shell && on(i - 1, j, k) && on(i + 1, j, k) && on(i, j - 1, k) && on(i, j + 1, k) && on(i, j, k - 1) && on(i, j, k + 1)) continue;
+			cells.push([
+				i,
+				j,
+				k
+			]);
+		}
+		const pitch = 2 * Math.max(...grid.half) / Math.max(grid.nx - 1, grid.ny - 1, grid.nz - 1, 1);
+		const blockShape = shape === VoxelShape.Sphere ? new IcosahedronGeometry(.5, 2) : shape === VoxelShape.Octahedron ? new OctahedronGeometry(.62) : new BoxGeometry(1, 1, 1);
+		const mesh = new InstancedMesh(blockShape, this.surface({ roughness: .6 }), cells.length);
+		mesh.castShadow = true;
+		const tone = this.sequential(ctx);
+		const unit = cells.map(([i, j, k]) => grid.unit(grid.at(i, j, k)));
+		cells.forEach((_, i) => mesh.setColorAt(i, tone(unit[i])));
+		this.populate(ctx, mesh, (i, dummy) => {
+			const [a, b, c] = cells[i];
+			dummy.position.set(grid.worldAxis(0, a), grid.worldAxis(1, b), grid.worldAxis(2, c));
+			dummy.scale.setScalar(pitch * .9 * (sizing === VoxelSizing.Value ? Math.cbrt(unit[i]) : 1));
+		}, (i) => cells[i][1] / Math.max(1, grid.ny - 1));
+		ctx.root.add(mesh);
+		ctx.pick(mesh, (i) => ({
+			title: `Voxel ${cells[i].join(", ")}`,
+			rows: [["Value", +grid.at(...cells[i]).toFixed(3)]]
+		}));
+	}
+};
+export { VoxelChart };

package/dist/charts/threevolume/index.js

@@ -0,0 +1,52 @@
+import { VolumeScene } from "./VolumeScene.js";
+import { PointRowsChart } from "./PointRowsChart.js";
+import { AtomicOrbital, AttractorProjection, BubbleLayout, BubbleSizing, ChaoticSystem, CloudContrast, CloudMethod, ContourSpacing, ContourStyle, CrystalStructure, Density3DBandwidth, Density3DKernel, DensityDisplay, FieldDerivation, FlowEmitter, FlowMark, FlowTrail, HelixEncoding, HelixHand, HelixShape, IsoAlgorithm, IsoThreshold, LatticeAtoms, MoleculeLayout, MoleculeStyle, OrbitMarks, OrbitSpacing, OrbitTilt, OrbitalDisplay, PointCoordinates, PointEnvelope, PointGuides, PointMark, PointNormalization, RaycastMode, SlabRelief, SliceAnchor, SliceLayout, StrandStyle, StreamDirection, Streamline3DSeeding, TubeCurve, TubeMarkers, TubeWidth, Vector3DGlyph, Vector3DLattice, Vector3DLength, VolumeAggregate, VolumeAxis, VolumeCut, VoxelOccupancy, VoxelShape, VoxelSizing } from "./volumeEnums.js";
+import { VolumeGrid } from "./VolumeGrid.js";
+import { VolumeIsoSurface } from "./VolumeIsoSurface.js";
+import { AtomicOrbitalChart } from "./AtomicOrbitalChart.js";
+import { Bubble3DCloud } from "./Bubble3DCloud.js";
+import { Cloud3DChart } from "./Cloud3DChart.js";
+import { VolumeGridChart } from "./VolumeGridChart.js";
+import { Contour3DStack } from "./Contour3DStack.js";
+import { CrystalLattice } from "./CrystalLattice.js";
+import { Density3DChart } from "./Density3DChart.js";
+import { FlowParticles } from "./FlowParticles.js";
+import { VectorField3D } from "./VectorField3D.js";
+import { VectorField3DChart } from "./VectorField3DChart.js";
+import { Helix3DChart } from "./Helix3DChart.js";
+import { IsosurfaceChart } from "./IsosurfaceChart.js";
+import { LorenzAttractor } from "./LorenzAttractor.js";
+import { Molecule3DChart } from "./Molecule3DChart.js";
+import { Orbital3DChart } from "./Orbital3DChart.js";
+import { PointCloudChart, samplePoints3D } from "./PointCloudChart.js";
+import { Slab3DChart } from "./Slab3DChart.js";
+import { Streamline3DChart } from "./Streamline3DChart.js";
+import { TubeTrajectoryChart } from "./TubeTrajectoryChart.js";
+import { Vector3DField } from "./Vector3DField.js";
+import { VolumeRaycastChart } from "./VolumeRaycastChart.js";
+import { VolumeSlicesChart } from "./VolumeSlicesChart.js";
+import { VoxelChart } from "./VoxelChart.js";
+// src/charts/threevolume/index.ts
+var threevolumeCatalog = [
+	IsosurfaceChart,
+	VolumeRaycastChart,
+	VoxelChart,
+	VolumeSlicesChart,
+	Slab3DChart,
+	Cloud3DChart,
+	Contour3DStack,
+	Density3DChart,
+	PointCloudChart,
+	Bubble3DCloud,
+	Vector3DField,
+	Streamline3DChart,
+	FlowParticles,
+	TubeTrajectoryChart,
+	Helix3DChart,
+	LorenzAttractor,
+	Orbital3DChart,
+	AtomicOrbitalChart,
+	Molecule3DChart,
+	CrystalLattice
+];
+export { AtomicOrbital, AtomicOrbitalChart, AttractorProjection, Bubble3DCloud, BubbleLayout, BubbleSizing, ChaoticSystem, Cloud3DChart, CloudContrast, CloudMethod, Contour3DStack, ContourSpacing, ContourStyle, CrystalLattice, CrystalStructure, Density3DBandwidth, Density3DChart, Density3DKernel, DensityDisplay, FieldDerivation, FlowEmitter, FlowMark, FlowParticles, FlowTrail, Helix3DChart, HelixEncoding, HelixHand, HelixShape, IsoAlgorithm, IsoThreshold, IsosurfaceChart, LatticeAtoms, LorenzAttractor, Molecule3DChart, MoleculeLayout, MoleculeStyle, OrbitMarks, OrbitSpacing, OrbitTilt, Orbital3DChart, OrbitalDisplay, PointCloudChart, PointCoordinates, PointEnvelope, PointGuides, PointMark, PointNormalization, PointRowsChart, RaycastMode, Slab3DChart, SlabRelief, SliceAnchor, SliceLayout, StrandStyle, StreamDirection, Streamline3DChart, Streamline3DSeeding, TubeCurve, TubeMarkers, TubeTrajectoryChart, TubeWidth, Vector3DField, Vector3DGlyph, Vector3DLattice, Vector3DLength, VectorField3D, VectorField3DChart, VolumeAggregate, VolumeAxis, VolumeCut, VolumeGrid, VolumeGridChart, VolumeIsoSurface, VolumeRaycastChart, VolumeScene, VolumeSlicesChart, VoxelChart, VoxelOccupancy, VoxelShape, VoxelSizing, samplePoints3D, threevolumeCatalog };

package/dist/charts/threevolume/volumeEnums.js

@@ -0,0 +1,338 @@
+// src/charts/threevolume/volumeEnums.ts
+/** Removes part of a volume so its interior shows. */
+var VolumeCut = /* @__PURE__ */ function(VolumeCut) {
+	VolumeCut["None"] = "whole";
+	VolumeCut["HalfX"] = "half-x";
+	VolumeCut["HalfZ"] = "half-z";
+	VolumeCut["Octant"] = "octant";
+	return VolumeCut;
+}({});
+var VolumeAxis = /* @__PURE__ */ function(VolumeAxis) {
+	VolumeAxis["X"] = "x";
+	VolumeAxis["Y"] = "y";
+	VolumeAxis["Z"] = "z";
+	return VolumeAxis;
+}({});
+var VolumeAggregate = /* @__PURE__ */ function(VolumeAggregate) {
+	VolumeAggregate["Mean"] = "mean";
+	VolumeAggregate["Max"] = "max";
+	VolumeAggregate["Min"] = "min";
+	return VolumeAggregate;
+}({});
+/** Mesh extraction algorithm for a scalar level set. */
+var IsoAlgorithm = /* @__PURE__ */ function(IsoAlgorithm) {
+	IsoAlgorithm["MarchingCubes"] = "marching-cubes";
+	IsoAlgorithm["SurfaceNets"] = "surface-nets";
+	return IsoAlgorithm;
+}({});
+/** How the level is chosen when none is given. */
+var IsoThreshold = /* @__PURE__ */ function(IsoThreshold) {
+	IsoThreshold["Otsu"] = "otsu";
+	IsoThreshold["Midrange"] = "midrange";
+	IsoThreshold["MeanSigma"] = "mean-sigma";
+	return IsoThreshold;
+}({});
+var VoxelShape = /* @__PURE__ */ function(VoxelShape) {
+	VoxelShape["Cube"] = "cube";
+	VoxelShape["Sphere"] = "sphere";
+	VoxelShape["Octahedron"] = "octahedron";
+	return VoxelShape;
+}({});
+var VoxelSizing = /* @__PURE__ */ function(VoxelSizing) {
+	VoxelSizing["Uniform"] = "uniform";
+	VoxelSizing["Value"] = "value";
+	return VoxelSizing;
+}({});
+var VoxelOccupancy = /* @__PURE__ */ function(VoxelOccupancy) {
+	VoxelOccupancy["Filled"] = "filled";
+	VoxelOccupancy["Shell"] = "shell";
+	VoxelOccupancy["Layered"] = "layered";
+	return VoxelOccupancy;
+}({});
+var SliceLayout = /* @__PURE__ */ function(SliceLayout) {
+	SliceLayout["Orthogonal"] = "orthogonal";
+	SliceLayout["StackX"] = "stack-x";
+	SliceLayout["StackY"] = "stack-y";
+	SliceLayout["StackZ"] = "stack-z";
+	SliceLayout["Oblique"] = "oblique";
+	return SliceLayout;
+}({});
+var SliceAnchor = /* @__PURE__ */ function(SliceAnchor) {
+	SliceAnchor["Center"] = "center";
+	SliceAnchor["Peak"] = "peak";
+	return SliceAnchor;
+}({});
+var PointMark = /* @__PURE__ */ function(PointMark) {
+	PointMark["Sphere"] = "sphere";
+	PointMark["Cube"] = "cube";
+	PointMark["Sprite"] = "sprite";
+	return PointMark;
+}({});
+var PointCoordinates = /* @__PURE__ */ function(PointCoordinates) {
+	PointCoordinates["Cartesian"] = "cartesian";
+	PointCoordinates["Cylindrical"] = "cylindrical";
+	PointCoordinates["Spherical"] = "spherical";
+	return PointCoordinates;
+}({});
+var PointNormalization = /* @__PURE__ */ function(PointNormalization) {
+	PointNormalization["Range"] = "range";
+	PointNormalization["Rank"] = "rank";
+	return PointNormalization;
+}({});
+var PointEnvelope = /* @__PURE__ */ function(PointEnvelope) {
+	PointEnvelope["None"] = "bare";
+	PointEnvelope["Ellipsoid"] = "ellipsoid";
+	PointEnvelope["Hull"] = "hull";
+	return PointEnvelope;
+}({});
+var PointGuides = /* @__PURE__ */ function(PointGuides) {
+	PointGuides["None"] = "unguided";
+	PointGuides["Drops"] = "drops";
+	PointGuides["Shadows"] = "shadows";
+	return PointGuides;
+}({});
+var Density3DKernel = /* @__PURE__ */ function(Density3DKernel) {
+	Density3DKernel["Gaussian"] = "gaussian";
+	Density3DKernel["Epanechnikov"] = "epanechnikov";
+	Density3DKernel["Box"] = "box-kernel";
+	return Density3DKernel;
+}({});
+var Density3DBandwidth = /* @__PURE__ */ function(Density3DBandwidth) {
+	Density3DBandwidth["Scott"] = "scott";
+	Density3DBandwidth["Silverman"] = "silverman";
+	Density3DBandwidth["Tight"] = "tight";
+	return Density3DBandwidth;
+}({});
+var DensityDisplay = /* @__PURE__ */ function(DensityDisplay) {
+	DensityDisplay["Shells"] = "shells";
+	DensityDisplay["Voxels"] = "voxels";
+	DensityDisplay["Slices"] = "slices";
+	return DensityDisplay;
+}({});
+/** How a scalar potential becomes a vector field. Ignored for data that already holds vectors. */
+var FieldDerivation = /* @__PURE__ */ function(FieldDerivation) {
+	FieldDerivation["Swirl"] = "swirl";
+	FieldDerivation["Gradient"] = "gradient";
+	FieldDerivation["Curl"] = "curl";
+	return FieldDerivation;
+}({});
+var Vector3DGlyph = /* @__PURE__ */ function(Vector3DGlyph) {
+	Vector3DGlyph["Arrow"] = "arrow";
+	Vector3DGlyph["Cone"] = "cone";
+	Vector3DGlyph["Plate"] = "plate";
+	return Vector3DGlyph;
+}({});
+var Vector3DLattice = /* @__PURE__ */ function(Vector3DLattice) {
+	Vector3DLattice["Cube"] = "cube-lattice";
+	Vector3DLattice["Staggered"] = "staggered";
+	Vector3DLattice["Plane"] = "plane";
+	Vector3DLattice["Shell"] = "shell-lattice";
+	return Vector3DLattice;
+}({});
+var Vector3DLength = /* @__PURE__ */ function(Vector3DLength) {
+	Vector3DLength["Magnitude"] = "magnitude";
+	Vector3DLength["Unit"] = "unit";
+	return Vector3DLength;
+}({});
+var Streamline3DSeeding = /* @__PURE__ */ function(Streamline3DSeeding) {
+	Streamline3DSeeding["Lattice"] = "lattice";
+	Streamline3DSeeding["Plane"] = "plane-seeds";
+	Streamline3DSeeding["Sphere"] = "sphere-seeds";
+	Streamline3DSeeding["Scatter"] = "scatter";
+	return Streamline3DSeeding;
+}({});
+var StreamDirection = /* @__PURE__ */ function(StreamDirection) {
+	StreamDirection["Both"] = "both";
+	StreamDirection["Forward"] = "forward";
+	return StreamDirection;
+}({});
+var StrandStyle = /* @__PURE__ */ function(StrandStyle) {
+	StrandStyle["Tube"] = "tube";
+	StrandStyle["Thread"] = "thread";
+	StrandStyle["Ribbon"] = "ribbon";
+	return StrandStyle;
+}({});
+var FlowEmitter = /* @__PURE__ */ function(FlowEmitter) {
+	FlowEmitter["Volume"] = "volume";
+	FlowEmitter["Plane"] = "plane-emitter";
+	FlowEmitter["Ring"] = "ring";
+	FlowEmitter["Core"] = "core";
+	return FlowEmitter;
+}({});
+var FlowTrail = /* @__PURE__ */ function(FlowTrail) {
+	FlowTrail["Medium"] = "medium-trail";
+	FlowTrail["None"] = "no-trail";
+	FlowTrail["Long"] = "long-trail";
+	return FlowTrail;
+}({});
+var FlowMark = /* @__PURE__ */ function(FlowMark) {
+	FlowMark["Bead"] = "bead";
+	FlowMark["Dart"] = "dart";
+	return FlowMark;
+}({});
+var TubeCurve = /* @__PURE__ */ function(TubeCurve) {
+	TubeCurve["CatmullRom"] = "catmull-rom";
+	TubeCurve["Centripetal"] = "centripetal";
+	TubeCurve["Polyline"] = "polyline";
+	return TubeCurve;
+}({});
+var TubeWidth = /* @__PURE__ */ function(TubeWidth) {
+	TubeWidth["Constant"] = "constant";
+	TubeWidth["Speed"] = "speed";
+	TubeWidth["Taper"] = "taper";
+	return TubeWidth;
+}({});
+var TubeMarkers = /* @__PURE__ */ function(TubeMarkers) {
+	TubeMarkers["Ends"] = "ends";
+	TubeMarkers["None"] = "plain";
+	TubeMarkers["Beads"] = "beads";
+	return TubeMarkers;
+}({});
+var HelixShape = /* @__PURE__ */ function(HelixShape) {
+	HelixShape["Cylinder"] = "cylinder";
+	HelixShape["Cone"] = "cone";
+	HelixShape["Sphere"] = "sphere";
+	return HelixShape;
+}({});
+var HelixEncoding = /* @__PURE__ */ function(HelixEncoding) {
+	HelixEncoding["Radius"] = "radius";
+	HelixEncoding["Width"] = "width";
+	HelixEncoding["Spikes"] = "spikes";
+	return HelixEncoding;
+}({});
+var HelixHand = /* @__PURE__ */ function(HelixHand) {
+	HelixHand["Right"] = "right";
+	HelixHand["Left"] = "left";
+	return HelixHand;
+}({});
+var ChaoticSystem = /* @__PURE__ */ function(ChaoticSystem) {
+	ChaoticSystem["Lorenz"] = "lorenz";
+	ChaoticSystem["Rossler"] = "rossler";
+	ChaoticSystem["Thomas"] = "thomas";
+	ChaoticSystem["Aizawa"] = "aizawa";
+	ChaoticSystem["Halvorsen"] = "halvorsen";
+	ChaoticSystem["Chen"] = "chen";
+	ChaoticSystem["ChenLee"] = "chen-lee";
+	ChaoticSystem["Dadras"] = "dadras";
+	return ChaoticSystem;
+}({});
+var AttractorProjection = /* @__PURE__ */ function(AttractorProjection) {
+	AttractorProjection["None"] = "free";
+	AttractorProjection["Floor"] = "floor-shadow";
+	AttractorProjection["Walls"] = "wall-shadows";
+	return AttractorProjection;
+}({});
+var OrbitSpacing = /* @__PURE__ */ function(OrbitSpacing) {
+	OrbitSpacing["Log"] = "log";
+	OrbitSpacing["Sqrt"] = "sqrt";
+	OrbitSpacing["Linear"] = "linear";
+	return OrbitSpacing;
+}({});
+var OrbitMarks = /* @__PURE__ */ function(OrbitMarks) {
+	OrbitMarks["Bodies"] = "bodies";
+	OrbitMarks["Sweep"] = "sweep";
+	OrbitMarks["Apsides"] = "apsides";
+	return OrbitMarks;
+}({});
+var OrbitTilt = /* @__PURE__ */ function(OrbitTilt) {
+	OrbitTilt["Inclined"] = "inclined";
+	OrbitTilt["Coplanar"] = "coplanar";
+	return OrbitTilt;
+}({});
+var MoleculeStyle = /* @__PURE__ */ function(MoleculeStyle) {
+	MoleculeStyle["BallStick"] = "ball-stick";
+	MoleculeStyle["SpaceFill"] = "space-fill";
+	MoleculeStyle["Sticks"] = "sticks";
+	MoleculeStyle["Wire"] = "wire";
+	return MoleculeStyle;
+}({});
+var MoleculeLayout = /* @__PURE__ */ function(MoleculeLayout) {
+	MoleculeLayout["Force"] = "force";
+	MoleculeLayout["Sphere"] = "sphere-layout";
+	MoleculeLayout["Helix"] = "helix";
+	return MoleculeLayout;
+}({});
+var CrystalStructure = /* @__PURE__ */ function(CrystalStructure) {
+	CrystalStructure["FaceCentered"] = "face-centered";
+	CrystalStructure["SimpleCubic"] = "simple-cubic";
+	CrystalStructure["BodyCentered"] = "body-centered";
+	CrystalStructure["Hexagonal"] = "hexagonal";
+	CrystalStructure["Diamond"] = "diamond";
+	CrystalStructure["RockSalt"] = "rock-salt";
+	CrystalStructure["CesiumChloride"] = "cesium-chloride";
+	CrystalStructure["Perovskite"] = "perovskite";
+	CrystalStructure["Fluorite"] = "fluorite";
+	return CrystalStructure;
+}({});
+var LatticeAtoms = /* @__PURE__ */ function(LatticeAtoms) {
+	LatticeAtoms["BallStick"] = "ball-stick";
+	LatticeAtoms["Packed"] = "packed";
+	return LatticeAtoms;
+}({});
+var BubbleLayout = /* @__PURE__ */ function(BubbleLayout) {
+	BubbleLayout["Scatter"] = "scatter";
+	BubbleLayout["Packed"] = "packed";
+	BubbleLayout["Clustered"] = "clustered";
+	return BubbleLayout;
+}({});
+var BubbleSizing = /* @__PURE__ */ function(BubbleSizing) {
+	BubbleSizing["Volume"] = "by-volume";
+	BubbleSizing["Area"] = "by-area";
+	return BubbleSizing;
+}({});
+var ContourStyle = /* @__PURE__ */ function(ContourStyle) {
+	ContourStyle["Terraces"] = "terraces";
+	ContourStyle["Plates"] = "plates";
+	ContourStyle["Lines"] = "lines";
+	ContourStyle["Curtains"] = "curtains";
+	return ContourStyle;
+}({});
+var ContourSpacing = /* @__PURE__ */ function(ContourSpacing) {
+	ContourSpacing["Equal"] = "equal";
+	ContourSpacing["Quantile"] = "quantile";
+	return ContourSpacing;
+}({});
+var SlabRelief = /* @__PURE__ */ function(SlabRelief) {
+	SlabRelief["Rising"] = "rising";
+	SlabRelief["Mirrored"] = "mirrored";
+	return SlabRelief;
+}({});
+var CloudMethod = /* @__PURE__ */ function(CloudMethod) {
+	CloudMethod["Stipple"] = "stipple";
+	CloudMethod["Puffs"] = "puffs";
+	CloudMethod["Skin"] = "skin";
+	CloudMethod["Strata"] = "strata";
+	return CloudMethod;
+}({});
+var CloudContrast = /* @__PURE__ */ function(CloudContrast) {
+	CloudContrast["Linear"] = "linear";
+	CloudContrast["Soft"] = "soft";
+	CloudContrast["Hard"] = "hard";
+	return CloudContrast;
+}({});
+var RaycastMode = /* @__PURE__ */ function(RaycastMode) {
+	RaycastMode["Composite"] = "composite";
+	RaycastMode["MaxIntensity"] = "max-intensity";
+	RaycastMode["Mean"] = "mean-intensity";
+	RaycastMode["Surface"] = "surface";
+	return RaycastMode;
+}({});
+var AtomicOrbital = /* @__PURE__ */ function(AtomicOrbital) {
+	AtomicOrbital["Data"] = "superposition";
+	AtomicOrbital["S"] = "s";
+	AtomicOrbital["Pz"] = "pz";
+	AtomicOrbital["Dz2"] = "dz2";
+	AtomicOrbital["Dxy"] = "dxy";
+	AtomicOrbital["Dx2y2"] = "dx2-y2";
+	AtomicOrbital["Fz3"] = "fz3";
+	AtomicOrbital["Fxyz"] = "fxyz";
+	return AtomicOrbital;
+}({});
+var OrbitalDisplay = /* @__PURE__ */ function(OrbitalDisplay) {
+	OrbitalDisplay["Lobes"] = "lobes";
+	OrbitalDisplay["Cloud"] = "cloud";
+	OrbitalDisplay["Isosurface"] = "isosurface";
+	OrbitalDisplay["Section"] = "section";
+	return OrbitalDisplay;
+}({});
+export { AtomicOrbital, AttractorProjection, BubbleLayout, BubbleSizing, ChaoticSystem, CloudContrast, CloudMethod, ContourSpacing, ContourStyle, CrystalStructure, Density3DBandwidth, Density3DKernel, DensityDisplay, FieldDerivation, FlowEmitter, FlowMark, FlowTrail, HelixEncoding, HelixHand, HelixShape, IsoAlgorithm, IsoThreshold, LatticeAtoms, MoleculeLayout, MoleculeStyle, OrbitMarks, OrbitSpacing, OrbitTilt, OrbitalDisplay, PointCoordinates, PointEnvelope, PointGuides, PointMark, PointNormalization, RaycastMode, SlabRelief, SliceAnchor, SliceLayout, StrandStyle, StreamDirection, Streamline3DSeeding, TubeCurve, TubeMarkers, TubeWidth, Vector3DGlyph, Vector3DLattice, Vector3DLength, VolumeAggregate, VolumeAxis, VolumeCut, VoxelOccupancy, VoxelShape, VoxelSizing };