@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/signals/CorrelogramChart.js

@@ -1,171 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SignalChart } from "./SignalChart.js";
-import { SignalDsp } from "./SignalDsp.js";
-import { SignalSamples } from "./SignalSamples.js";
-import { SignalScales } from "./SignalScales.js";
-import { area, scaleLinear } from "d3";
-// src/charts/signals/CorrelogramChart.ts
-var CorrelogramFunction = /* @__PURE__ */ function(CorrelogramFunction) {
-	CorrelogramFunction["Auto"] = "autocorrelation";
-	CorrelogramFunction["Partial"] = "partial";
-	CorrelogramFunction["Cross"] = "cross-correlation";
-	return CorrelogramFunction;
-}({});
-var CorrelogramMark = /* @__PURE__ */ function(CorrelogramMark) {
-	CorrelogramMark["Stem"] = "stem";
-	CorrelogramMark["Bars"] = "bars";
-	CorrelogramMark["Area"] = "area";
-	return CorrelogramMark;
-}({});
-var CorrelogramBand = /* @__PURE__ */ function(CorrelogramBand) {
-	CorrelogramBand["White"] = "white-noise";
-	CorrelogramBand["Bartlett"] = "bartlett";
-	CorrelogramBand["None"] = "none";
-	return CorrelogramBand;
-}({});
-var Z = 1.96;
-/** Correlation of a signal with its own past, for finding periods and AR order, or the delay between two signals. */
-var CorrelogramChart = class extends SignalChart {
-	static meta = {
-		id: "signal-correlogram",
-		name: "Correlogram",
-		family: ChartFamily.Scientific,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Plots auto, partial or cross-correlation against lag, with significance bands, to expose periods and delays.",
-		tags: [
-			"acf",
-			"pacf",
-			"ccf",
-			"lag",
-			"time series"
-		],
-		sample: (seed) => SignalSamples.noise(seed, 512, 2).flatMap(({ name, noise }, channel) => noise.map((step, i) => {
-			const at = i - channel * 3;
-			return {
-				t: i,
-				series: name,
-				value: +(Math.sin(at / 3.2) + .5 * Math.sin(at / 1.3) + step * .5).toFixed(4)
-			};
-		})),
-		variants: {
-			fn: Object.values(CorrelogramFunction),
-			mark: Object.values(CorrelogramMark),
-			band: Object.values(CorrelogramBand),
-			twoSided: [false, true]
-		},
-		valid: (values) => {
-			if (values.fn === "autocorrelation") return true;
-			if (values.band === "bartlett") return false;
-			return values.fn === "partial" ? values.twoSided === false : values.twoSided === true;
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			xLabel: "Lag (samples)",
-			yLabel: "Correlation",
-			fn: "autocorrelation",
-			mark: "stem",
-			band: "white-noise",
-			twoSided: false
-		};
-	}
-	get legended() {
-		return false;
-	}
-	series(width) {
-		const { fn, twoSided, band, maxLag } = this.options, a = this.first, n = a.v.length, b = this.channels[1] ?? a;
-		const both = twoSided || fn === "cross-correlation", pitch = both ? 9 : 8;
-		const reach = Math.max(1, Math.min(maxLag ?? 60, Math.floor(width / (both ? 2 * pitch : pitch)), n - 1));
-		const white = n ? Z / Math.sqrt(n) : 0;
-		if (fn === "cross-correlation") return SignalDsp.correlate(a.v, b.v, reach).map((point) => ({
-			...point,
-			limit: white
-		}));
-		const auto = SignalDsp.autocorrelation(a.v, reach), values = fn === "partial" ? SignalDsp.partial(auto) : auto;
-		let running = 1;
-		const lags = values.map((value, lag) => {
-			const limit = band === "bartlett" ? Z * Math.sqrt(running / (n || 1)) : white;
-			if (lag > 0) running += 2 * auto[lag] ** 2;
-			return {
-				lag,
-				value,
-				limit
-			};
-		});
-		return both ? [...lags.slice(1).reverse().map((item) => ({
-			...item,
-			lag: -item.lag
-		})), ...lags] : lags;
-	}
-	scales(ctx) {
-		const { width, height } = ctx.plot, lags = this.series(width);
-		const reach = Math.max(1, ...lags.map((item) => Math.abs(item.lag)));
-		const negative = lags.some((item) => item.lag < 0);
-		return {
-			x: scaleLinear([negative ? -reach - 1 : -1, reach + 1], [0, width]),
-			y: scaleLinear([-1, 1], [height, 0])
-		};
-	}
-	plotMarks(ctx, { x, y }) {
-		const { mark, band } = this.options, { width } = ctx.plot, lags = this.series(width);
-		const color = ctx.palette.color(this.first.name), base = y(0);
-		if (band !== "none") {
-			const shape = area().x((item) => x(item.lag)).y0((item) => y(-item.limit)).y1((item) => y(item.limit));
-			this.fill(ctx, "band", [lags], () => 0, (list) => shape(list) ?? "", () => ctx.theme.grid, .8);
-		}
-		this.rule(ctx, "zero", [0], y);
-		const tip = (item) => ({
-			title: `Lag ${item.lag}`,
-			color,
-			rows: [["Correlation", SignalScales.number(item.value)], ["Significant", Math.abs(item.value) > item.limit ? "Yes" : "No"]]
-		});
-		if (mark === "area") {
-			const shape = area().x((item) => x(item.lag)).y0(base).y1((item) => y(item.value));
-			this.fill(ctx, "value", [lags], () => 0, (list) => shape(list) ?? "", () => color, .8);
-			this.probe(ctx, (px) => {
-				const near = lags.reduce((best, item) => !best || Math.abs(x(item.lag) - px) < Math.abs(x(best.lag) - px) ? item : best, null);
-				return near && {
-					x: x(near.lag),
-					tip: tip(near),
-					datum: near
-				};
-			});
-			return;
-		}
-		if (mark === "bars") {
-			const pitch = lags.length > 1 ? Math.abs(x(lags[1].lag) - x(lags[0].lag)) : 8, thick = Math.max(2, pitch - 2);
-			const bars = ctx.marks("bars", "rect", lags, (item) => item.lag).attr("fill", color).attr("rx", Math.min(2, thick / 2));
-			ctx.set(bars, {
-				x: (item) => x(item.lag) - thick / 2,
-				width: thick,
-				y: (item) => Math.min(y(item.value), base),
-				height: (item) => Math.abs(y(item.value) - base)
-			}, {
-				y: base,
-				height: 0
-			}, 5);
-			ctx.hover(bars, tip);
-			return;
-		}
-		const rods = ctx.marks("rods", "line", lags, (item) => item.lag).attr("stroke", color).attr("stroke-width", 2);
-		ctx.set(rods, {
-			x1: (item) => x(item.lag),
-			x2: (item) => x(item.lag),
-			y1: base,
-			y2: (item) => y(item.value)
-		}, { y2: base }, 5);
-		const heads = ctx.marks("heads", "circle", lags, (item) => item.lag).attr("fill", color).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
-		ctx.set(heads, {
-			cx: (item) => x(item.lag),
-			cy: (item) => y(item.value),
-			r: 4
-		}, {
-			cy: base,
-			r: 0
-		}, 5);
-		ctx.hover(heads, tip);
-	}
-};
-export { CorrelogramBand, CorrelogramChart, CorrelogramFunction, CorrelogramMark };

