@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/scientific/TernaryPlot.js

@@ -0,0 +1,268 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Draft } from "./Draft.js";
+import { GridContours } from "./GridContours.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { Simplex } from "./Simplex.js";
+import { min, polygonHull, range, scaleSqrt } from "d3";
+// src/charts/scientific/TernaryPlot.ts
+var TernaryMark = /* @__PURE__ */ function(TernaryMark) {
+	TernaryMark["Scatter"] = "scatter";
+	TernaryMark["Bubble"] = "bubble";
+	TernaryMark["Density"] = "density";
+	TernaryMark["Contour"] = "contour";
+	TernaryMark["Hull"] = "hull";
+	return TernaryMark;
+}({});
+var TernaryGrid = /* @__PURE__ */ function(TernaryGrid) {
+	TernaryGrid["Lines"] = "lines";
+	TernaryGrid["Ticks"] = "ticks";
+	TernaryGrid["Frame"] = "frame";
+	return TernaryGrid;
+}({});
+var TernaryTransform = /* @__PURE__ */ function(TernaryTransform) {
+	TernaryTransform["Raw"] = "raw";
+	TernaryTransform["Centered"] = "centered";
+	TernaryTransform["Zoom"] = "zoom";
+	return TernaryTransform;
+}({});
+var TernaryApex = /* @__PURE__ */ function(TernaryApex) {
+	TernaryApex["Up"] = "apex-up";
+	TernaryApex["Down"] = "apex-down";
+	return TernaryApex;
+}({});
+/** Three parts of a whole, such as mineral, sediment or alloy compositions, on one triangle. */
+var TernaryPlot = class extends Chart2D {
+	static meta = {
+		id: "ternary-plot",
+		name: "Ternary plot",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Places three-part compositions on a triangle, for reading mixtures that always sum to a constant.",
+		tags: [
+			"simplex",
+			"de finetti",
+			"composition",
+			"geochemistry"
+		],
+		sample: (seed) => ScientificSample.compositions(seed),
+		variants: {
+			mark: Object.values(TernaryMark),
+			frame: Object.values(TernaryGrid),
+			transform: Object.values(TernaryTransform),
+			apex: Object.values(TernaryApex)
+		}
+	};
+	defaults() {
+		return {
+			a: "a",
+			b: "b",
+			c: "c",
+			group: "group",
+			size: "size",
+			mark: "scatter",
+			frame: "lines",
+			transform: "raw",
+			apex: "apex-up",
+			divisions: 10
+		};
+	}
+	plotMargin() {
+		return {
+			top: 20,
+			right: 34,
+			bottom: 24,
+			left: 34
+		};
+	}
+	compositions() {
+		const { data, a, b, c, group, size } = this.options;
+		return data.flatMap((row) => {
+			const [x, y, z] = [
+				row[a],
+				row[b],
+				row[c]
+			].map(Draft.number);
+			if (x === null || y === null || z === null || x < 0 || y < 0 || z < 0) return [];
+			const total = x + y + z;
+			return total > 0 ? [{
+				a: x / total,
+				b: y / total,
+				c: z / total,
+				group: String(row[group] ?? ""),
+				size: Draft.number(row[size]) ?? 1,
+				row
+			}] : [];
+		});
+	}
+	/** Perturbs by the inverse geometric mean, which moves the data centroid to the barycentre. */
+	centered(rows) {
+		const mean = (key) => Math.exp(rows.reduce((sum, row) => sum + Math.log(Math.max(row[key], 1e-6)), 0) / (rows.length || 1));
+		const [ga, gb, gc] = [
+			mean("a"),
+			mean("b"),
+			mean("c")
+		];
+		return rows.map((row) => {
+			const [x, y, z] = [
+				row.a / ga,
+				row.b / gb,
+				row.c / gc
+			], total = x + y + z;
+			return {
+				...row,
+				a: x / total,
+				b: y / total,
+				c: z / total
+			};
+		});
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		const { aLabel, bLabel, cLabel, a, b, c, group, frame, mark, transform, apex, divisions } = this.options;
+		const rows = this.compositions();
+		const shown = transform === "centered" ? this.centered(rows) : rows;
+		const floor = transform === "zoom" ? [
+			min(rows, (d) => d.a) ?? 0,
+			min(rows, (d) => d.b) ?? 0,
+			min(rows, (d) => d.c) ?? 0
+		].map((v) => Math.floor(v * 100) / 100) : [
+			0,
+			0,
+			0
+		];
+		const span = 1 - floor[0] - floor[1] - floor[2];
+		const simplex = Simplex.fit({ ...ctx.plot }, apex === "apex-down");
+		const at = (d) => simplex.at((d.a - floor[0]) / span, (d.b - floor[1]) / span, (d.c - floor[2]) / span);
+		Draft.rules(ctx, "grid", frame === "lines" ? simplex.grid(divisions) : []);
+		Draft.rules(ctx, "ticks", frame === "ticks" ? simplex.ticks(divisions) : [], { stroke: ctx.theme.axis });
+		Draft.paths(ctx, "outline", [simplex.outline], { stroke: ctx.theme.axis });
+		const percent = (component, t) => `${Math.round((floor[component] + t * span) * 100)}`;
+		const every = divisions >= 10 ? 2 : 1;
+		const scale = transform === "centered" ? [] : frame === "frame" ? [] : simplex.labels(divisions, percent).filter((_, i) => (Math.floor(i / 3) + 1) % every === 0);
+		Draft.captions(ctx, "scale", scale);
+		Draft.captions(ctx, "corners", simplex.corners(aLabel ?? a, bLabel ?? b, cLabel ?? c));
+		const pixels = shown.map((d) => ({
+			d,
+			p: at(d)
+		}));
+		const tooltip = (d) => ({
+			title: d.group || void 0,
+			color: d.group ? ctx.palette.color(d.group) : void 0,
+			rows: [
+				[aLabel ?? a, `${(d.a * 100).toFixed(1)}%`],
+				[bLabel ?? b, `${(d.b * 100).toFixed(1)}%`],
+				[cLabel ?? c, `${(d.c * 100).toFixed(1)}%`]
+			]
+		});
+		const groups = [...new Set(shown.map((d) => d.group))];
+		if (mark === "density") {
+			const n = divisions * 2, cells = this.cells(simplex, n, pixels.map(({ d }) => [
+				(d.a - floor[0]) / span,
+				(d.b - floor[1]) / span,
+				(d.c - floor[2]) / span
+			]));
+			const peak = Math.max(1, ...cells.map((cell) => cell.count));
+			const shapes = ctx.marks("cells", "path", cells.filter((cell) => cell.count), (cell) => cell.key).attr("fill", (cell) => ctx.palette.sequential(.15 + .85 * cell.count / peak)).attr("stroke", ctx.theme.surface).attr("stroke-width", 1);
+			ctx.set(shapes, { d: (cell) => cell.d }, {
+				d: (cell) => cell.d,
+				opacity: 0
+			}, 3);
+			ctx.set(shapes, { opacity: 1 });
+			ctx.hover(shapes, (cell) => ({
+				title: "Density",
+				rows: [["Samples", cell.count]]
+			}));
+			return;
+		}
+		if (mark === "contour") {
+			const bands = groups.flatMap((name) => GridContours.bands(pixels.filter(({ d }) => d.group === name).map(({ p }) => p), ctx.plot.width, ctx.plot.height, simplex.side / 15, (x, y) => simplex.contains(x, y), 4).map((band) => ({
+				...band,
+				name
+			})));
+			const shapes = ctx.marks("contours", "path", bands, (band, i) => `${band.name}${i}`).attr("fill", (band) => ctx.palette.color(band.name)).attr("fill-opacity", .16).attr("stroke", (band) => ctx.palette.color(band.name)).attr("stroke-width", 1);
+			ctx.set(shapes, { d: (band) => band.d }, { d: (band) => band.d });
+			ctx.hover(shapes, (band) => ({
+				title: band.name,
+				color: ctx.palette.color(band.name),
+				rows: [["Density level", `${Math.round(band.level * 100)}%`]]
+			}));
+			return;
+		}
+		if (mark === "hull") {
+			const hulls = groups.flatMap((name) => {
+				const hull = polygonHull(pixels.filter(({ d }) => d.group === name).map(({ p }) => [p[0], p[1]]));
+				return hull ? [{
+					name,
+					d: Draft.polygon(hull)
+				}] : [];
+			});
+			const shapes = ctx.marks("hulls", "path", hulls, (hull) => hull.name).attr("fill", (hull) => ctx.palette.color(hull.name)).attr("fill-opacity", .14).attr("stroke", (hull) => ctx.palette.color(hull.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round");
+			ctx.set(shapes, { d: (hull) => hull.d }, { d: (hull) => hull.d });
+		}
+		const bubble = scaleSqrt([0, Math.max(1, ...shown.map((d) => d.size))], [0, 13]);
+		const radius = (d) => mark === "bubble" ? Math.max(3, bubble(d.size)) : 4;
+		const dots = ctx.marks("points", "circle", pixels, (_, i) => i).attr("fill", ({ d }) => d.group ? ctx.palette.color(d.group) : ctx.palette.color(group)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2).attr("fill-opacity", mark === "bubble" ? .78 : 1);
+		ctx.set(dots, {
+			cx: ({ p }) => p[0],
+			cy: ({ p }) => p[1],
+			r: ({ d }) => radius(d)
+		}, {
+			cx: ({ p }) => p[0],
+			cy: ({ p }) => p[1],
+			r: 0
+		}, 2);
+		ctx.hover(dots, ({ d }) => tooltip(d));
+	}
+	/** Counts samples in the `n²` small triangles of a subdivided simplex. */
+	cells(simplex, n, points) {
+		const counts = /* @__PURE__ */ new Map();
+		for (const [a, b, c] of points) {
+			if (a < 0 || b < 0 || c < 0) continue;
+			const i = Math.min(n - 1, Math.floor(a * n)), j = Math.min(n - 1 - i, Math.floor(b * n));
+			const key = `${i}/${j}/${a * n - i + b * n - j <= 1 || i + j === n - 1 ? 1 : 0}`;
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		return range(n).flatMap((i) => range(n - i).flatMap((j) => {
+			const corner = (x, y) => simplex.at(x / n, y / n, 1 - (x + y) / n);
+			const up = Draft.polygon([
+				corner(i, j),
+				corner(i + 1, j),
+				corner(i, j + 1)
+			]);
+			const down = Draft.polygon([
+				corner(i + 1, j + 1),
+				corner(i + 1, j),
+				corner(i, j + 1)
+			]);
+			const list = [{
+				key: `${i}/${j}/1`,
+				d: up,
+				count: counts.get(`${i}/${j}/1`) ?? 0
+			}];
+			return i + j < n - 1 ? [...list, {
+				key: `${i}/${j}/0`,
+				d: down,
+				count: counts.get(`${i}/${j}/0`) ?? 0
+			}] : list;
+		}));
+	}
+	table() {
+		return {
+			columns: [
+				"a",
+				"b",
+				"c",
+				"group"
+			],
+			rows: this.compositions().map((d) => [
+				d.a,
+				d.b,
+				d.c,
+				d.group
+			])
+		};
+	}
+};
+export { TernaryApex, TernaryGrid, TernaryMark, TernaryPlot, TernaryTransform };

package/dist/charts/scientific/WalterLiethChart.js

@@ -0,0 +1,213 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ClimateChart, ClimateYearStart } from "./ClimateChart.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { axisBottom, axisLeft, axisRight, curveLinear, curveMonotoneX, line, max, mean, min, range, scaleLinear, sum } from "d3";
+// src/charts/scientific/WalterLiethChart.ts
+var WalterLiethFill = /* @__PURE__ */ function(WalterLiethFill) {
+	WalterLiethFill["Hatched"] = "hatched";
+	WalterLiethFill["Solid"] = "solid-seasons";
+	return WalterLiethFill;
+}({});
+var STEPS = 10;
+/** The ecologist's climate diagram: where the rain line sits below temperature, plants face drought. */
+var WalterLiethChart = class extends ClimateChart {
+	static meta = {
+		id: "walter-lieth",
+		name: "Walter–Lieth diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Overlays temperature and scaled precipitation to reveal humid, arid and perhumid seasons at a site.",
+		tags: [
+			"climate diagram",
+			"ecology",
+			"gaussen",
+			"bagnouls"
+		],
+		sample: (seed) => ScientificSample.climate(seed),
+		variants: {
+			ratio: [2, 3],
+			start: Object.values(ClimateYearStart),
+			fill: Object.values(WalterLiethFill),
+			compress: [true, false],
+			frost: [true, false],
+			smooth: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			ratio: 2,
+			fill: "hatched",
+			compress: true,
+			frost: true,
+			smooth: false
+		};
+	}
+	plotMargin() {
+		return {
+			top: 18,
+			right: 42,
+			bottom: this.options.frost ? 36 : 26,
+			left: 38
+		};
+	}
+	/** Rain in degree-equivalent axis units. */
+	rainUnits(mm) {
+		const { ratio, compress } = this.options;
+		return (compress && mm > 100 ? 100 + (mm - 100) / 10 : mm) / ratio;
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		const { width, height } = ctx.plot;
+		const { ratio, compress, frost, fill, smooth } = this.options;
+		const months = this.months();
+		if (!months.length) return;
+		const count = months.length, slot = width / count;
+		const ceiling = Math.max(10, max(months, (d) => this.rainUnits(d.precipitation)) ?? 10, max(months, (d) => d.temperature) ?? 10);
+		const floor = Math.min(0, min(months, (d) => d.temperature) ?? 0);
+		const y = scaleLinear([floor, ceiling], [height, 0]).nice();
+		const x = (i) => (i + .5) * slot;
+		const samples = range(0, (count - 1) * STEPS + 1).map((k) => {
+			const position = k / STEPS, i = Math.min(count - 2, Math.floor(position)), t = position - Math.max(0, i);
+			const a = months[Math.max(0, i)], b = months[Math.min(count - 1, Math.max(0, i) + 1)];
+			const raw = a.precipitation + (b.precipitation - a.precipitation) * t;
+			return {
+				x: x(position),
+				temperature: a.temperature + (b.temperature - a.temperature) * t,
+				raw,
+				rain: this.rainUnits(a.precipitation) + (this.rainUnits(b.precipitation) - this.rainUnits(a.precipitation)) * t
+			};
+		});
+		const hundred = this.rainUnits(100);
+		const humid = samples.filter((d) => d.rain > d.temperature);
+		const arid = samples.filter((d) => d.rain < d.temperature);
+		const ticks = y.ticks(6);
+		Draft.axis(ctx, "axis-temperature", axisLeft(y).ticks(6).tickSize(0).tickFormat((d) => `${d}°`), "translate(0,0)", false);
+		const rainScale = axisRight(y).tickValues(ticks.filter((tick) => tick >= 0)).tickSize(0).tickFormat((tick) => {
+			const units = +tick * ratio;
+			return `${Math.round(compress && units > 100 ? 100 + (units - 100) * 10 : units)}`;
+		});
+		Draft.axis(ctx, "axis-rain", rainScale, `translate(${width},0)`, false);
+		Draft.rules(ctx, "grid", ticks.map((tick) => ({
+			x1: 0,
+			x2: width,
+			y1: y(tick),
+			y2: y(tick)
+		}))).lower();
+		const axis = axisBottom(scaleLinear([0, count], [0, width])).tickValues(months.map((_, i) => i + .5)).tickFormat((_, i) => months[i].label).tickSize(0).tickPadding(frost ? 14 : 7);
+		Draft.axis(ctx, "axis-months", axis, `translate(0,${height})`);
+		Draft.captions(ctx, "units", [{
+			text: "mm",
+			x: width + 6,
+			y: -6,
+			anchor: "start",
+			size: 10,
+			tone: "muted"
+		}, {
+			text: "°C",
+			x: -6,
+			y: -6,
+			anchor: "end",
+			size: 10,
+			tone: "muted"
+		}]);
+		Draft.captions(ctx, "normals", [{
+			text: `${(mean(months, (d) => d.temperature) ?? 0).toFixed(1)} °C   ${Math.round(sum(months, (d) => d.precipitation))} mm`,
+			x: width - 6,
+			y: 12,
+			anchor: "end",
+			size: 11,
+			tone: "ink",
+			weight: 600
+		}]);
+		const wet = ctx.palette.color("Humid"), dry = ctx.palette.color("Arid");
+		const hatchEvery = Math.max(2, Math.round(4 / (slot / STEPS)));
+		const hatch = fill === "hatched" ? humid.filter((_, i) => i % hatchEvery === 0).map((d) => ({
+			x1: d.x,
+			x2: d.x,
+			y1: y(d.temperature),
+			y2: y(Math.min(d.rain, compress ? hundred : d.rain))
+		})) : [];
+		Draft.rules(ctx, "humid-hatch", hatch, {
+			stroke: wet,
+			width: 1
+		});
+		const dots = fill === "hatched" ? arid.filter((_, i) => i % hatchEvery === 0).flatMap((d) => range(y(d.temperature) + 4, y(d.rain), 5).map((py) => [d.x, py])) : [];
+		const stipple = ctx.marks("arid-stipple", "circle", dots, (_, i) => i).attr("fill", dry);
+		ctx.set(stipple, {
+			cx: (d) => d[0],
+			cy: (d) => d[1],
+			r: 1.2
+		}, {
+			cx: (d) => d[0],
+			cy: (d) => d[1],
+			r: 1.2
+		});
+		const band = (list, top, bottom) => this.runs(list).map((run) => Draft.polygon([...run.map((d) => [d.x, y(top(d))]), ...[...run].reverse().map((d) => [d.x, y(bottom(d))])]));
+		if (fill === "solid-seasons") {
+			Draft.paths(ctx, "humid-fill", band(humid, (d) => Math.min(d.rain, compress ? hundred : d.rain), (d) => d.temperature), { stroke: "none" }, wet).attr("fill-opacity", .35);
+			Draft.paths(ctx, "arid-fill", band(arid, (d) => d.temperature, (d) => d.rain), { stroke: "none" }, dry).attr("fill-opacity", .45);
+		}
+		const perhumid = compress ? samples.filter((d) => d.raw > 100) : [];
+		Draft.paths(ctx, "perhumid", band(perhumid, (d) => d.rain, () => hundred), { stroke: "none" }, wet);
+		const curve = (accessor) => line().x((_, i) => x(i)).y((d) => y(accessor(d))).curve(smooth ? curveMonotoneX : curveLinear)(months) ?? "";
+		const traces = ctx.marks("curves", "path", ["Precipitation", "Temperature"], (d) => d).attr("fill", "none").attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke", (d) => d === "Temperature" ? dry : wet);
+		const shape = (name) => curve(name === "Temperature" ? (d) => d.temperature : (d) => this.rainUnits(d.precipitation));
+		ctx.set(traces, { d: shape }, { d: shape });
+		ctx.drawOn(traces);
+		const targets = ctx.marks("months", "rect", months, (d) => d.month).attr("fill", "transparent");
+		ctx.set(targets, {
+			x: (_, i) => i * slot,
+			width: slot,
+			y: 0,
+			height
+		}, {
+			x: (_, i) => i * slot,
+			width: slot,
+			y: 0,
+			height
+		});
+		ctx.hover(targets, (d) => ({
+			title: `Month ${d.month}`,
+			rows: [
+				["Temperature", `${d.temperature.toFixed(1)} °C`],
+				["Precipitation", `${d.precipitation.toFixed(0)} mm`],
+				["Season", this.rainUnits(d.precipitation) >= d.temperature ? "Humid" : "Arid"]
+			]
+		}));
+		if (frost) {
+			const blocks = months.flatMap((d, i) => {
+				if (d.tmin === null || d.tmin >= 0) return [];
+				return [{
+					i,
+					sure: d.temperature < 0 || d.tmin < -5
+				}];
+			});
+			const cells = ctx.marks("frost", "rect", blocks, (d) => d.i).attr("fill", ctx.theme.inkSecondary).attr("fill-opacity", (d) => d.sure ? 1 : .4).attr("rx", 1);
+			ctx.set(cells, {
+				x: (d) => d.i * slot + 1,
+				width: slot - 2,
+				y: height + 3,
+				height: 6
+			}, {
+				x: (d) => d.i * slot + 1,
+				width: slot - 2,
+				y: height + 3,
+				height: 6
+			});
+		}
+	}
+	/** Splits samples into contiguous runs. */
+	runs(list) {
+		const gap = 1.5 * (list.length > 1 ? Math.min(...list.slice(1).map((d, i) => d.x - list[i].x)) : 1);
+		return list.reduce((all, d) => {
+			const last = all[all.length - 1];
+			if (last && d.x - last[last.length - 1].x <= gap) last.push(d);
+			else all.push([d]);
+			return all;
+		}, []).filter((run) => run.length > 1);
+	}
+};
+export { WalterLiethChart, WalterLiethFill };

package/dist/charts/scientific/index.js

@@ -0,0 +1,44 @@
+import { ClimateChart, ClimateYearStart } from "./ClimateChart.js";
+import { ClimographChart, ClimographForm, ClimographRain } from "./ClimographChart.js";
+import { HertzsprungRussell, StellarAbscissa, StellarGuides, StellarMark, StellarOrdinate } from "./HertzsprungRussell.js";
+import { HodographChart, HodographFrame, HodographMark, HodographStorm } from "./HodographChart.js";
+import { ChromatogramBaseline, ChromatogramChart, ChromatogramLayout, ChromatogramPeaks } from "./ChromatogramChart.js";
+import { MassSpectrumChart, SpectrumDisplay, SpectrumIntensity } from "./MassSpectrumChart.js";
+import { ElectrophoresisGel, GelBand, GelMigration } from "./ElectrophoresisGel.js";
+import { PeriodicEncoding, PeriodicLayout, PeriodicTableChart } from "./PeriodicTableChart.js";
+import { PhaseBoundary, PhaseDiagram, PhaseDiagramSystem } from "./PhaseDiagram.js";
+import { PiperDiagram, PiperPanels, PiperSizing } from "./PiperDiagram.js";
+import { LogoAlphabet, LogoForm, LogoMetric, LogoOrder, SequenceLogoChart } from "./SequenceLogoChart.js";
+import { SpectralAnalysis, SpectralWindow } from "./SpectralAnalysis.js";
+import { SpectrogramAmplitude, SpectrogramChart, SpectrogramFrequency, SpectrogramRender } from "./SpectrogramChart.js";
+import { RoseForm, RoseRadial, RoseStrainChart, RoseSymmetry } from "./RoseStrainChart.js";
+import { StiffDiagram, StiffForm, StiffLayout, StiffUnit } from "./StiffDiagram.js";
+import { SkewTChart, SoundingDiagram, SoundingParcel } from "./SkewTChart.js";
+import { SoilClassStyle, SoilMark, SoilSystem, SoilTextureChart } from "./SoilTextureChart.js";
+import { StereonetChart, StereonetFeature, StereonetHemisphere, StereonetNet, StereonetProjection } from "./StereonetChart.js";
+import { TaylorDiagram, TaylorMark, TaylorSpan } from "./TaylorDiagram.js";
+import { TernaryApex, TernaryGrid, TernaryMark, TernaryPlot, TernaryTransform } from "./TernaryPlot.js";
+import { WalterLiethChart, WalterLiethFill } from "./WalterLiethChart.js";
+// src/charts/scientific/index.ts
+var scientificCatalog = [
+	TernaryPlot,
+	SoilTextureChart,
+	PiperDiagram,
+	HertzsprungRussell,
+	StereonetChart,
+	ClimographChart,
+	WalterLiethChart,
+	SkewTChart,
+	HodographChart,
+	TaylorDiagram,
+	StiffDiagram,
+	RoseStrainChart,
+	MassSpectrumChart,
+	ChromatogramChart,
+	ElectrophoresisGel,
+	SpectrogramChart,
+	SequenceLogoChart,
+	PeriodicTableChart,
+	PhaseDiagram
+];
+export { ChromatogramBaseline, ChromatogramChart, ChromatogramLayout, ChromatogramPeaks, ClimateChart, ClimateYearStart, ClimographChart, ClimographForm, ClimographRain, ElectrophoresisGel, GelBand, GelMigration, HertzsprungRussell, HodographChart, HodographFrame, HodographMark, HodographStorm, LogoAlphabet, LogoForm, LogoMetric, LogoOrder, MassSpectrumChart, PeriodicEncoding, PeriodicLayout, PeriodicTableChart, PhaseBoundary, PhaseDiagram, PhaseDiagramSystem, PiperDiagram, PiperPanels, PiperSizing, RoseForm, RoseRadial, RoseStrainChart, RoseSymmetry, SequenceLogoChart, SkewTChart, SoilClassStyle, SoilMark, SoilSystem, SoilTextureChart, SoundingDiagram, SoundingParcel, SpectralAnalysis, SpectralWindow, SpectrogramAmplitude, SpectrogramChart, SpectrogramFrequency, SpectrogramRender, SpectrumDisplay, SpectrumIntensity, StellarAbscissa, StellarGuides, StellarMark, StellarOrdinate, StereonetChart, StereonetFeature, StereonetHemisphere, StereonetNet, StereonetProjection, StiffDiagram, StiffForm, StiffLayout, StiffUnit, TaylorDiagram, TaylorMark, TaylorSpan, TernaryApex, TernaryGrid, TernaryMark, TernaryPlot, TernaryTransform, WalterLiethChart, WalterLiethFill, scientificCatalog };