@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/signals/AudiogramChart.js

@@ -0,0 +1,235 @@
+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 { group, scaleLinear, scaleLog } from "d3";
+// src/charts/signals/AudiogramChart.ts
+var AudiogramLayout = /* @__PURE__ */ function(AudiogramLayout) {
+	AudiogramLayout["Combined"] = "combined";
+	AudiogramLayout["Separate"] = "separate-ears";
+	return AudiogramLayout;
+}({});
+var AudiogramSpacing = /* @__PURE__ */ function(AudiogramSpacing) {
+	AudiogramSpacing["Octave"] = "octave";
+	AudiogramSpacing["Linear"] = "linear";
+	return AudiogramSpacing;
+}({});
+var FREQUENCIES = [
+	250,
+	500,
+	1e3,
+	2e3,
+	4e3,
+	8e3
+];
+var ZONES = [
+	[
+		-10,
+		25,
+		"Normal"
+	],
+	[
+		25,
+		40,
+		"Mild"
+	],
+	[
+		40,
+		70,
+		"Moderate"
+	],
+	[
+		70,
+		90,
+		"Severe"
+	],
+	[
+		90,
+		120,
+		"Profound"
+	]
+];
+var BANANA = [
+	[
+		250,
+		28,
+		48
+	],
+	[
+		500,
+		22,
+		52
+	],
+	[
+		1e3,
+		20,
+		55
+	],
+	[
+		2e3,
+		22,
+		58
+	],
+	[
+		4e3,
+		28,
+		55
+	],
+	[
+		6e3,
+		34,
+		48
+	]
+];
+var GUTTER = 22;
+/** Clinical plot of hearing thresholds by frequency, downward meaning worse, with standard ear symbols. */
+var AudiogramChart = class extends SignalChart {
+	static meta = {
+		id: "signal-audiogram",
+		name: "Audiogram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots hearing thresholds per ear against test frequency, with hearing level increasing downward.",
+		tags: [
+			"hearing",
+			"audiometry",
+			"dB HL",
+			"speech banana"
+		],
+		sample: (seed) => {
+			const rows = SampleData.categories(seed, 6, 4), slope = [
+				8,
+				10,
+				16,
+				28,
+				48,
+				62
+			];
+			return rows.map((row, i) => {
+				const at = Math.floor(i / 4), kind = i % 4, ear = kind % 2 ? "Left" : "Right", bone = kind > 1;
+				const level = slope[at] + (kind % 2 ? 6 : 0) - (bone ? Math.min(slope[at] * .4, 18) : 0) + (+row.value - 60) / 80 * 10;
+				return {
+					frequency: FREQUENCIES[at],
+					level: Math.round(level / 5) * 5,
+					ear,
+					conduction: bone ? "Bone" : "Air"
+				};
+			});
+		},
+		variants: {
+			layout: Object.values(AudiogramLayout),
+			spacing: Object.values(AudiogramSpacing),
+			bone: [true, false],
+			zones: [true, false],
+			banana: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			x: "frequency",
+			y: "level",
+			xLabel: "Frequency (Hz)",
+			yLabel: "Hearing level (dB HL)",
+			ear: "ear",
+			conduction: "conduction",
+			layout: "combined",
+			spacing: "octave",
+			bone: true,
+			zones: true,
+			banana: false,
+			grid: true
+		};
+	}
+	get legended() {
+		return this.ears.length > 1;
+	}
+	get thresholds() {
+		const { data, x, y, ear, conduction, bone } = this.options;
+		return (data ?? []).flatMap((row, i) => {
+			const freq = +row[x], level = +row[y], isBone = String(row[conduction] ?? "Air") === "Bone";
+			if (!(freq > 0) || !Number.isFinite(level) || row[y] === null || isBone && !bone) return [];
+			return [{
+				key: `${i}`,
+				freq,
+				level,
+				ear: String(row[ear] ?? "Right"),
+				bone: isBone
+			}];
+		});
+	}
+	get ears() {
+		return [...new Set(this.thresholds.map((item) => item.ear))].sort((a, b) => b.localeCompare(a));
+	}
+	get split() {
+		return this.options.layout === "separate-ears" && this.ears.length > 1;
+	}
+	frequencyScale(width) {
+		const seen = this.thresholds.map((item) => item.freq), lo = Math.min(125, ...seen), hi = Math.max(8e3, ...seen);
+		const ticks = FREQUENCIES.filter((freq) => freq >= lo && freq <= hi);
+		const scale = this.options.spacing === "linear" ? scaleLinear([0, hi], [0, width]) : scaleLog([lo, hi * 1.3], [0, width]);
+		const shown = this.options.spacing === "linear" ? ticks.filter((freq) => freq >= 1e3) : ticks;
+		return SignalScales.labelled(scale, width < 150 ? shown.filter((_, i) => i % 2 === 0) : shown, SignalScales.hertz);
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, deepest = Math.max(120, ...this.thresholds.map((item) => item.level + 10));
+		const x = this.frequencyScale(this.split ? (width - GUTTER) / 2 : width);
+		const y = scaleLinear([-10, deepest], [0, height]);
+		return {
+			x,
+			y: SignalScales.labelled(y, y.ticks(7).filter((tick) => tick % 20 === 0), String)
+		};
+	}
+	symbol(item) {
+		const r = 5;
+		if (item.bone) return item.ear === "Left" ? `M-${r} -${r}L${r} 0L-${r} ${r}` : `M${r} -${r}L-${r} 0L${r} ${r}`;
+		return item.ear === "Left" ? `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`;
+	}
+	plotMarks(ctx, { x, y }) {
+		const { width, height } = ctx.plot, ears = this.ears;
+		const single = (width - GUTTER) / 2, panels = (this.split ? ears : ["all"]).map((ear, i) => ({
+			ear,
+			left: i * (single + GUTTER),
+			width: this.split ? single : width,
+			items: this.thresholds.filter((item) => !this.split || item.ear === ear)
+		}));
+		for (const panel of panels) this.panel(ctx, panel, x, y, height);
+	}
+	panel(ctx, { ear, left, width, items }, x, y, height) {
+		const inner = ctx.nest(`translate(${left},0)`, `panel-${ear}`), { zones, banana } = this.options;
+		if (this.split && left > 0) {
+			const scale = x.copy();
+			ctx.marks("second-rule", "line", [0]).attr("x1", left).attr("x2", left + width).attr("y1", height).attr("y2", height).attr("stroke", ctx.theme.axis);
+			ctx.group("second-axis").attr("transform", `translate(${left},${height})`).selectAll("text").data(x.ticks()).join("text").attr("x", (tick) => scale(tick)).attr("y", 17).attr("text-anchor", "middle").attr("fill", ctx.theme.inkSecondary).attr("font-size", 11).text((tick) => SignalScales.hertz(tick));
+		}
+		if (zones) {
+			const bands = ZONES.filter((_, i) => i % 2 === 1);
+			inner.marks("zones", "rect", bands, (band) => band[2], inner.root).attr("x", 0).attr("width", width).attr("y", (band) => y(band[0])).attr("height", (band) => y(band[1]) - y(band[0])).attr("fill", ctx.theme.grid).attr("opacity", .5);
+			if (width > 140) ctx.text(inner.marks("zone-names", "text", ZONES, (band) => band[2], inner.root).attr("x", 5).attr("y", (band) => (y(band[0]) + y(band[1])) / 2 + 4).text((band) => band[2]), 10, "muted");
+		}
+		if (banana) {
+			const reach = BANANA.filter(([freq]) => x(freq) <= width);
+			const d = `M${reach.map(([freq, upper]) => `${x(freq)} ${y(upper)}`).join("L")}L${[...reach].reverse().map(([freq, , lower]) => `${x(freq)} ${y(lower)}`).join("L")}Z`;
+			this.fill(inner, "banana", [d], () => 0, (shape) => shape, () => ctx.palette.sequential(.3), .45);
+		}
+		for (const [key, list] of group(items, (item) => `${item.ear}/${item.bone}`)) this.connect(ctx, inner, key, list, x, y);
+		const marks = inner.marks("thresholds", "path", items, (item) => item.key, inner.root).attr("fill", "none").attr("stroke", (item) => ctx.palette.color(item.ear)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("d", (item) => this.symbol(item));
+		ctx.set(marks, {
+			transform: (item) => `translate(${x(item.freq) + (item.bone ? item.ear === "Left" ? 8 : -8 : 0)},${y(item.level)})`,
+			opacity: 1
+		}, { opacity: 0 }, 10);
+		ctx.hover(marks, (item) => ({
+			title: `${SignalScales.hertz(item.freq)} Hz`,
+			color: ctx.palette.color(item.ear),
+			rows: [[`${item.ear} ${item.bone ? "bone" : "air"}`, `${item.level} dB HL`]]
+		}));
+		if (this.split) ctx.text(inner.marks("ear", "text", [ear], (name) => name, inner.root).attr("x", 4).attr("y", 12).text(`${ear} ear`), 11, "ink");
+	}
+	connect(ctx, inner, key, list, x, y) {
+		const ordered = [...list].sort((a, b) => a.freq - b.freq);
+		if (ordered[0]?.bone) return;
+		this.stroke(inner, `air-${key.replace(/\W/g, "")}`, [ordered], () => key, (items) => this.path(items.map((item) => [item.freq, item.level]), x, y), () => ctx.palette.color(ordered[0].ear), 2).attr("opacity", .9);
+	}
+};
+export { AudiogramChart, AudiogramLayout, AudiogramSpacing };

package/dist/charts/signals/CepstrumChart.js

@@ -0,0 +1,161 @@
+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, scaleLog } from "d3";
+// src/charts/signals/CepstrumChart.ts
+var CepstrumKind = /* @__PURE__ */ function(CepstrumKind) {
+	CepstrumKind["Real"] = "real";
+	CepstrumKind["Power"] = "power";
+	return CepstrumKind;
+}({});
+var CepstrumAxis = /* @__PURE__ */ function(CepstrumAxis) {
+	CepstrumAxis["Quefrency"] = "quefrency";
+	CepstrumAxis["Pitch"] = "pitch";
+	return CepstrumAxis;
+}({});
+var CepstrumMark = /* @__PURE__ */ function(CepstrumMark) {
+	CepstrumMark["Line"] = "line";
+	CepstrumMark["Area"] = "area";
+	CepstrumMark["Stem"] = "stem";
+	return CepstrumMark;
+}({});
+/** The spectrum of a log spectrum: separates pitch and echoes from spectral shape. */
+var CepstrumChart = class extends SignalChart {
+	static meta = {
+		id: "signal-cepstrum",
+		name: "Cepstrum",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Takes the spectrum of a log spectrum, so harmonic spacing shows as one peak that gives pitch or echo delay.",
+		tags: [
+			"quefrency",
+			"pitch detection",
+			"liftering",
+			"echo"
+		],
+		sample: (seed) => SignalSamples.voiced(seed),
+		variants: {
+			kind: Object.values(CepstrumKind),
+			axis: Object.values(CepstrumAxis),
+			mark: Object.values(CepstrumMark),
+			lifter: [true, false]
+		},
+		valid: (values) => values.axis === "quefrency" || values.lifter === false
+	};
+	constructor(options) {
+		super({
+			xLabel: options.axis === "pitch" ? "Pitch (Hz)" : "Quefrency (ms)",
+			yLabel: options.kind === "power" ? "Power cepstrum" : "Cepstrum",
+			...options
+		});
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			kind: "real",
+			axis: "quefrency",
+			mark: "line",
+			lifter: true,
+			pitchRange: [60, 800]
+		};
+	}
+	get pitched() {
+		return this.options.axis === "pitch";
+	}
+	points(channel = this.first) {
+		const [low, high] = this.options.pitchRange, values = SignalDsp.cepstrum(channel.v, this.options.kind === "power");
+		const least = Math.floor(channel.rate / high / (this.pitched ? 1 : 4)), most = Math.ceil(channel.rate / low);
+		return values.slice(least, most).map((value, i) => ({
+			key: i + least,
+			quefrency: (i + least) / channel.rate,
+			value
+		}));
+	}
+	/** Strongest quefrency inside the pitch search range. */
+	pitchPeak(points) {
+		const [low, high] = this.options.pitchRange;
+		return points.filter((point) => point.quefrency >= 1 / high && point.quefrency <= 1 / low).reduce((best, point) => !best || point.value > best.value ? point : best, void 0);
+	}
+	place(point) {
+		return this.pitched ? 1 / point.quefrency : point.quefrency * 1e3;
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, points = this.channels.flatMap((channel) => this.points(channel)), [low, high] = this.options.pitchRange;
+		const domainTop = Math.max(...points.map((point) => point.value), 1e-9), bottom = this.options.kind === "power" ? 0 : Math.min(0, ...points.map((point) => point.value));
+		const y = scaleLinear([bottom, domainTop * 1.12], [height, 0]).nice(4);
+		if (this.pitched) {
+			const x = scaleLog([low, high], [0, width]);
+			return {
+				x: SignalScales.labelled(x, SignalScales.sparse(x, low, high), SignalScales.hertz),
+				y
+			};
+		}
+		return {
+			x: scaleLinear([points[0]?.quefrency * 1e3 || 0, (points[points.length - 1]?.quefrency ?? .02) * 1e3], [0, width]),
+			y
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { mark, lifter, pitchRange } = this.options, { width, height } = ctx.plot, base = y(0);
+		const traces = this.channels.map((channel) => ({
+			name: channel.name,
+			color: ctx.palette.color(channel.name),
+			points: this.points(channel)
+		}));
+		if (lifter && !this.pitched) {
+			const edge = x(1e3 / pitchRange[1]);
+			ctx.marks("lifter", "rect", [0]).attr("x", 0).attr("y", 0).attr("height", height).attr("fill", ctx.theme.grid).attr("opacity", .55).attr("width", Math.max(0, Math.min(width, edge)));
+			if (edge > 60) ctx.text(ctx.marks("lifter-text", "text", [0]).attr("x", 5).attr("y", height - 6).text("Spectral shape"), 10, "muted");
+		}
+		this.rule(ctx, "zero", [0], y);
+		if (mark === "stem") {
+			const stride = Math.max(1, Math.ceil((traces[0]?.points.length ?? 1) / (width / 5)));
+			const strongest = (points) => points.filter((_, i) => i % stride === 0).map((_, n) => points.slice(n * stride, (n + 1) * stride).reduce((best, point) => Math.abs(point.value) > Math.abs(best.value) ? point : best));
+			const rods = traces.flatMap((trace) => strongest(trace.points).map((point) => ({
+				point,
+				trace
+			})));
+			const marks = ctx.marks("rods", "line", rods, (rod) => `${rod.trace.name}${rod.point.key}`).attr("stroke", (rod) => rod.trace.color).attr("stroke-width", 2);
+			ctx.set(marks, {
+				x1: (rod) => x(this.place(rod.point)),
+				x2: (rod) => x(this.place(rod.point)),
+				y1: base,
+				y2: (rod) => y(rod.point.value)
+			}, { y2: base }, 2);
+			ctx.hover(marks, (rod) => ({
+				title: `${SignalScales.number(rod.point.quefrency * 1e3)} ms`,
+				color: rod.trace.color,
+				rows: [[rod.trace.name, SignalScales.number(rod.point.value)]]
+			}));
+		} else {
+			const ordered = (points) => [...points].sort((a, b) => this.place(a) - this.place(b)).filter((point) => {
+				const at = this.place(point);
+				return at >= x.domain()[0] && at <= x.domain()[1];
+			});
+			if (mark === "area") {
+				const shape = area().x((point) => x(this.place(point))).y0(base).y1((point) => y(point.value));
+				this.fill(ctx, "fill", traces, (trace) => trace.name, (trace) => shape(ordered(trace.points)) ?? "", (trace) => trace.color, .25);
+			}
+			this.stroke(ctx, "line", traces, (trace) => trace.name, (trace) => this.path(ordered(trace.points).map((point) => [this.place(point), point.value]), x, y), (trace) => trace.color, 1.5);
+		}
+		const top = traces[0] && this.pitchPeak(traces[0].points);
+		if (top) {
+			const px = x(this.place(top)), py = y(top.value), flip = px > width - 130;
+			const dot = ctx.marks("pitch", "circle", [0]).attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+			ctx.set(dot, {
+				cx: px,
+				cy: py,
+				r: 4
+			}, { r: 0 });
+			ctx.hover(dot, () => ({
+				title: "Pitch",
+				rows: [["Frequency", `${SignalScales.hertz(1 / top.quefrency)} Hz`], ["Quefrency", `${SignalScales.number(top.quefrency * 1e3)} ms`]]
+			}));
+			ctx.text(ctx.marks("pitch-text", "text", [0]).attr("x", px + (flip ? -9 : 9)).attr("y", Math.max(11, py + 4)).attr("text-anchor", flip ? "end" : "start").text(`Pitch ${SignalScales.hertz(1 / top.quefrency)} Hz`), 11, "ink");
+		}
+	}
+};
+export { CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark };