@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/engineering/SParameterChart.js

@@ -0,0 +1,214 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { EngineeringChart } from "./EngineeringChart.js";
+import { sampleSParameters } from "./SParameterData.js";
+import { format, quantile } from "d3";
+// src/charts/engineering/SParameterChart.ts
+var SParameterView = /* @__PURE__ */ function(SParameterView) {
+	SParameterView["Decibel"] = "decibel";
+	SParameterView["Ratio"] = "ratio";
+	SParameterView["Phase"] = "phase";
+	SParameterView["GroupDelay"] = "group-delay";
+	SParameterView["ReturnLoss"] = "return-loss";
+	SParameterView["Vswr"] = "vswr";
+	return SParameterView;
+}({});
+var SParameterLayout = /* @__PURE__ */ function(SParameterLayout) {
+	SParameterLayout["Overlay"] = "overlay";
+	SParameterLayout["Matrix"] = "port-matrix";
+	return SParameterLayout;
+}({});
+var RATIO_VIEWS = ["decibel", "ratio"];
+var REFLECTION_VIEWS = ["return-loss", "vswr"];
+var isReflection = (name) => {
+	const m = /(\d)(\d)$/.exec(name);
+	return !m || m[1] === m[2];
+};
+var TITLES = {
+	["decibel"]: "Magnitude (dB)",
+	["ratio"]: "Magnitude",
+	["phase"]: "Phase (deg)",
+	["group-delay"]: "Group delay (s)",
+	["return-loss"]: "Return loss (dB)",
+	["vswr"]: "VSWR"
+};
+/** Characterise a network from a Touchstone sweep: gain, match, phase, group delay. */
+var SParameterChart = class extends EngineeringChart {
+	static meta = {
+		id: "s-parameter-chart",
+		name: "S-parameter chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots scattering parameters against frequency as magnitude, phase, group delay or VSWR.",
+		tags: [
+			"rf",
+			"network analyzer",
+			"touchstone",
+			"filter",
+			"insertion loss",
+			"return loss"
+		],
+		sample: sampleSParameters,
+		variants: {
+			view: Object.values(SParameterView),
+			layout: ["overlay", "port-matrix"],
+			frequencyScale: [ScaleKind.Linear, ScaleKind.Log],
+			bandEdges: [true, false]
+		},
+		valid: (v) => {
+			if (v.bandEdges && !RATIO_VIEWS.includes(v.view)) return false;
+			return !(REFLECTION_VIEWS.includes(v.view) && v.layout === "port-matrix");
+		}
+	};
+	defaults() {
+		return {
+			frequency: "frequency",
+			parameter: "parameter",
+			real: "real",
+			imaginary: "imaginary",
+			view: "decibel",
+			layout: "overlay",
+			frequencyScale: ScaleKind.Linear,
+			bandEdges: true
+		};
+	}
+	sweeps() {
+		const { frequency, parameter, real, imaginary, view } = this.options;
+		const reflections = REFLECTION_VIEWS.includes(view);
+		return this.series(parameter).filter(([name]) => !reflections || isReflection(name)).map(([name, rows]) => {
+			const raw = rows.map((row) => ({
+				frequency: this.num(row, frequency),
+				re: this.num(row, real),
+				im: this.num(row, imaginary)
+			})).filter((r) => r.frequency > 0 && Number.isFinite(r.re) && Number.isFinite(r.im)).sort((a, b) => a.frequency - b.frequency);
+			let turn = 0, last = 0;
+			const phase = raw.map((r, i) => {
+				const angle = Math.atan2(r.im, r.re) * 180 / Math.PI;
+				if (i) turn += 360 * Math.round((last - angle - turn) / 360);
+				last = angle + turn;
+				return last;
+			});
+			const value = (i) => {
+				const size = Math.hypot(raw[i].re, raw[i].im);
+				switch (view) {
+					case "ratio": return size;
+					case "phase": return phase[i];
+					case "return-loss": return -20 * Math.log10(size);
+					case "vswr": return size < 1 ? (1 + size) / (1 - size) : NaN;
+					case "group-delay": {
+						const a = Math.max(0, i - 1), b = Math.min(raw.length - 1, i + 1);
+						return b === a ? NaN : -((phase[b] - phase[a]) / 360) / (raw[b].frequency - raw[a].frequency);
+					}
+					default: return 20 * Math.log10(size);
+				}
+			};
+			return {
+				name,
+				samples: raw.map((r, i) => ({
+					name,
+					frequency: r.frequency,
+					value: value(i),
+					decibel: 20 * Math.log10(Math.hypot(r.re, r.im))
+				}))
+			};
+		}).filter((sweep) => sweep.samples.length);
+	}
+	/** Spiky views keep the middle of the data on the axis, so one notch cannot flatten a sweep. */
+	range(values) {
+		const { view } = this.options;
+		if (view === "vswr" || view === "group-delay") {
+			const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+			if (view === "vswr") return [1, Math.min(10, quantile(sorted, 1) ?? 10)];
+			return [Math.min(0, quantile(sorted, .02) ?? 0), (quantile(sorted, .92) ?? 1) * 1.15];
+		}
+		return this.span(values, { pad: .04 });
+	}
+	panel(ctx, sweeps, x, y, bare) {
+		const width = Math.max(...x.range()), height = Math.max(...y.range());
+		const { view, bandEdges, xLabel, yLabel } = this.options;
+		this.frame(ctx, {
+			x,
+			y,
+			hideX: bare.hideX,
+			hideY: bare.hideY,
+			xTitle: xLabel ?? "Frequency (Hz)",
+			yTitle: yLabel ?? TITLES[view]
+		});
+		const at = (s) => this.within([[x(s.frequency), y(s.value)]], width, height)[0];
+		this.traces(ctx, "sweeps", sweeps.map((sweep) => ({
+			key: sweep.name,
+			color: ctx.palette.color(sweep.name),
+			points: sweep.samples.map(at)
+		})));
+		const tip = (s) => ({
+			title: s.name,
+			color: ctx.palette.color(s.name),
+			rows: [["Frequency", `${format(".4~s")(s.frequency)}Hz`], [TITLES[view], s.value.toPrecision(4)]]
+		});
+		sweeps.forEach((sweep, i) => this.probes(ctx, `probe-${i}`, sweep.samples, at, tip));
+		if (bandEdges) {
+			const edges = sweeps.filter((sweep) => !isReflection(sweep.name)).slice(0, 1).flatMap((sweep) => {
+				const peak = Math.max(...sweep.samples.map((s) => s.decibel));
+				return sweep.samples.filter((s, i) => {
+					const b = sweep.samples[i - 1];
+					return b && (s.decibel - peak + 3) * (b.decibel - peak + 3) < 0;
+				});
+			});
+			this.dots(ctx, "band-edges", edges, at, (s) => ctx.palette.color(s.name), tip, 4);
+			this.annotate(ctx, "band-note", edges.length > 1 ? [{
+				key: "bw",
+				text: `BW ${format(".3~s")(edges[edges.length - 1].frequency - edges[0].frequency)}Hz`,
+				x: x((edges[0].frequency + edges[edges.length - 1].frequency) / 2),
+				y: 14,
+				anchor: "middle",
+				tone: "ink"
+			}] : [], {
+				width,
+				height
+			});
+		}
+		if (bare.label) this.annotate(ctx, "panel-label", [{
+			key: "l",
+			text: bare.label,
+			x: width - 4,
+			y: height - 6,
+			anchor: "end",
+			tone: "ink"
+		}], {
+			width,
+			height
+		});
+	}
+	draw(ctx) {
+		const { layout, frequencyScale } = this.options;
+		const { width, height } = ctx.plot;
+		const sweeps = this.sweeps();
+		const log = frequencyScale === ScaleKind.Log;
+		const frequencies = sweeps.flatMap((s) => s.samples.map((p) => p.frequency));
+		const domain = this.span(frequencies, { log });
+		const values = this.range(sweeps.flatMap((s) => s.samples.map((p) => p.value)));
+		const vertical = Scales.continuous(ScaleKind.Linear);
+		if (layout === "overlay") {
+			this.panel(ctx, sweeps, Scales.continuous(frequencyScale).domain(domain).range([0, width]), vertical.domain(values).range([height, 0]).nice(), {
+				hideX: false,
+				hideY: false
+			});
+			return;
+		}
+		const ports = Math.max(1, Math.ceil(Math.sqrt(sweeps.length)));
+		const gap = 20;
+		const w = (width - gap * (ports - 1)) / ports, h = (height - gap * (ports - 1)) / ports;
+		const x = Scales.continuous(frequencyScale).domain(domain).range([0, w]);
+		const y = vertical.domain(values).range([h, 0]).nice();
+		[...sweeps].sort((a, b) => a.name.localeCompare(b.name)).forEach((sweep, i) => {
+			const column = i % ports, row = Math.floor(i / ports);
+			this.panel(ctx.nest(`translate(${column * (w + gap)},${row * (h + gap)})`, `port-${i}`), [sweep], x, y, {
+				hideX: row < ports - 1,
+				hideY: column > 0,
+				label: sweep.name
+			});
+		});
+	}
+};
+export { SParameterChart, SParameterLayout, SParameterView };

