@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/scientific/SoilTextureChart.js

@@ -0,0 +1,592 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { Simplex } from "./Simplex.js";
+import { polygonCentroid, scaleSqrt } from "d3";
+// src/charts/scientific/SoilTextureChart.ts
+var SoilSystem = /* @__PURE__ */ function(SoilSystem) {
+	SoilSystem["Usda"] = "usda";
+	SoilSystem["Fao"] = "fao";
+	return SoilSystem;
+}({});
+var SoilClassStyle = /* @__PURE__ */ function(SoilClassStyle) {
+	SoilClassStyle["Tinted"] = "tinted";
+	SoilClassStyle["Outlined"] = "outlined";
+	return SoilClassStyle;
+}({});
+var SoilMark = /* @__PURE__ */ function(SoilMark) {
+	SoilMark["Points"] = "points";
+	SoilMark["Tally"] = "tally";
+	SoilMark["None"] = "no-samples";
+	return SoilMark;
+}({});
+var SYSTEMS = {
+	["usda"]: [
+		["Clay", [
+			[
+				55,
+				45,
+				0
+			],
+			[
+				100,
+				0,
+				0
+			],
+			[
+				60,
+				0,
+				40
+			],
+			[
+				40,
+				20,
+				40
+			],
+			[
+				40,
+				45,
+				15
+			]
+		]],
+		["Sandy clay", [
+			[
+				35,
+				65,
+				0
+			],
+			[
+				55,
+				45,
+				0
+			],
+			[
+				40,
+				45,
+				15
+			],
+			[
+				35,
+				45,
+				20
+			]
+		]],
+		["Silty clay", [
+			[
+				60,
+				0,
+				40
+			],
+			[
+				40,
+				0,
+				60
+			],
+			[
+				40,
+				20,
+				40
+			]
+		]],
+		["Clay loam", [
+			[
+				40,
+				45,
+				15
+			],
+			[
+				40,
+				20,
+				40
+			],
+			[
+				27,
+				20,
+				53
+			],
+			[
+				27,
+				45,
+				28
+			]
+		]],
+		["Silty clay loam", [
+			[
+				40,
+				20,
+				40
+			],
+			[
+				40,
+				0,
+				60
+			],
+			[
+				27,
+				0,
+				73
+			],
+			[
+				27,
+				20,
+				53
+			]
+		]],
+		["Sandy clay loam", [
+			[
+				20,
+				80,
+				0
+			],
+			[
+				35,
+				65,
+				0
+			],
+			[
+				35,
+				45,
+				20
+			],
+			[
+				27,
+				45,
+				28
+			],
+			[
+				20,
+				52,
+				28
+			]
+		]],
+		["Loam", [
+			[
+				27,
+				45,
+				28
+			],
+			[
+				27,
+				23,
+				50
+			],
+			[
+				7,
+				43,
+				50
+			],
+			[
+				7,
+				52,
+				41
+			],
+			[
+				20,
+				52,
+				28
+			]
+		]],
+		["Silt loam", [
+			[
+				27,
+				23,
+				50
+			],
+			[
+				27,
+				0,
+				73
+			],
+			[
+				12,
+				0,
+				88
+			],
+			[
+				12,
+				8,
+				80
+			],
+			[
+				0,
+				20,
+				80
+			],
+			[
+				0,
+				50,
+				50
+			],
+			[
+				7,
+				43,
+				50
+			]
+		]],
+		["Silt", [
+			[
+				12,
+				8,
+				80
+			],
+			[
+				12,
+				0,
+				88
+			],
+			[
+				0,
+				0,
+				100
+			],
+			[
+				0,
+				20,
+				80
+			]
+		]],
+		["Sandy loam", [
+			[
+				20,
+				80,
+				0
+			],
+			[
+				20,
+				52,
+				28
+			],
+			[
+				7,
+				52,
+				41
+			],
+			[
+				7,
+				43,
+				50
+			],
+			[
+				0,
+				50,
+				50
+			],
+			[
+				0,
+				70,
+				30
+			],
+			[
+				15,
+				85,
+				0
+			]
+		]],
+		["Loamy sand", [
+			[
+				15,
+				85,
+				0
+			],
+			[
+				0,
+				70,
+				30
+			],
+			[
+				0,
+				85,
+				15
+			],
+			[
+				10,
+				90,
+				0
+			]
+		]],
+		["Sand", [
+			[
+				10,
+				90,
+				0
+			],
+			[
+				0,
+				85,
+				15
+			],
+			[
+				0,
+				100,
+				0
+			]
+		]]
+	],
+	["fao"]: [
+		["Very fine", [
+			[
+				60,
+				40,
+				0
+			],
+			[
+				100,
+				0,
+				0
+			],
+			[
+				60,
+				0,
+				40
+			]
+		]],
+		["Fine", [
+			[
+				35,
+				65,
+				0
+			],
+			[
+				60,
+				40,
+				0
+			],
+			[
+				60,
+				0,
+				40
+			],
+			[
+				35,
+				0,
+				65
+			]
+		]],
+		["Medium fine", [
+			[
+				35,
+				15,
+				50
+			],
+			[
+				35,
+				0,
+				65
+			],
+			[
+				0,
+				0,
+				100
+			],
+			[
+				0,
+				15,
+				85
+			]
+		]],
+		["Medium", [
+			[
+				18,
+				82,
+				0
+			],
+			[
+				35,
+				65,
+				0
+			],
+			[
+				35,
+				15,
+				50
+			],
+			[
+				0,
+				15,
+				85
+			],
+			[
+				0,
+				65,
+				35
+			],
+			[
+				18,
+				65,
+				17
+			]
+		]],
+		["Coarse", [
+			[
+				0,
+				100,
+				0
+			],
+			[
+				18,
+				82,
+				0
+			],
+			[
+				18,
+				65,
+				17
+			],
+			[
+				0,
+				65,
+				35
+			]
+		]]
+	]
+};
+/** Classifies soil samples by sand, silt and clay on the standard texture triangle. */
+var SoilTextureChart = class extends Chart2D {
+	static meta = {
+		id: "soil-texture-triangle",
+		name: "Soil texture triangle",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Classifies soil samples by sand, silt and clay fractions using the USDA or FAO texture classes.",
+		tags: [
+			"ternary",
+			"pedology",
+			"agronomy"
+		],
+		sample: (seed) => ScientificSample.compositions(seed, 60).map(({ a, b, c, group }) => ({
+			clay: +a * 62,
+			sand: +b * 100 * .62 + +a * 14,
+			silt: +c * 100 + +a * 24,
+			group
+		})),
+		variants: {
+			system: Object.values(SoilSystem),
+			classes: Object.values(SoilClassStyle),
+			samples: Object.values(SoilMark),
+			labels: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			sand: "sand",
+			silt: "silt",
+			clay: "clay",
+			system: "usda",
+			classes: "tinted",
+			samples: "points",
+			labels: true
+		};
+	}
+	plotMargin() {
+		return {
+			top: 18,
+			right: 30,
+			bottom: 24,
+			left: 30
+		};
+	}
+	classify(polygons, x, y) {
+		return polygons.find(([, shape]) => {
+			let inside = false;
+			for (let i = 0, j = shape.length - 1; i < shape.length; j = i++) {
+				const [xi, yi] = shape[i], [xj, yj] = shape[j];
+				if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+			}
+			return inside;
+		})?.[0] ?? null;
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		const { data, sand, silt, clay, system, classes, samples, labels } = this.options;
+		const simplex = Simplex.fit({ ...ctx.plot });
+		const at = ([c, s, t]) => simplex.at(c, t, s);
+		const polygons = SYSTEMS[system].map(([name, vertices]) => [name, vertices.map(at)]);
+		const points = data.flatMap((row) => {
+			const [s, t, c] = [
+				row[sand],
+				row[silt],
+				row[clay]
+			].map(Draft.number);
+			return s === null || t === null || c === null || s + t + c <= 0 ? [] : [{
+				row,
+				clay: c,
+				sand: s,
+				silt: t,
+				p: at([
+					c,
+					s,
+					t
+				])
+			}];
+		}).map((d) => ({
+			...d,
+			texture: this.classify(polygons, d.p[0], d.p[1]) ?? "Unclassified"
+		}));
+		const tally = /* @__PURE__ */ new Map();
+		for (const d of points) tally.set(d.texture, (tally.get(d.texture) ?? 0) + 1);
+		const bubble = scaleSqrt([0, Math.max(1, ...tally.values())], [0, simplex.side / 14]);
+		Draft.rules(ctx, "grid", classes === "outlined" ? simplex.grid(10) : []);
+		const fields = ctx.marks("classes", "path", polygons, ([name]) => name).attr("stroke", classes === "tinted" ? ctx.theme.surface : ctx.theme.inkMuted).attr("stroke-width", classes === "tinted" ? 2 : 1.25).attr("stroke-linejoin", "round").attr("fill", (_, i) => classes === "tinted" ? ctx.palette.sequential(.06 + i % 4 * .075) : "transparent");
+		ctx.set(fields, { d: ([, shape]) => Draft.polygon(shape) }, { d: ([, shape]) => Draft.polygon(shape) });
+		ctx.hover(fields, ([name]) => ({
+			title: name,
+			rows: [["Samples", tally.get(name) ?? 0]]
+		}));
+		Draft.rules(ctx, "ticks", simplex.ticks(10), { stroke: ctx.theme.axis });
+		Draft.paths(ctx, "outline", [simplex.outline], { stroke: ctx.theme.axis });
+		const scale = simplex.labels(10, (_, t) => `${Math.round(t * 100)}`).filter((_, i) => (Math.floor(i / 3) + 1) % 2 === 0);
+		Draft.captions(ctx, "scale", scale);
+		Draft.captions(ctx, "corners", simplex.corners("Clay %", "Silt %", "Sand %"));
+		const counts = samples === "tally" ? polygons.filter(([name]) => tally.get(name)).map(([name, shape]) => ({
+			name,
+			count: tally.get(name),
+			centre: polygonCentroid(shape)
+		})) : [];
+		const bubbles = ctx.marks("tally", "circle", counts, (d) => d.name).attr("fill", ctx.palette.color("Samples")).attr("fill-opacity", .75).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(bubbles, {
+			cx: (d) => d.centre[0],
+			cy: (d) => d.centre[1],
+			r: (d) => bubble(d.count)
+		}, {
+			cx: (d) => d.centre[0],
+			cy: (d) => d.centre[1],
+			r: 0
+		}, 20);
+		ctx.hover(bubbles, (d) => ({
+			title: d.name,
+			rows: [["Samples", d.count]]
+		}));
+		const dots = ctx.marks("samples", "circle", samples === "points" ? points : [], (_, i) => i).attr("fill", ctx.palette.color("Samples")).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => d.p[0],
+			cy: (d) => d.p[1],
+			r: 4
+		}, {
+			cx: (d) => d.p[0],
+			cy: (d) => d.p[1],
+			r: 0
+		}, 3);
+		ctx.hover(dots, (d) => ({
+			title: d.texture,
+			rows: [
+				["Sand", d.sand.toFixed(1)],
+				["Silt", d.silt.toFixed(1)],
+				["Clay", d.clay.toFixed(1)]
+			]
+		}));
+		const names = !labels ? [] : Draft.declutter([...scale, ...polygons.map(([name, shape]) => {
+			const [x, y] = polygonCentroid(shape);
+			return {
+				text: name,
+				x,
+				y: y + 4,
+				size: 10,
+				tone: "ink"
+			};
+		}).filter((item) => simplex.side > 240 || item.text.length < 11)], ctx.plot.width, ctx.plot.height).filter((item) => !scale.includes(item));
+		Draft.captions(ctx, "names", names).attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke");
+	}
+};
+export { SoilClassStyle, SoilMark, SoilSystem, SoilTextureChart };

