prographs 0.12.0 → 0.13.0

package/dist/charts/signals/AntennaPatternChart.js

@@ -0,0 +1,492 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { TextFit } from "../../core/TextFit.js";
+import { SignalParser } from "./SignalChart.js";
+import { SignalAmplitude } from "./SignalEnums.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { scaleLinear } from "d3";
+// src/charts/signals/AntennaPatternChart.ts
+var AntennaPatternForm = /* @__PURE__ */ function(AntennaPatternForm) {
+	AntennaPatternForm["Polar"] = "polar";
+	AntennaPatternForm["Rectangular"] = "rectangular";
+	return AntennaPatternForm;
+}({});
+var RAD = Math.PI / 180;
+var CHAR = 5.7;
+var ROW = 12;
+var DOT = 4;
+/** A side lobe must stand this far above the null before it, in dB, so ripple on the main lobe is not taken for one. */
+var PROMINENCE = 1;
+var HALF_POWER = 3;
+var RING_LABELS_AT = 105;
+/** Least width left for the plot once the figures are listed beside it. */
+var LEAST_PLOT = 190;
+/** Room beside a dial for its angle labels. */
+var RIM = 34;
+var wrap = (angle) => ((angle + 180) % 360 + 360) % 360 - 180;
+var degrees = (angle) => `${+wrap(angle).toFixed(1)}°`;
+/**
+* Where an antenna sends its power: gain against angle through one plane, round a polar plot or along straight axes.
+* Use it to compare the E-plane and H-plane cuts and to read beamwidth, side-lobe level and front-to-back ratio. For the whole sphere use the 3D polar surface.
+*/
+var AntennaPatternChart = class AntennaPatternChart extends Chart2D {
+	static meta = {
+		id: "signal-antenna-pattern",
+		name: "Antenna radiation pattern",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots antenna gain in dB against angle for one or more cuts, normalised to the peak, on a polar or a rectangular plot, with the main lobe, half-power beamwidth, first side-lobe level and front-to-back ratio marked.",
+		tags: [
+			"antenna",
+			"rf",
+			"radiation pattern",
+			"beamwidth",
+			"side lobe",
+			"front-to-back",
+			"e-plane",
+			"h-plane",
+			"polar"
+		],
+		sample: (seed) => SignalSamples.antenna(seed),
+		variants: {
+			form: Object.values(AntennaPatternForm),
+			amplitude: Object.values(SignalAmplitude),
+			normalize: [true, false],
+			metrics: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			x: "angle",
+			y: "gain",
+			series: "cut",
+			form: "polar",
+			amplitude: SignalAmplitude.Decibel,
+			normalize: true,
+			metrics: true,
+			range: 40
+		};
+	}
+	plotMargin() {
+		return {
+			top: 8,
+			right: 12,
+			bottom: 8,
+			left: 12
+		};
+	}
+	/** True when sorted angles go all the way round, leaving no gap wider than their usual step. */
+	static closed(angles) {
+		const n = angles.length;
+		return n > 2 && 360 - (angles[n - 1] - angles[0]) <= 1.5 * (angles[n - 1] - angles[0]) / (n - 1);
+	}
+	/** Gain at `angle`, read between the two nearest samples and across the seam of a cut that goes all the way round. `null` outside an open cut. */
+	static gainAt(angles, gains, angle) {
+		const n = Math.min(angles.length, gains.length), after = angles.findIndex((value) => value >= angle), b = after < 0 ? 0 : after, a = (b + n - 1) % n;
+		if (!n) return null;
+		if (angles[b] === angle) return gains[b];
+		if (after <= 0 && !AntennaPatternChart.closed(angles)) return null;
+		const from = angles[a] - (after === 0 ? 360 : 0), to = angles[b] + (after < 0 ? 360 : 0);
+		return gains[a] + (gains[b] - gains[a]) * (angle - from) / (to - from || 1);
+	}
+	/**
+	* Peak, half-power points, first side lobe and front-to-back ratio of a cut whose `angles` are sorted, in degrees from -180.
+	* Each side is walked out from the peak: to the first sample 3 dB down, then past the first null to the next maximum.
+	*/
+	static metrics(angles, gains) {
+		const n = Math.min(angles.length, gains.length), closed = AntennaPatternChart.closed(angles);
+		if (!n) return null;
+		let top = 0;
+		for (let i = 1; i < n; i++) if (gains[i] > gains[top]) top = i;
+		const peak = gains[top], reach = closed ? Math.floor(n / 2) : n - 1;
+		const has = (k) => closed || top + k >= 0 && top + k < n, gain = (k) => gains[((top + k) % n + n) % n];
+		const angle = (k) => angles[((top + k) % n + n) % n] + 360 * Math.floor((top + k) / n);
+		const edge = (side) => {
+			for (let k = 1; k <= reach && has(side * k); k++) {
+				if (gain(side * k) > peak - HALF_POWER) continue;
+				const before = gain(side * (k - 1)), t = (before - (peak - HALF_POWER)) / (before - gain(side * k));
+				return angle(side * (k - 1)) + (angle(side * k) - angle(side * (k - 1))) * t;
+			}
+			return null;
+		};
+		const lobe = (side) => {
+			let low = peak, best = 0;
+			for (let k = 1; k <= reach && has(side * k); k++) {
+				const here = gain(side * k);
+				if (!best) {
+					if (here < low) low = here;
+					else if (low <= peak - HALF_POWER && here > low + PROMINENCE) best = k;
+				} else if (here > gain(side * best)) best = k;
+				else if (here < gain(side * best) - PROMINENCE) break;
+			}
+			return best ? [{
+				angle: wrap(angle(side * best)),
+				level: gain(side * best) - peak
+			}] : [];
+		};
+		const left = edge(-1), right = edge(1), behind = wrap(angles[top] + 180), rear = AntennaPatternChart.gainAt(angles, gains, behind);
+		return {
+			peak,
+			peakAngle: angles[top],
+			halfPower: left === null || right === null ? null : [left, right],
+			sideLobe: [...lobe(-1), ...lobe(1)].sort((a, b) => b.level - a.level)[0] ?? null,
+			back: rear === null ? null : {
+				angle: behind,
+				ratio: peak - rear
+			}
+		};
+	}
+	/** One cut per name, in the order the names first appear. */
+	get cuts() {
+		const { data, x, y, series } = this.options;
+		const rows = (Array.isArray(data) ? data : []).flatMap((row) => {
+			const cell = row === null || typeof row !== "object" ? null : row[x], turned = typeof cell === "number" || typeof cell === "string" && cell.trim() ? +cell : NaN;
+			return Number.isFinite(turned) ? [{
+				angle: wrap(turned),
+				gain: row[y],
+				cut: row[series] ?? "Pattern"
+			}] : [];
+		});
+		return SignalParser.channels(rows, "angle", "gain", "cut").flatMap(({ name, t, v }) => {
+			const metrics = AntennaPatternChart.metrics(t, v);
+			return metrics ? [{
+				name,
+				angles: t,
+				gains: v,
+				closed: AntennaPatternChart.closed(t),
+				metrics
+			}] : [];
+		});
+	}
+	/** Maps gain onto 0 to 1 from the bottom of the scale to its top, with the levels to rule and label. */
+	#levels(cuts) {
+		const { amplitude, normalize, range } = this.options;
+		const peak = cuts.length ? Math.max(...cuts.map((cut) => cut.metrics.peak)) : 0, base = normalize ? peak : 0;
+		const clamp = (value) => Math.max(0, Math.min(1, value));
+		if (amplitude === SignalAmplitude.Linear) {
+			const scale = scaleLinear([0, normalize ? 1 : 10 ** (peak / 10)], [0, 1]);
+			if (!normalize) scale.nice(4);
+			return {
+				unit: (gain) => clamp(scale(10 ** ((gain - base) / 10))),
+				ticks: scale.ticks(4).map((tick) => ({
+					at: scale(tick),
+					text: SignalScales.number(tick)
+				}))
+			};
+		}
+		const span = Math.max(5, Number.isFinite(range) ? range : 40), top = normalize ? 0 : Math.ceil(peak / 10) * 10, step = span <= 20 ? 5 : span <= 60 ? 10 : 20;
+		return {
+			unit: (gain) => clamp((gain - base - (top - span)) / span),
+			ticks: Array.from({ length: Math.floor(span / step) + 1 }, (_, i) => ({
+				at: 1 - i * step / span,
+				text: `${top - i * step}${i ? "" : " dB"}`
+			}))
+		};
+	}
+	draw(ctx) {
+		const cuts = this.cuts, levels = this.#levels(cuts), polar = this.options.form === "polar", { width, height } = ctx.plot;
+		for (const cut of cuts) ctx.palette.color(cut.name);
+		const blocks = this.options.metrics ? cuts.map((cut) => [cut.name, ...AntennaPatternChart.#figures(cut).map(([name, value]) => `${name} ${value}`)]) : [];
+		const column = Math.max(0, ...blocks.flat().map((line) => TextFit.width(line, CHAR))) + 16, listed = blocks.length > 0 && width - column >= LEAST_PLOT;
+		const wide = listed ? width - column : width, slack = listed && polar ? Math.max(0, wide - 2 * AntennaPatternChart.#radius(wide, height) - 68) : 0;
+		const room = {
+			x: slack / 2,
+			y: 0,
+			width: wide - slack,
+			height
+		};
+		const frame = polar ? this.#dial(ctx, levels, room) : this.#axes(ctx, levels, cuts, room);
+		if (polar) this.#axes(ctx, levels, cuts, room, true);
+		else this.#dial(ctx, levels, room, true);
+		this.#marks(ctx, cuts, levels, frame);
+		let y = 10;
+		const lines = (listed ? blocks : []).flatMap((block, i) => {
+			if (y + block.length * ROW > height + 4) return [];
+			const placed = block.map((text, row) => ({
+				key: `${i}/${row}`,
+				text,
+				x: room.x + room.width + 14,
+				y: y + row * ROW,
+				anchor: "start",
+				bold: !row,
+				listed: true
+			}));
+			y += block.length * ROW + 8;
+			return placed;
+		});
+		this.#write(ctx, "axis-figures", lines);
+	}
+	/** The largest dial that leaves room for its angle labels. */
+	static #radius(width, height) {
+		return Math.max(8, Math.min(width / 2 - RIM, height / 2 - 18));
+	}
+	static #figures({ metrics }) {
+		return [
+			["Peak", `${metrics.peak.toFixed(1)} dB at ${degrees(metrics.peakAngle)}`],
+			...metrics.halfPower ? [["HPBW", `${(metrics.halfPower[1] - metrics.halfPower[0]).toFixed(1)}°`]] : [],
+			...metrics.sideLobe ? [["SLL", `${metrics.sideLobe.level.toFixed(1)} dB`]] : [],
+			...metrics.back ? [["F/B", `${metrics.back.ratio.toFixed(1)} dB`]] : []
+		];
+	}
+	/** Text on a surface halo, so it stays legible over a cut. */
+	#write(ctx, name, labels) {
+		const { theme } = ctx;
+		const written = ctx.marks(name, "text", labels, (d) => d.key).attr("dy", (d) => d.listed ? null : "0.35em").attr("text-anchor", (d) => d.anchor).attr("font-weight", (d) => d.bold ? 600 : 400).attr("paint-order", "stroke").attr("stroke", theme.surface).attr("stroke-width", 3).attr("stroke-linejoin", "round").style("pointer-events", "none").text((d) => d.text);
+		ctx.text(written, 10).attr("fill", (d) => d.bold ? theme.ink : d.muted ? theme.inkMuted : theme.inkSecondary);
+		ctx.set(written, {
+			x: (d) => d.x,
+			y: (d) => d.y
+		});
+	}
+	/** Rings, spokes and angle labels of the polar form. `clear` draws none, which removes what the other form left. */
+	#dial(ctx, levels, { x: start, width, height }, clear = false) {
+		const { theme } = ctx, cx = start + width / 2, cy = height / 2, radius = AntennaPatternChart.#radius(width, height);
+		const turn = radius >= 70 ? 30 : radius >= 36 ? 45 : 90;
+		const around = (angle, r) => [cx + r * Math.sin(angle * RAD), cy - r * Math.cos(angle * RAD)];
+		const rings = clear ? [] : levels.ticks.filter((tick) => tick.at > 0), spokes = clear ? [] : Array.from({ length: 360 / turn }, (_, i) => -180 + turn + i * turn);
+		const circles = ctx.marks("axis-rings", "circle", rings, (d) => d.text).attr("fill", "none").attr("stroke", (d) => d.at === 1 ? theme.axis : theme.grid).attr("stroke-width", 1);
+		ctx.set(circles, {
+			cx,
+			cy,
+			r: (d) => radius * d.at
+		});
+		const lines = ctx.marks("axis-spokes", "line", spokes, (d) => d).attr("stroke", theme.grid).attr("stroke-width", 1);
+		ctx.set(lines, {
+			x1: cx,
+			y1: cy,
+			x2: (d) => around(d, radius)[0],
+			y2: (d) => around(d, radius)[1]
+		});
+		const side = (angle) => Math.sin(angle * RAD) > .2 ? "start" : Math.sin(angle * RAD) < -.2 ? "end" : "middle";
+		const named = spokes.map((angle) => ({
+			angle,
+			text: `${angle}°`,
+			anchor: side(angle),
+			at: around(angle, radius + 9)
+		}));
+		const angles = ctx.text(ctx.marks("axis-angles", "text", named, (d) => d.angle)).attr("dy", "0.35em").attr("text-anchor", (d) => d.anchor).text((d) => d.text);
+		ctx.set(angles, {
+			x: (d) => d.at[0],
+			y: (d) => d.at[1]
+		});
+		const gap = rings.length > 1 ? radius * (rings[0].at - rings[1].at) : radius, every = Math.max(1, Math.ceil((Math.max(0, ...rings.map((ring) => TextFit.width(ring.text, CHAR))) + 5) / gap));
+		const scale = ctx.text(ctx.marks("axis-levels", "text", rings.filter((ring, i) => i % every === 0 && radius * ring.at - TextFit.width(ring.text, CHAR) >= 6), (d) => d.text), 10, "muted").attr("dy", "0.35em").attr("text-anchor", "end").attr("paint-order", "stroke").attr("stroke", theme.surface).attr("stroke-width", 3).attr("stroke-linejoin", "round").text((d) => d.text);
+		ctx.set(scale, {
+			x: (d) => around(RING_LABELS_AT, radius * d.at)[0] - 2,
+			y: (d) => around(RING_LABELS_AT, radius * d.at)[1]
+		});
+		return {
+			round: true,
+			point: (angle, level) => around(angle, radius * level),
+			tag: (angle, level) => {
+				const [x, y] = around(angle, Math.max(radius * level, radius * .24) + 11), anchor = side(angle);
+				return {
+					x,
+					y: y + (anchor === "middle" ? Math.cos(angle * RAD) > 0 ? -2 : 3 : 0),
+					anchor
+				};
+			},
+			beam: (edge, level, away) => {
+				const reach = Math.max(12, radius * Math.min(level, .78)), [x, y] = around(edge + away * 9 / (reach * RAD), reach), from = around(edge, reach)[0];
+				return {
+					x,
+					y,
+					anchor: x > from + 1 ? "start" : x < from - 1 ? "end" : "middle"
+				};
+			}
+		};
+	}
+	/** Level rules and the angle axis of the rectangular form. `clear` draws none, which removes what the other form left. */
+	#axes(ctx, levels, cuts, { x: start, width, height }, clear = false) {
+		const { theme } = ctx;
+		const left = start + Math.max(24, ...levels.ticks.map((tick) => TextFit.width(tick.text, 6.2) + 10)), right = start + width - 10, top = 6, bottom = Math.max(16, height - 18);
+		const seen = cuts.flatMap((cut) => [cut.angles[0], cut.angles[cut.angles.length - 1]]);
+		let [low, high] = !cuts.length || cuts.some((cut) => cut.closed) ? [-180, 180] : [Math.min(...seen), Math.max(...seen)];
+		if (low === high) [low, high] = [low - 1, high + 1];
+		const x = scaleLinear([low, high], [left, Math.max(left + 10, right)]), y = (level) => bottom - level * (bottom - top);
+		const step = [
+			30,
+			45,
+			60,
+			90,
+			180
+		].find((size) => (x(high) - x(low)) * size / (high - low) >= 36) ?? 360;
+		const ticks = clear ? [] : Array.from({ length: Math.floor(high / step) - Math.ceil(low / step) + 1 }, (_, i) => (Math.ceil(low / step) + i) * step);
+		const ruled = clear ? [] : levels.ticks;
+		const rules = ctx.marks("axis-rules", "line", ruled, (d) => d.text).attr("stroke", theme.grid).attr("stroke-width", 1);
+		ctx.set(rules, {
+			x1: left,
+			x2: x(high),
+			y1: (d) => y(d.at),
+			y2: (d) => y(d.at)
+		});
+		const base = ctx.marks("axis-base", "line", clear ? [] : [0]).attr("stroke", theme.axis).attr("stroke-width", 1);
+		ctx.set(base, {
+			x1: left,
+			x2: x(high),
+			y1: bottom,
+			y2: bottom
+		});
+		const levelText = ctx.text(ctx.marks("axis-level-ticks", "text", ruled, (d) => d.text)).attr("dy", "0.32em").attr("text-anchor", "end").text((d) => d.text);
+		ctx.set(levelText, {
+			x: left - 6,
+			y: (d) => y(d.at)
+		});
+		const angleText = ctx.text(ctx.marks("axis-angle-ticks", "text", ticks, (d) => d)).attr("text-anchor", "middle").text((d) => `${d}°`);
+		ctx.set(angleText, {
+			x: (d) => x(d),
+			y: bottom + 14
+		});
+		const across = (angle) => x(Math.max(low, Math.min(high, angle > high || angle < low ? wrap(angle) : angle)));
+		return {
+			round: false,
+			point: (angle, level) => [across(angle), y(level)],
+			tag: (angle, level, wide) => ({
+				x: Math.max(left + wide / 2 + 2, Math.min(x(high) - wide / 2 - 2, across(angle))),
+				y: Math.max(12, y(level) - 12),
+				anchor: "middle"
+			}),
+			beam: (edge, level, away) => ({
+				x: across(edge) + away * 9,
+				y: y(level),
+				anchor: away > 0 ? "start" : "end"
+			})
+		};
+	}
+	#marks(ctx, cuts, levels, frame) {
+		const { theme, palette } = ctx;
+		const traced = cuts.map((cut) => {
+			const edge = !frame.round && cut.closed ? AntennaPatternChart.gainAt(cut.angles, cut.gains, -180) : null;
+			const run = cut.angles.map((angle, i) => [angle, cut.gains[i]]);
+			return {
+				cut,
+				points: (edge === null ? run : [
+					...run[0][0] > -180 ? [[-180, edge]] : [],
+					...run,
+					[180, edge]
+				]).map(([angle, gain]) => frame.point(angle, levels.unit(gain)))
+			};
+		});
+		const outline = (points, shut) => points.length ? `M${points.map(([x, y]) => `${x.toFixed(2)},${y.toFixed(2)}`).join("L")}${shut ? "Z" : ""}` : "";
+		const lead = this.options.metrics ? cuts[0] : void 0, found = lead?.metrics, tint = lead ? palette.color(lead.name) : null;
+		const halfPower = levels.unit((found?.peak ?? 0) - HALF_POWER), [from, to] = found?.halfPower ?? [0, 0];
+		const guides = !found?.halfPower ? [] : [...frame.round || wrap(from) < wrap(to) ? [{
+			key: "arc",
+			d: outline(Array.from({ length: 25 }, (_, i) => frame.point(from + (to - from) * i / 24, halfPower)), false)
+		}] : [], ...[from, to].map((angle, i) => ({
+			key: `edge-${i}`,
+			d: outline([frame.point(angle, 0), frame.point(angle, halfPower)], false)
+		}))];
+		const beams = ctx.marks("axis-beam", "path", guides, (d) => d.key).attr("fill", "none").attr("stroke", theme.inkMuted).attr("stroke-width", 1).attr("stroke-dasharray", (d) => d.key === "arc" ? null : "3 3");
+		ctx.set(beams, { d: (d) => d.d });
+		const paths = ctx.marks("cuts", "path", traced.filter((entry) => entry.points.length > 1), (d) => d.cut.name).attr("fill", "none").attr("stroke", (d) => palette.color(d.cut.name)).attr("stroke-width", 2).attr("stroke-linejoin", "round").attr("stroke-linecap", "round");
+		ctx.set(paths, { d: (d) => outline(d.points, frame.round && d.cut.closed) });
+		ctx.drawOn(paths);
+		ctx.hover(paths, (d) => ({
+			title: d.cut.name,
+			color: palette.color(d.cut.name),
+			rows: AntennaPatternChart.#figures(d.cut)
+		}));
+		const lone = ctx.marks("single", "circle", traced.filter((entry) => entry.points.length === 1 && entry.cut !== lead), (d) => d.cut.name).attr("fill", (d) => palette.color(d.cut.name)).attr("stroke", theme.surface).attr("stroke-width", 2);
+		ctx.set(lone, {
+			cx: (d) => d.points[0][0],
+			cy: (d) => d.points[0][1],
+			r: DOT
+		}, { r: 0 });
+		ctx.hover(lone, (d) => ({
+			title: d.cut.name,
+			color: palette.color(d.cut.name),
+			rows: AntennaPatternChart.#figures(d.cut)
+		}));
+		const read = (value) => `${value.toFixed(1)} dB`;
+		const spots = !found ? [] : [
+			{
+				key: "peak",
+				angle: found.peakAngle,
+				gain: found.peak,
+				name: "Main lobe",
+				text: "",
+				value: `${read(found.peak)} at ${degrees(found.peakAngle)}`
+			},
+			...(found.halfPower ?? []).map((angle, i) => ({
+				key: `half-${i}`,
+				angle,
+				gain: found.peak - HALF_POWER,
+				name: "Half power",
+				text: "",
+				value: degrees(angle)
+			})),
+			...found.sideLobe ? [{
+				key: "side",
+				angle: found.sideLobe.angle,
+				gain: found.peak + found.sideLobe.level,
+				name: "First side lobe",
+				text: "SLL",
+				value: `${read(found.sideLobe.level)} at ${degrees(found.sideLobe.angle)}`
+			}] : [],
+			...found.back ? [{
+				key: "back",
+				angle: found.back.angle,
+				gain: found.peak - found.back.ratio,
+				name: "Front to back",
+				text: "F/B",
+				value: read(found.back.ratio)
+			}] : []
+		].map((spot) => ({
+			...spot,
+			at: frame.point(spot.angle, levels.unit(spot.gain)),
+			tag: frame.tag(spot.angle, levels.unit(spot.gain), TextFit.width(spot.text, CHAR))
+		}));
+		const dots = ctx.marks("markers", "circle", spots, (d) => d.key).attr("fill", tint).attr("stroke", theme.surface).attr("stroke-width", 2);
+		ctx.set(dots, {
+			cx: (d) => d.at[0],
+			cy: (d) => d.at[1],
+			r: (d) => d.key.startsWith("half") ? 3 : DOT
+		}, { r: 0 }, 30);
+		ctx.hover(dots, (d) => ({
+			title: d.name,
+			color: tint ?? void 0,
+			rows: [[lead.name, d.value]]
+		}));
+		const tagged = spots.filter((spot) => spot.text);
+		const leaders = !frame.round ? [] : tagged.flatMap((spot) => {
+			const far = Math.hypot(spot.tag.x - spot.at[0], spot.tag.y - spot.at[1]), along = (t) => [spot.at[0] + (spot.tag.x - spot.at[0]) * t, spot.at[1] + (spot.tag.y - spot.at[1]) * t];
+			return far > 24 ? [{
+				key: spot.key,
+				from: along(7 / far),
+				to: along(1 - 10 / far)
+			}] : [];
+		});
+		const tails = ctx.marks("axis-leaders", "line", leaders, (d) => d.key).attr("stroke", theme.axis).attr("stroke-width", 1);
+		ctx.set(tails, {
+			x1: (d) => d.from[0],
+			y1: (d) => d.from[1],
+			x2: (d) => d.to[0],
+			y2: (d) => d.to[1]
+		});
+		const sideLobe = found?.sideLobe ? wrap(found.sideLobe.angle - found.peakAngle) : -1;
+		this.#write(ctx, "axis-tags", [
+			...tagged.map((spot) => ({
+				key: spot.key,
+				text: spot.text,
+				...spot.tag
+			})),
+			...found?.halfPower ? [{
+				key: "beam",
+				text: "HPBW",
+				...sideLobe > 0 ? frame.beam(from, halfPower, -1) : frame.beam(to, halfPower, 1)
+			}] : [],
+			...cuts.length ? [] : [{
+				key: "empty",
+				text: "No pattern",
+				x: 4,
+				y: 12,
+				anchor: "start",
+				muted: true
+			}]
+		]);
+	}
+};
+export { AntennaPatternChart, AntennaPatternForm };