package/dist/charts/engineering/SParameterData.js

@@ -0,0 +1,69 @@
+import { SampleData } from "../../data/SampleData.js";
+import { ComplexMath } from "./ComplexMath.js";
+// src/charts/engineering/SParameterData.ts
+var { add, div, mul } = ComplexMath;
+var cascade = (m, n) => [
+	add(mul(m[0], n[0]), mul(m[1], n[2])),
+	add(mul(m[0], n[1]), mul(m[1], n[3])),
+	add(mul(m[2], n[0]), mul(m[3], n[2])),
+	add(mul(m[2], n[1]), mul(m[3], n[3]))
+];
+/** `{ frequency, parameter, real, imaginary }` for a slightly lossy third-order band-pass filter. */
+function sampleSParameters(seed) {
+	const [a, b] = SampleData.points(seed, 2, 1).map((row) => (+row.size - 3) / 30);
+	const center = 2e9 * (.95 + .1 * a), fraction = .25, z0 = 50, w0 = 2 * Math.PI * center;
+	const sections = [
+		{
+			g: 1,
+			series: true
+		},
+		{
+			g: 2 * (.92 + .16 * b),
+			series: false
+		},
+		{
+			g: 1.15,
+			series: true
+		}
+	];
+	return Array.from({ length: 161 }, (_, i) => 1e9 + i * 125e5).flatMap((frequency) => {
+		const w = 2 * Math.PI * frequency;
+		const detune = w / (w0 * fraction) - w0 / (w * fraction);
+		const m = sections.reduce((product, { g, series }) => {
+			const element = [.012 * g, g * detune];
+			return cascade(product, series ? [
+				[1, 0],
+				[element[0] * z0, element[1] * z0],
+				[0, 0],
+				[1, 0]
+			] : [
+				[1, 0],
+				[0, 0],
+				[element[0] / z0, element[1] / z0],
+				[1, 0]
+			]);
+		}, [
+			[1, 0],
+			[0, 0],
+			[0, 0],
+			[1, 0]
+		]);
+		const b1 = [m[1][0] / z0, m[1][1] / z0], c1 = [m[2][0] * z0, m[2][1] * z0];
+		const delta = add(add(m[0], b1), add(c1, m[3]));
+		const s11 = div([m[0][0] + b1[0] - c1[0] - m[3][0], m[0][1] + b1[1] - c1[1] - m[3][1]], delta);
+		const s22 = div([-m[0][0] + b1[0] - c1[0] + m[3][0], -m[0][1] + b1[1] - c1[1] + m[3][1]], delta);
+		const s21 = div([2, 0], delta);
+		return [
+			["S11", s11],
+			["S21", s21],
+			["S12", s21],
+			["S22", s22]
+		].map(([parameter, [real, imaginary]]) => ({
+			frequency,
+			parameter,
+			real,
+			imaginary
+		}));
+	});
+}
+export { sampleSParameters };