package/dist/charts/scientific/SpectralAnalysis.js

@@ -0,0 +1,59 @@
+// src/charts/scientific/SpectralAnalysis.ts
+var SpectralWindow = /* @__PURE__ */ function(SpectralWindow) {
+	SpectralWindow["Hann"] = "hann";
+	SpectralWindow["Hamming"] = "hamming";
+	SpectralWindow["Blackman"] = "blackman";
+	SpectralWindow["Rectangular"] = "rectangular";
+	return SpectralWindow;
+}({});
+var WINDOWS = {
+	["hann"]: (x) => .5 - .5 * Math.cos(2 * Math.PI * x),
+	["hamming"]: (x) => .54 - .46 * Math.cos(2 * Math.PI * x),
+	["blackman"]: (x) => .42 - .5 * Math.cos(2 * Math.PI * x) + .08 * Math.cos(4 * Math.PI * x),
+	["rectangular"]: () => 1
+};
+/** Short-time Fourier transform with a radix-2 FFT. */
+var SpectralAnalysis = class SpectralAnalysis {
+	static fft(re, im) {
+		const n = re.length;
+		for (let i = 1, j = 0; i < n; i++) {
+			let bit = n >> 1;
+			for (; j & bit; bit >>= 1) j ^= bit;
+			j ^= bit;
+			if (i < j) {
+				[re[i], re[j]] = [re[j], re[i]];
+				[im[i], im[j]] = [im[j], im[i]];
+			}
+		}
+		for (let size = 2; size <= n; size *= 2) {
+			const angle = -2 * Math.PI / size;
+			for (let start = 0; start < n; start += size) for (let k = 0; k < size / 2; k++) {
+				const c = Math.cos(angle * k), s = Math.sin(angle * k), a = start + k, b = a + size / 2;
+				const tr = re[b] * c - im[b] * s, ti = re[b] * s + im[b] * c;
+				re[b] = re[a] - tr;
+				im[b] = im[a] - ti;
+				re[a] = re[a] + tr;
+				im[a] = im[a] + ti;
+			}
+		}
+	}
+	static stft(signal, rate, size, overlap, window, floor = -70) {
+		const hop = Math.max(1, Math.round(size * (1 - overlap)));
+		const taper = Array.from({ length: size }, (_, i) => WINDOWS[window](i / (size - 1)));
+		const frames = signal.length < size ? 0 : Math.floor((signal.length - size) / hop) + 1;
+		const bins = size / 2;
+		const raw = Array.from({ length: frames }, (_, f) => {
+			const re = new Float64Array(size), im = new Float64Array(size);
+			for (let i = 0; i < size; i++) re[i] = signal[f * hop + i] * taper[i];
+			SpectralAnalysis.fft(re, im);
+			return Array.from({ length: bins }, (_, k) => re[k + 1] ** 2 + im[k + 1] ** 2);
+		});
+		const peak = Math.max(1e-12, ...raw.flat());
+		return {
+			times: raw.map((_, f) => (f * hop + size / 2) / rate),
+			frequencies: Array.from({ length: bins }, (_, k) => (k + 1) * rate / size),
+			power: raw.map((frame) => frame.map((value) => Math.max(floor, 10 * Math.log10(Math.max(value, 1e-12) / peak))))
+		};
+	}
+};
+export { SpectralAnalysis, SpectralWindow };