package/dist/charts/signals/SignalSamples.js

@@ -103,5 +103,22 @@ var SignalSamples = class {
 			value: +point[axis].toFixed(4)
 		})));
 	}
+	/**
+	* `{ angle, gain, cut }`: gain in dBi every 2 degrees round the E-plane and H-plane of a small array of patch elements, boresight at 0.
+	* Each cut is a uniform array factor at half-wave spacing times an element pattern that leaks a little to the rear, with the walk's noise as ripple.
+	*/
+	static antenna(seed = 1) {
+		const elements = [5 + seed % 4, 2 + seed % 2], peak = 10 * Math.log10(elements[0] * elements[1] * 3.2);
+		return this.noise(seed, 180, 2).flatMap(({ noise }, cut) => noise.map((ripple, i) => {
+			const angle = -180 + i * 2, theta = angle * Math.PI / 180, count = elements[cut], phase = Math.PI * Math.sin(theta) / 2;
+			const array = Math.abs(Math.sin(phase)) < 1e-9 ? 1 : (Math.sin(count * phase) / (count * Math.sin(phase))) ** 2;
+			const element = (.92 * ((1 + Math.cos(theta)) / 2) ** 1.5 + .08) ** 2;
+			return {
+				angle,
+				cut: cut ? "H-plane" : "E-plane",
+				gain: +(peak + 10 * Math.log10(array * element + 10 ** -4.5) + .12 * ripple).toFixed(2)
+			};
+		}));
+	}
 };
 export { SignalSamples };