package/dist/charts/engineering/SPlaneChart.js

@@ -0,0 +1,71 @@
+import { EngineeringChart } from "./EngineeringChart.js";
+// src/charts/engineering/SPlaneChart.ts
+/** Shared by charts that read pole-zero rows: root parsing, symbols and damping guides. */
+var SPlaneChart = class extends EngineeringChart {
+	defaults() {
+		return {
+			real: "real",
+			imaginary: "imaginary",
+			kind: "kind",
+			system: "system"
+		};
+	}
+	roots() {
+		const { real, imaginary, kind, system } = this.options;
+		return this.rows.map((row) => ({
+			real: this.num(row, real),
+			imaginary: this.num(row, imaginary) || 0,
+			kind: String(row[kind]).toLowerCase().startsWith("z") ? "zero" : "pole",
+			system: String(row[system] ?? "System")
+		})).filter((root) => Number.isFinite(root.real));
+	}
+	symbol(root, [x, y], size = 5.5) {
+		return root.kind === "pole" ? `M${x - size},${y - size}L${x + size},${y + size}M${x - size},${y + size}L${x + size},${y - size}` : `M${x - size},${y}a${size},${size} 0 1,0 ${size * 2},0a${size},${size} 0 1,0 ${-size * 2},0Z`;
+	}
+	/** Hollow zeros, crossed poles; both in stroke so overlapping roots stay legible. */
+	rootMarks(ctx, name, roots, seat, stroke = (root) => ctx.palette.color(root.system)) {
+		const marks = ctx.marks(name, "path", roots.filter((root) => seat(root).every(Number.isFinite))).attr("fill", ctx.theme.surface).attr("fill-opacity", (d) => d.kind === "zero" ? 1 : 0).attr("stroke", stroke).attr("stroke-width", 2.2).attr("stroke-linecap", "round");
+		ctx.set(marks, { d: (d) => this.symbol(d, seat(d)) }, { d: (d) => this.symbol(d, seat(d)) });
+		ctx.hover(marks, (d) => ({
+			title: `${d.kind === "pole" ? "Pole" : "Zero"}, ${d.system}`,
+			color: stroke(d),
+			rows: [
+				["Real", d.real.toFixed(3)],
+				["Imaginary", d.imaginary.toFixed(3)],
+				["Natural frequency", Math.hypot(d.real, d.imaginary).toFixed(3)],
+				["Damping", (Math.hypot(d.real, d.imaginary) ? -d.real / Math.hypot(d.real, d.imaginary) : 0).toFixed(3)]
+			]
+		}));
+	}
+	/** Lines of constant damping ratio and arcs of constant natural frequency, in the s-plane. */
+	dampingGrid(reach) {
+		const rays = [
+			.2,
+			.4,
+			.6,
+			.8
+		].flatMap((zeta) => [1, -1].map((sign) => {
+			const angle = Math.acos(zeta);
+			return {
+				key: `z${sign}${zeta}`,
+				label: sign > 0 ? `ζ ${zeta}` : "",
+				points: Array.from({ length: 40 }, (_, i) => [-(i * reach / 39) * zeta, sign * (i * reach) / 39 * Math.sin(angle)])
+			};
+		}));
+		const arcs = [
+			.25,
+			.5,
+			.75,
+			1
+		].map((share) => ({
+			key: `w${share}`,
+			label: "",
+			points: Array.from({ length: 49 }, (_, i) => {
+				const angle = Math.PI / 2 + i * Math.PI / 48;
+				return [share * reach * Math.cos(angle), share * reach * Math.sin(angle)];
+			})
+		}));
+		return [...rays, ...arcs];
+	}
+};
+export { SPlaneChart };