package/dist/charts/signals/EyeDiagramChart.js

@@ -1,155 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SignalChart } from "./SignalChart.js";
-import { SignalDsp } from "./SignalDsp.js";
-import { SignalRaster } from "./SignalRaster.js";
-import { SignalSamples } from "./SignalSamples.js";
-import { SignalScales } from "./SignalScales.js";
-import { max, scaleLinear } from "d3";
-// src/charts/signals/EyeDiagramChart.ts
-var EyeDisplay = /* @__PURE__ */ function(EyeDisplay) {
-	EyeDisplay["Traces"] = "traces";
-	EyeDisplay["Density"] = "density";
-	return EyeDisplay;
-}({});
-var OVERSAMPLE = 16;
-var CELL = 3;
-var MOST = 160;
-/** Overlays bit periods of a serial link so that noise and jitter show as a closing eye. */
-var EyeDiagramChart = class extends SignalChart {
-	static meta = {
-		id: "signal-eye-diagram",
-		name: "Eye diagram",
-		family: ChartFamily.Scientific,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Folds a digital signal over its symbol period so that noise, jitter and timing margin read as an eye opening.",
-		tags: [
-			"serdes",
-			"signal integrity",
-			"jitter",
-			"mask test"
-		],
-		sample: (seed) => {
-			const [{ noise }] = SignalSamples.noise(seed, 3200, 1), bits = Array.from({ length: 200 }, (_, i) => noise[i * OVERSAMPLE] > 0 ? 1 : -1);
-			let level = 0;
-			return noise.map((step, i) => {
-				level += (bits[Math.floor(i / OVERSAMPLE)] - level) * .28;
-				return {
-					t: i / OVERSAMPLE,
-					series: "Lane 0",
-					value: +(level + step * .045).toFixed(4)
-				};
-			});
-		},
-		variants: {
-			display: Object.values(EyeDisplay),
-			span: [2, 1],
-			mask: [true, false],
-			measure: [true, false]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			xLabel: "Time (UI)",
-			yLabel: "Amplitude",
-			grid: false,
-			display: "traces",
-			samplesPerSymbol: OVERSAMPLE,
-			span: 2,
-			mask: true,
-			measure: true
-		};
-	}
-	get legended() {
-		return false;
-	}
-	get levels() {
-		const { v } = this.first, centre = v.reduce((sum, value) => sum + value, 0) / (v.length || 1);
-		const highs = v.filter((value) => value > centre), lows = v.filter((value) => value <= centre);
-		const mean = (values) => values.reduce((sum, value) => sum + value, 0) / (values.length || 1);
-		const high = mean(highs), low = mean(lows);
-		return {
-			high,
-			low,
-			mid: (high + low) / 2
-		};
-	}
-	/** Samples into a symbol at which transitions cross mid level: circular mean over all crossings. */
-	get phase() {
-		const { v } = this.first, per = this.options.samplesPerSymbol, { mid } = this.levels;
-		let sin = 0, cos = 0;
-		for (let i = 1; i < v.length; i++) if ((v[i - 1] - mid) * (v[i] - mid) < 0) {
-			const angle = 2 * Math.PI * i / per;
-			sin += Math.sin(angle);
-			cos += Math.cos(angle);
-		}
-		return Math.round((Math.atan2(sin, cos) / (2 * Math.PI) + 1) % 1 * per);
-	}
-	/** One sweep per symbol, each a list of [ui, value] with transitions on whole UIs. */
-	get sweeps() {
-		const { samplesPerSymbol, span } = this.options, { v } = this.first, per = samplesPerSymbol, length = per * span, out = [];
-		for (let start = this.phase; start + length < v.length && out.length < MOST; start += per) out.push(Array.from({ length: length + 1 }, (_, i) => [i / per, v[start + i]]));
-		return out;
-	}
-	scales(ctx) {
-		const reach = this.peak * 1.2;
-		return {
-			x: scaleLinear([0, this.options.span], [0, ctx.plot.width]),
-			y: scaleLinear([-reach, reach], [ctx.plot.height, 0])
-		};
-	}
-	plotMarks(ctx, { x, y }) {
-		const { display, mask, measure, span } = this.options, sweeps = this.sweeps, color = ctx.palette.color(this.first.name);
-		if (display === "traces") this.stroke(ctx, "sweeps", sweeps, (_, i) => i, (sweep) => this.path(sweep, x, y), () => color, 1).attr("stroke-opacity", .28);
-		else this.density(ctx, sweeps, x, y);
-		const { high, low, mid } = this.levels, centers = Array.from({ length: span }, (_, i) => i + .5), half = (high - low) * .34;
-		if (mask) {
-			const d = centers.map((c) => `M${x(c - .22)} ${y(mid)}L${x(c - .1)} ${y(mid + half)}H${x(c + .1)}L${x(c + .22)} ${y(mid)}L${x(c + .1)} ${y(mid - half)}H${x(c - .1)}Z`).join("");
-			ctx.marks("mask", "path", [d], (_, i) => i).attr("d", (shape) => shape).attr("fill", ctx.theme.surface).attr("fill-opacity", .8).attr("stroke", ctx.theme.ink).attr("stroke-width", 1);
-		}
-		if (measure) this.measure(ctx, sweeps, x, y, centers[0], high, low);
-		this.probe(ctx, (px, py) => ({
-			x: px,
-			tip: {
-				title: `${SignalScales.number(x.invert(px))} UI`,
-				rows: [["Amplitude", SignalScales.number(y.invert(py))], ["Traces", sweeps.length]]
-			},
-			datum: { ui: x.invert(px) }
-		}));
-	}
-	density(ctx, sweeps, x, y) {
-		const { width, height } = ctx.plot, columns = Math.ceil(width / CELL), rows = Math.ceil(height / CELL);
-		const counts = new Array(columns * rows).fill(0);
-		for (const sweep of sweeps) for (let i = 1; i < sweep.length; i++) {
-			const [ax, ay] = [x(sweep[i - 1][0]), y(sweep[i - 1][1])], [bx, by] = [x(sweep[i][0]), y(sweep[i][1])], steps = Math.ceil(Math.max(Math.abs(bx - ax), Math.abs(by - ay)) / CELL) + 1;
-			for (let s = 0; s < steps; s++) {
-				const c = Math.floor((ax + (bx - ax) * s / steps) / CELL), r = Math.floor((ay + (by - ay) * s / steps) / CELL);
-				if (c >= 0 && c < columns && r >= 0 && r < rows) counts[r * columns + c]++;
-			}
-		}
-		const top = max(counts) || 1, cells = [];
-		counts.forEach((count, i) => {
-			if (count) cells.push({
-				x: i % columns * CELL,
-				y: Math.floor(i / columns) * CELL,
-				width: CELL,
-				height: CELL,
-				level: Math.max(.12, Math.sqrt(count / top))
-			});
-		});
-		SignalRaster.paint(ctx, "density", cells, ctx.palette.sequential);
-	}
-	/** Eye height from the inner rails at centre; eye width from where inner traces cross the mid level. */
-	measure(ctx, sweeps, x, y, centre, high, low) {
-		const mid = (high + low) / 2, values = sweeps.map((sweep) => SignalDsp.interpolate(sweep.map((point) => point[0]), sweep.map((point) => point[1]), centre));
-		const upper = Math.min(...values.filter((value) => value >= mid), high), lower = Math.max(...values.filter((value) => value < mid), low);
-		const crossings = sweeps.flatMap((sweep) => sweep.flatMap(([ui, value], i) => i && (sweep[i - 1][1] - mid) * (value - mid) < 0 ? [ui] : []));
-		const left = Math.max(0, ...crossings.filter((ui) => ui < centre)), right = Math.min(centre + .5, ...crossings.filter((ui) => ui >= centre));
-		const d = `M${x(centre)} ${y(upper)}V${y(lower)}M${x(left)} ${y(mid)}H${x(right)}`;
-		ctx.marks("eye-rulers", "path", [d], (_, i) => i).attr("d", (shape) => shape).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 1);
-		const line = `Height ${SignalScales.number(upper - lower)}  Width ${SignalScales.number(right - left)} UI`;
-		ctx.text(ctx.marks("eye-text", "text", [line], (_, i) => i).attr("x", ctx.plot.width - 4).attr("y", 12).attr("text-anchor", "end").text((text) => text), 11, "ink");
-	}
-};
-export { EyeDiagramChart, EyeDisplay };