package/dist/charts/signals/index.js

@@ -2,8 +2,9 @@ import { SignalAmplitude, SignalFrequencyScale, SignalLayout, SignalWavelet, Sig
 import { SignalDsp } from "./SignalDsp.js";
 import { SignalScales } from "./SignalScales.js";
 import { SignalChart, SignalParser } from "./SignalChart.js";
-import { AudiogramChart, AudiogramLayout, AudiogramSpacing } from "./AudiogramChart.js";
 import { SignalSamples } from "./SignalSamples.js";
+import { AntennaPatternChart, AntennaPatternForm } from "./AntennaPatternChart.js";
+import { AudiogramChart, AudiogramLayout, AudiogramSpacing } from "./AudiogramChart.js";
 import { CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark } from "./CepstrumChart.js";
 import { ECGChart, EcgAnnotation, EcgLayout, EcgView } from "./ECGChart.js";
 import { EnvelopeChart, EnvelopeMethod, EnvelopeShape } from "./EnvelopeChart.js";
@@ -43,6 +44,7 @@ var signalsCatalog = [
 	ECGChart,
 	LogicAnalyzerChart,
 	PhaseSpaceChart,
-	PhaseSpace3DChart
+	PhaseSpace3DChart,
+	AntennaPatternChart
 ];
-export { AudiogramChart, AudiogramLayout, AudiogramSpacing, CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark, DiffMetric, DiffView, ECGChart, EcgAnnotation, EcgLayout, EcgView, EnvelopeChart, EnvelopeMethod, EnvelopeShape, FilterResponseChart, FilterView, ImpulseMark, ImpulseResponseChart, ImpulseView, LogicAnalyzerChart, LogicDisplay, LogicEdge, OscilloscopeChart, PeriodogramAbscissa, PeriodogramChart, PeriodogramMethod, Phase3DCoordinates, Phase3DStyle, PhaseCoordinates, PhaseMark, PhaseSpace3DChart, PhaseSpaceChart, ScopeCoupling, ScopeDisplay, ScopeMode, ScopeTrigger, SeismogramChart, SeismogramFill, SeismogramGain, SeismogramLayout, SignalAmplitude, SignalChart, SignalDsp, SignalFrequencyScale, SignalLayout, SignalParser, SignalRaster, SignalSamples, SignalScales, SignalWavelet, SignalWindow, SpectralChart, SpectrumChart, SpectrumMark, StemReconstruction, StemSignalChart, TimeDomainDiffChart, TimeFrequencyChart, WaterfallFill, WaterfallOrder, WaterfallProjection, WaterfallSpectrum, WaveformChart, WaveformStyle, WaveletAxis, WaveletScalogram, WaveletValue, signalsCatalog };
+export { AntennaPatternChart, AntennaPatternForm, AudiogramChart, AudiogramLayout, AudiogramSpacing, CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark, DiffMetric, DiffView, ECGChart, EcgAnnotation, EcgLayout, EcgView, EnvelopeChart, EnvelopeMethod, EnvelopeShape, FilterResponseChart, FilterView, ImpulseMark, ImpulseResponseChart, ImpulseView, LogicAnalyzerChart, LogicDisplay, LogicEdge, OscilloscopeChart, PeriodogramAbscissa, PeriodogramChart, PeriodogramMethod, Phase3DCoordinates, Phase3DStyle, PhaseCoordinates, PhaseMark, PhaseSpace3DChart, PhaseSpaceChart, ScopeCoupling, ScopeDisplay, ScopeMode, ScopeTrigger, SeismogramChart, SeismogramFill, SeismogramGain, SeismogramLayout, SignalAmplitude, SignalChart, SignalDsp, SignalFrequencyScale, SignalLayout, SignalParser, SignalRaster, SignalSamples, SignalScales, SignalWavelet, SignalWindow, SpectralChart, SpectrumChart, SpectrumMark, StemReconstruction, StemSignalChart, TimeDomainDiffChart, TimeFrequencyChart, WaterfallFill, WaterfallOrder, WaterfallProjection, WaterfallSpectrum, WaveformChart, WaveformStyle, WaveletAxis, WaveletScalogram, WaveletValue, signalsCatalog };