package/dist/charts/engineering/SmithChart.js

@@ -0,0 +1,259 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ComplexMath } from "./ComplexMath.js";
+import { EngineeringChart, engineeringTick } from "./EngineeringChart.js";
+import { sampleSParameters } from "./SParameterData.js";
+// src/charts/engineering/SmithChart.ts
+var SmithGrid = /* @__PURE__ */ function(SmithGrid) {
+	SmithGrid["Impedance"] = "impedance";
+	SmithGrid["Admittance"] = "admittance";
+	SmithGrid["Immittance"] = "immittance";
+	return SmithGrid;
+}({});
+var SmithDensity = /* @__PURE__ */ function(SmithDensity) {
+	SmithDensity["Standard"] = "standard";
+	SmithDensity["Fine"] = "fine";
+	return SmithDensity;
+}({});
+var SmithMarks = /* @__PURE__ */ function(SmithMarks) {
+	SmithMarks["Line"] = "line";
+	SmithMarks["Dots"] = "dots";
+	SmithMarks["LineDots"] = "line-dots";
+	return SmithMarks;
+}({});
+var toGamma = (z) => ComplexMath.div(ComplexMath.sub(z, [1, 0]), ComplexMath.add(z, [1, 0]));
+var SWEEP = Array.from({ length: 90 }, (_, i) => i ? 10 ** (-2.2 + i * .06) : 0);
+/** Match RF impedances: reflection data over the normalised circles of constant resistance and reactance. */
+var SmithChart = class extends EngineeringChart {
+	static meta = {
+		id: "smith-chart",
+		name: "Smith chart",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Maps reflection coefficients onto impedance and admittance circles for RF matching.",
+		tags: [
+			"rf",
+			"impedance",
+			"matching",
+			"reflection",
+			"vswr"
+		],
+		sample: (seed) => sampleSParameters(seed).filter((row) => row.parameter === "S11" || row.parameter === "S22"),
+		variants: {
+			gridType: [
+				"impedance",
+				"admittance",
+				"immittance"
+			],
+			density: ["standard", "fine"],
+			marks: [
+				"line",
+				"dots",
+				"line-dots"
+			],
+			vswr: [2, 0],
+			sweepEnds: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			real: "real",
+			imaginary: "imaginary",
+			frequency: "frequency",
+			series: "parameter",
+			gridType: "impedance",
+			density: "standard",
+			marks: "line",
+			vswr: 2,
+			sweepEnds: true
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 16,
+			bottom: 8,
+			left: 16
+		};
+	}
+	family(key, values, draw, at) {
+		return values.map((value) => ({
+			key: `${key}${value}`,
+			points: SWEEP.map((along) => at(toGamma(draw(value, along))))
+		}));
+	}
+	circles(ctx, name, at, resistance, reactance, dash) {
+		const lines = [
+			...this.family("r", resistance, (r, x) => [r, x], at),
+			...this.family("s", resistance, (r, x) => [r, -x], at),
+			...this.family("x", reactance, (x, r) => [r, x], at),
+			...this.family("y", reactance, (x, r) => [r, -x], at)
+		];
+		this.guides(ctx, name, lines.map((guide) => ({
+			...guide,
+			dash
+		})));
+		ctx.group(name).attr("opacity", .75);
+	}
+	draw(ctx) {
+		const { real, imaginary, frequency, series, gridType, density, marks, vswr, sweepEnds } = this.options;
+		const radius = Math.min(ctx.plot.width, ctx.plot.height) / 2 - 16;
+		const cx = ctx.plot.width / 2, cy = ctx.plot.height / 2;
+		const at = ([re, im]) => [cx + re * radius, cy - im * radius];
+		const flip = ([re, im]) => [-re, -im];
+		const fine = density === "fine";
+		const resistance = fine ? [
+			.1,
+			.2,
+			.35,
+			.5,
+			.75,
+			1,
+			1.5,
+			2,
+			3,
+			5,
+			10
+		] : [
+			.2,
+			.5,
+			1,
+			2,
+			5
+		];
+		const reactance = fine ? [
+			.1,
+			.2,
+			.35,
+			.5,
+			.75,
+			1,
+			1.5,
+			2,
+			3,
+			5,
+			10
+		] : [
+			.2,
+			.5,
+			1,
+			2,
+			5
+		];
+		this.shapes(ctx, "disc", [{
+			key: "disc",
+			fill: ctx.theme.grid,
+			opacity: .22,
+			d: `M${cx - radius},${cy}a${radius},${radius} 0 1,0 ${radius * 2},0a${radius},${radius} 0 1,0 ${-radius * 2},0Z`
+		}]);
+		if (gridType !== "admittance") this.circles(ctx, "impedance-grid", at, resistance, reactance);
+		if (gridType !== "impedance") this.circles(ctx, "admittance-grid", (g) => at(flip(g)), resistance, reactance, gridType === "immittance" ? "2 3" : void 0);
+		const ring = (r) => Array.from({ length: 145 }, (_, i) => at(ComplexMath.polar(r, i * Math.PI / 72)));
+		this.guides(ctx, "rim", [{
+			key: "rim",
+			points: ring(1)
+		}, {
+			key: "axis",
+			points: [[cx - radius, cy], [cx + radius, cy]]
+		}]);
+		const swr = vswr > 1 ? (vswr - 1) / (vswr + 1) : 0;
+		if (swr) this.traces(ctx, "vswr", [{
+			key: "vswr",
+			color: ctx.theme.inkMuted,
+			width: 1.5,
+			dash: "6 4",
+			points: ring(swr)
+		}]);
+		const yGrid = gridType === "admittance";
+		const mirrored = (g) => yGrid ? flip(g) : g;
+		const scaleLabels = [
+			.2,
+			.5,
+			1,
+			2,
+			5
+		];
+		this.annotate(ctx, "grid-notes", [
+			...scaleLabels.map((r) => {
+				const p = at(mirrored(toGamma([r, 0])));
+				return {
+					key: `r${r}`,
+					text: `${r}`,
+					x: p[0] + 2,
+					y: p[1] - 3,
+					tone: "muted",
+					size: 9
+				};
+			}),
+			...scaleLabels.flatMap((x) => [1, -1].map((sign) => {
+				const g = mirrored(toGamma([0, sign * x])), angle = ComplexMath.arg(g), p = at(ComplexMath.polar(1 + 9 / radius, angle));
+				return {
+					key: `x${sign * x}`,
+					text: `${sign < 0 ? "−" : ""}${x}j`,
+					x: p[0],
+					y: p[1] + 3,
+					anchor: "middle",
+					tone: "muted",
+					size: 9
+				};
+			})),
+			...swr ? [{
+				key: "vswr",
+				text: `VSWR ${vswr}`,
+				x: at([0, -swr])[0],
+				y: at([0, -swr])[1] + 12,
+				anchor: "middle",
+				tone: "muted",
+				size: 10
+			}] : []
+		]);
+		const groups = this.series(series).map(([name, rows]) => ({
+			name,
+			points: rows.map((row) => ({
+				name,
+				frequency: this.num(row, frequency),
+				gamma: [this.num(row, real), this.num(row, imaginary)]
+			})).filter((p) => Number.isFinite(p.gamma[0]) && Number.isFinite(p.gamma[1])).sort((a, b) => a.frequency - b.frequency)
+		})).filter((g) => g.points.length);
+		const seat = (p) => at(p.gamma);
+		const tip = (p) => {
+			const z = ComplexMath.div(ComplexMath.add([1, 0], p.gamma), ComplexMath.sub([1, 0], p.gamma));
+			return {
+				title: p.name,
+				color: ctx.palette.color(p.name),
+				rows: [
+					["Frequency", Number.isFinite(p.frequency) ? engineeringTick(p.frequency) : "–"],
+					["Z/Z0", `${z[0].toFixed(2)} ${z[1] < 0 ? "−" : "+"} ${Math.abs(z[1]).toFixed(2)}j`],
+					["|Γ|", ComplexMath.abs(p.gamma).toFixed(3)]
+				]
+			};
+		};
+		if (marks !== "dots") this.traces(ctx, "sweeps", groups.map((g) => ({
+			key: g.name,
+			color: ctx.palette.color(g.name),
+			points: g.points.map(seat)
+		})));
+		if (marks !== "line") {
+			const stride = (g) => g.points.filter((_, i) => i % Math.max(1, Math.floor(g.points.length / 20)) === 0);
+			this.dots(ctx, "sweep-dots", groups.flatMap(stride), seat, (p) => ctx.palette.color(p.name), tip, 4);
+		}
+		if (sweepEnds) {
+			const ends = groups.flatMap((g) => [g.points[0], g.points[g.points.length - 1]]);
+			this.dots(ctx, "sweep-ends", ends, seat, () => ctx.theme.ink, tip, 3.5);
+			this.annotate(ctx, "sweep-notes", groups.slice(0, 1).flatMap((g) => [g.points[0], g.points[g.points.length - 1]].filter((p) => Number.isFinite(p.frequency)).map((p, i) => {
+				const [x, y] = seat(p);
+				return {
+					key: `${i}`,
+					text: engineeringTick(p.frequency),
+					x: x + (x > cx ? -8 : 8),
+					y: y + (i ? 14 : -7),
+					anchor: x > cx ? "end" : "start",
+					tone: "ink",
+					size: 10
+				};
+			})));
+		}
+		groups.forEach((g, i) => this.probes(ctx, `probe-${i}`, g.points, seat, tip));
+	}
+};
+export { SmithChart, SmithDensity, SmithGrid, SmithMarks };