package/dist/charts/signals/PoleZeroChart.js

@@ -1,164 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SampleData } from "../../data/SampleData.js";
-import { SignalChart } from "./SignalChart.js";
-import { SignalScales } from "./SignalScales.js";
-import { scaleLinear } from "d3";
-// src/charts/signals/PoleZeroChart.ts
-var PolePlane = /* @__PURE__ */ function(PolePlane) {
-	PolePlane["Z"] = "z-plane";
-	PolePlane["S"] = "s-plane";
-	return PolePlane;
-}({});
-var RADIAL = [
-	.25,
-	.5,
-	.75
-];
-var ARC = 5;
-/** Poles and zeros of a transfer function, with stability read off the unit circle or left half-plane. */
-var PoleZeroChart = class extends SignalChart {
-	static meta = {
-		id: "signal-pole-zero",
-		name: "Pole-zero plot",
-		family: ChartFamily.Scientific,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Places a system’s poles and zeros on the complex plane, showing stability, damping and notch frequencies.",
-		tags: [
-			"z-plane",
-			"s-plane",
-			"root locus",
-			"stability",
-			"transfer function"
-		],
-		sample: (seed) => SampleData.categories(seed, 4, 2).map((row, i) => {
-			const pole = i < 4, order = i % 4, angle = pole ? .32 + order * .3 : 1.25 + order * .22 + +row.value / 100 * .1;
-			const radius = pole ? .92 - order * .1 + +row.value / 100 * .03 : 1;
-			return {
-				re: +(radius * Math.cos(angle)).toFixed(4),
-				im: +((order % 2 ? -1 : 1) * radius * Math.sin(angle)).toFixed(4),
-				kind: pole ? "pole" : "zero"
-			};
-		}).flatMap((row) => [row, {
-			...row,
-			im: -row.im
-		}]),
-		variants: {
-			plane: Object.values(PolePlane),
-			guides: [true, false],
-			stable: [true, false],
-			pairs: [false, true]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			re: "re",
-			im: "im",
-			kind: "kind",
-			xLabel: "Real",
-			yLabel: "Imaginary",
-			grid: false,
-			plane: "z-plane",
-			guides: true,
-			stable: true,
-			pairs: false
-		};
-	}
-	get legended() {
-		return this.roots.length > 0;
-	}
-	get z() {
-		return this.options.plane === "z-plane";
-	}
-	/** Roots in the display plane; z maps to s by the inverse bilinear transform. */
-	get roots() {
-		const { data, re, im, kind } = this.options;
-		return (data ?? []).flatMap((row, i) => {
-			const a = +row[re], b = +row[im];
-			if (!Number.isFinite(a) || !Number.isFinite(b) || row[re] === null) return [];
-			const pole = String(row[kind] ?? "pole") === "pole";
-			if (this.z) return [{
-				key: `${i}`,
-				re: a,
-				im: b,
-				pole
-			}];
-			const bottom = (a + 1) ** 2 + b ** 2;
-			return bottom < 1e-9 ? [] : [{
-				key: `${i}`,
-				re: (a * a + b * b - 1) / bottom,
-				im: 2 * b / bottom,
-				pole
-			}];
-		});
-	}
-	scales(ctx) {
-		const { width, height } = ctx.plot, roots = this.roots, ratio = width / height;
-		const reach = Math.max(this.z ? 1.25 : 1.6, ...roots.map((root) => Math.max(Math.abs(root.re) / ratio, Math.abs(root.im)) * 1.15));
-		return {
-			x: scaleLinear([-reach * ratio, reach * ratio], [0, width]),
-			y: scaleLinear([-reach, reach], [height, 0])
-		};
-	}
-	plotMarks(ctx, { x, y }) {
-		const { guides, stable, pairs } = this.options, { width, height } = ctx.plot, roots = this.roots, scale = Math.abs(x(1) - x(0));
-		if (stable) {
-			if (this.z) ctx.marks("stable", "circle", [0]).attr("cx", x(0)).attr("cy", y(0)).attr("r", scale).attr("fill", ctx.theme.grid).attr("opacity", .55);
-			else ctx.marks("stable", "rect", [0]).attr("x", 0).attr("y", 0).attr("width", x(0)).attr("height", height).attr("fill", ctx.theme.grid).attr("opacity", .55);
-		}
-		ctx.marks("axes", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("d", `M${x(0)} 0V${height}M0 ${y(0)}H${width}`);
-		if (this.z) ctx.marks("unit", "circle", [0]).attr("cx", x(0)).attr("cy", y(0)).attr("r", scale).attr("fill", "none").attr("stroke", ctx.theme.inkMuted).attr("stroke-width", 1);
-		if (guides) this.guides(ctx, x, y, scale);
-		if (pairs) {
-			const conjugates = roots.filter((root) => root.im > 1e-6).map((root) => ({
-				root,
-				twin: roots.find((other) => other.pole === root.pole && Math.abs(other.re - root.re) < .001 && Math.abs(other.im + root.im) < .001)
-			})).filter((pair) => pair.twin);
-			ctx.marks("pairs", "line", conjugates, (pair) => pair.root.key).attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "3 3").attr("x1", (pair) => x(pair.root.re)).attr("x2", (pair) => x(pair.twin.re)).attr("y1", (pair) => y(pair.root.im)).attr("y2", (pair) => y(pair.twin.im));
-		}
-		const color = (root) => ctx.palette.color(root.pole ? "Pole" : "Zero");
-		const r = 5, shape = (root) => root.pole ? `M-${r} -${r}L${r} ${r}M${r} -${r}L-${r} ${r}` : `M-${r} 0a${r} ${r} 0 1 0 10 0a${r} ${r} 0 1 0 -10 0`;
-		const marks = ctx.marks("roots", "path", roots, (root) => root.key).attr("d", shape).attr("fill", ctx.theme.surface).attr("fill-opacity", (root) => root.pole ? 0 : 1).attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round");
-		ctx.set(marks, {
-			transform: (root) => `translate(${x(root.re)},${y(root.im)})`,
-			opacity: 1
-		}, { opacity: 0 }, 25);
-		ctx.hover(marks, (root) => ({
-			title: root.pole ? "Pole" : "Zero",
-			color: color(root),
-			rows: [["Value", `${SignalScales.number(root.re)} ${root.im < 0 ? "−" : "+"} ${SignalScales.number(Math.abs(root.im))}j`], ["Magnitude", SignalScales.number(Math.hypot(root.re, root.im))]]
-		}));
-	}
-	guides(ctx, x, y, scale) {
-		if (this.z) {
-			ctx.marks("rings", "circle", RADIAL, (r) => r).attr("cx", x(0)).attr("cy", y(0)).attr("r", (r) => r * scale).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-			const spokes = Array.from({ length: 10 }, (_, i) => i * Math.PI / ARC);
-			ctx.marks("spokes", "line", spokes, (angle) => angle).attr("x1", x(0)).attr("y1", y(0)).attr("x2", (angle) => x(Math.cos(angle))).attr("y2", (angle) => y(Math.sin(angle))).attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-			return;
-		}
-		const limit = Math.min(x.domain()[1], y.domain()[1]);
-		ctx.marks("rings", "circle", [
-			.5,
-			1,
-			1.5,
-			2,
-			3,
-			4
-		].filter((r) => r <= limit), (r) => r).attr("cx", x(0)).attr("cy", y(0)).attr("r", (r) => r * scale).attr("fill", "none").attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-		const rays = [
-			.2,
-			.5,
-			.8
-		].flatMap((damping) => [1, -1].map((sign) => {
-			const angle = Math.acos(damping) * sign, reach = Math.min(-x.domain()[0] / Math.cos(angle) * Math.sign(Math.cos(angle)), y.domain()[1] / Math.abs(Math.sin(angle)));
-			return {
-				key: `${damping}${sign}`,
-				angle,
-				reach
-			};
-		}));
-		ctx.marks("spokes", "line", rays, (ray) => ray.key).attr("x1", x(0)).attr("y1", y(0)).attr("x2", (ray) => x(-Math.cos(ray.angle) * ray.reach)).attr("y2", (ray) => y(Math.sin(ray.angle) * ray.reach)).attr("stroke", ctx.theme.grid).attr("stroke-width", 1);
-	}
-};
-export { PolePlane, PoleZeroChart };

package/dist/charts/signals/SpectrogramChart.js

@@ -1,79 +0,0 @@
-import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
-import { SignalDsp } from "./SignalDsp.js";
-import { SignalAmplitude, SignalFrequencyScale, SignalWindow } from "./SignalEnums.js";
-import { SignalSamples } from "./SignalSamples.js";
-import { SignalScales } from "./SignalScales.js";
-import { TimeFrequencyChart } from "./TimeFrequencyChart.js";
-import { bisectLeft } from "d3";
-// src/charts/signals/SpectrogramChart.ts
-var FRAMES = 120;
-/** Shows how a signal's spectrum changes over time. */
-var SignalSpectrogramChart = class extends TimeFrequencyChart {
-	static meta = {
-		id: "signal-spectrogram",
-		name: "Spectrogram",
-		family: ChartFamily.Scientific,
-		dimension: Dimension.Two,
-		shape: DataShape.Table,
-		description: "Maps short-time spectra across time so that sweeps, tones and clicks show as shapes.",
-		tags: [
-			"stft",
-			"sonogram",
-			"voiceprint",
-			"mel"
-		],
-		sample: (seed) => SignalSamples.chirp(seed),
-		variants: {
-			frameSize: [
-				256,
-				64,
-				1024
-			],
-			frequency: Object.values(SignalFrequencyScale),
-			amplitude: Object.values(SignalAmplitude),
-			ridge: [false, true]
-		}
-	};
-	defaults() {
-		return {
-			...super.defaults(),
-			yLabel: "Frequency (Hz)",
-			frameSize: 256,
-			frequency: SignalFrequencyScale.Linear,
-			amplitude: SignalAmplitude.Decibel,
-			window: SignalWindow.Hann,
-			range: 70
-		};
-	}
-	cache;
-	get frames() {
-		const { frameSize, window } = this.options, channel = this.channel, key = `${channel.v.length}|${frameSize}|${window}|${channel.name}|${channel.v[0]}`;
-		if (this.cache?.key !== key) this.cache = {
-			key,
-			frames: SignalDsp.stft(channel.v, channel.rate, window, frameSize, FRAMES, channel.t[0] ?? 0)
-		};
-		return this.cache.frames;
-	}
-	yAxis(height) {
-		const { freqs } = this.frames, top = freqs[freqs.length - 1] ?? 10;
-		return SignalScales.frequency(this.options.frequency, [this.options.frequency === SignalFrequencyScale.Log ? freqs[0] ?? 1 : 0, top], [height, 0]);
-	}
-	field() {
-		const { times, freqs, mags } = this.frames, { range, amplitude } = this.options;
-		if (!mags.length) return null;
-		const top = Math.max(1e-12, ...mags.map((frame) => Math.max(...frame))), decibel = amplitude === SignalAmplitude.Decibel, step = freqs[0];
-		return {
-			read: (time, freq) => {
-				const frame = mags[Math.min(mags.length - 1, Math.max(0, bisectLeft(times, time)))];
-				const bin = Math.max(0, Math.min(freqs.length - 1, Math.round(freq / step) - 1));
-				return decibel ? SignalDsp.decibel(frame[bin], top, -range) : frame[bin];
-			},
-			shade: (value) => decibel ? 1 + value / range : Math.sqrt(value / top),
-			signed: false,
-			low: decibel ? `-${range}` : "0",
-			high: decibel ? "0 dB" : "Max",
-			unit: decibel ? "Level (dB)" : "Magnitude"
-		};
-	}
-};
-export { SignalSpectrogramChart };