@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/scientific/HertzsprungRussell.js

@@ -0,0 +1,272 @@
+import { CartesianChart } from "../../core/CartesianChart.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { Draft } from "./Draft.js";
+import { GridContours } from "./GridContours.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { extent, scaleBand, scaleLinear, scaleLog, scaleSqrt } from "d3";
+// src/charts/scientific/HertzsprungRussell.ts
+var StellarAbscissa = /* @__PURE__ */ function(StellarAbscissa) {
+	StellarAbscissa["Temperature"] = "temperature";
+	StellarAbscissa["ColorIndex"] = "color-index";
+	StellarAbscissa["SpectralClass"] = "spectral-class";
+	return StellarAbscissa;
+}({});
+var StellarOrdinate = /* @__PURE__ */ function(StellarOrdinate) {
+	StellarOrdinate["Luminosity"] = "luminosity";
+	StellarOrdinate["Magnitude"] = "magnitude";
+	return StellarOrdinate;
+}({});
+var StellarGuides = /* @__PURE__ */ function(StellarGuides) {
+	StellarGuides["Sequences"] = "sequences";
+	StellarGuides["None"] = "no-guides";
+	StellarGuides["Radii"] = "iso-radii";
+	return StellarGuides;
+}({});
+var StellarMark = /* @__PURE__ */ function(StellarMark) {
+	StellarMark["Dots"] = "dots";
+	StellarMark["Sized"] = "compressed-radius";
+	StellarMark["Contours"] = "contours";
+	return StellarMark;
+}({});
+var SUN = 5772;
+var CLASSES = [
+	["O", 3e4],
+	["B", 1e4],
+	["A", 7500],
+	["F", 6e3],
+	["G", 5200],
+	["K", 3700],
+	["M", 2400]
+];
+var SEQUENCES = [
+	{
+		name: "Main sequence",
+		shape: [
+			[33e3, 5.3],
+			[15e3, 3.2],
+			[8e3, 1.3],
+			[5772, 0],
+			[4200, -.9],
+			[3e3, -2.8]
+		],
+		at: [11e3, 1.25]
+	},
+	{
+		name: "Giants",
+		shape: [
+			[5400, 1.7],
+			[4400, 2.2],
+			[3500, 3]
+		],
+		at: [4200, 1.45]
+	},
+	{
+		name: "Supergiants",
+		shape: [
+			[18e3, 4.9],
+			[8e3, 4.95],
+			[3600, 5.1]
+		],
+		at: [7800, 4.3]
+	},
+	{
+		name: "White dwarfs",
+		shape: [
+			[22e3, -1.6],
+			[1e4, -2.9],
+			[6e3, -3.6]
+		],
+		at: [14e3, -3.4]
+	}
+];
+/** Maps stellar temperature against luminosity, the classic diagram of stellar evolution. */
+var HertzsprungRussell = class extends CartesianChart {
+	static meta = {
+		id: "hertzsprung-russell",
+		name: "Hertzsprung–Russell diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots stars by surface temperature against luminosity to reveal the main sequence, giants and white dwarfs.",
+		tags: [
+			"astronomy",
+			"hr diagram",
+			"color magnitude"
+		],
+		sample: (seed) => ScientificSample.stars(seed),
+		variants: {
+			abscissa: Object.values(StellarAbscissa),
+			ordinate: Object.values(StellarOrdinate),
+			guides: Object.values(StellarGuides),
+			mark: Object.values(StellarMark)
+		}
+	};
+	defaults() {
+		return {
+			temperature: "temperature",
+			luminosity: "luminosity",
+			radius: "radius",
+			name: "name",
+			group: "group",
+			grid: true,
+			abscissa: "temperature",
+			ordinate: "luminosity",
+			guides: "sequences",
+			mark: "dots"
+		};
+	}
+	/** Ballesteros's formula inverted: B−V of a blackbody at `t` kelvin. */
+	colorIndex(t) {
+		const k = t / 4600, b = 2.32 * k - 2, c = 1.054 * k - 2.32;
+		return (-b + Math.sqrt(b * b - 4 * k * c)) / (2 * k) / .92;
+	}
+	fraction(t) {
+		const index = CLASSES.findIndex(([, floor]) => t >= floor);
+		const i = index < 0 ? CLASSES.length - 1 : index;
+		const ceiling = i === 0 ? 6e4 : CLASSES[i - 1][1], floor = CLASSES[i][1];
+		return [CLASSES[i][0], Math.max(0, Math.min(1, (Math.log(ceiling) - Math.log(t)) / (Math.log(ceiling) - Math.log(floor))))];
+	}
+	stars() {
+		const { data, temperature, luminosity, radius, name, group } = this.options;
+		return data.flatMap((row) => {
+			const t = Draft.number(row[temperature]), l = Draft.number(row[luminosity]);
+			if (t === null || l === null || t <= 0 || l <= 0) return [];
+			return [{
+				row,
+				t,
+				l,
+				name: String(row[name] ?? ""),
+				group: String(row[group] ?? "Stars"),
+				r: Draft.number(row[radius]) ?? Math.sqrt(l) / (t / SUN) ** 2,
+				x: 0,
+				y: 0
+			}];
+		});
+	}
+	across(axes, t) {
+		if (this.options.abscissa === "spectral-class") {
+			const [name, fraction] = this.fraction(t), band = axes.x;
+			return band(name) + fraction * band.bandwidth();
+		}
+		return axes.x(this.options.abscissa === "color-index" ? this.colorIndex(t) : t);
+	}
+	up(axes, logL) {
+		return axes.y(this.options.ordinate === "magnitude" ? 4.83 - 2.5 * logL : 10 ** logL);
+	}
+	scales(ctx) {
+		const { abscissa, ordinate } = this.options;
+		const { width, height } = ctx.plot;
+		const stars = this.stars();
+		const [cool = 2500, hot = 4e4] = extent(stars, (d) => d.t);
+		const [dim = 1e-4, bright = 1e6] = extent(stars, (d) => d.l);
+		return {
+			x: abscissa === "spectral-class" ? scaleBand(CLASSES.map(([name]) => name), [0, width]) : abscissa === "color-index" ? scaleLinear([this.colorIndex(hot * 1.1) - .05, this.colorIndex(cool * .9) + .05], [0, width]) : scaleLog([hot * 1.15, cool * .88], [0, width]),
+			y: ordinate === "magnitude" ? scaleLinear([4.83 - 2.5 * Math.log10(dim) + 1, 4.83 - 2.5 * Math.log10(bright) - 1], [height, 0]) : scaleLog([dim / 2.5, bright * 2.5], [height, 0])
+		};
+	}
+	tickFormat(scale) {
+		if (typeof scale.bandwidth === "function") return null;
+		if (!scale.base) return super.tickFormat(scale);
+		const descending = scale.domain()[0] > scale.domain()[1];
+		return (value) => {
+			const v = +value, power = Math.floor(Math.log10(v) + 1e-9), lead = Math.round(v / 10 ** power);
+			if (descending) return [
+				1,
+				2,
+				3,
+				5
+			].includes(lead) ? `${v / 1e3}k` : "";
+			return lead === 1 && power % 2 === 0 ? `10${SUPER(power)}` : "";
+		};
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	plotMarks(ctx, axes) {
+		const { guides, mark } = this.options;
+		const { width, height } = ctx.plot;
+		const stars = this.stars().map((star) => ({
+			...star,
+			x: this.across(axes, star.t),
+			y: this.up(axes, Math.log10(star.l))
+		}));
+		const place = (t, logL) => [this.across(axes, t), this.up(axes, logL)];
+		const curve = (points) => Draft.clipped(points, width, height);
+		const radii = [
+			.01,
+			1,
+			100
+		];
+		const iso = guides !== "iso-radii" ? [] : radii.map((r) => {
+			const samples = Array.from({ length: 24 }, (_, i) => 2400 * (4e4 / 2400) ** (i / 23));
+			return curve(samples.map((t) => place(t, 2 * Math.log10(r) + 4 * Math.log10(t / SUN))));
+		});
+		Draft.paths(ctx, "iso-radii", iso, {
+			stroke: ctx.theme.inkMuted,
+			dash: "3 4"
+		});
+		const radiusCaptions = guides !== "iso-radii" ? [] : radii.flatMap((r) => {
+			const [x, y] = place(9e3, 2 * Math.log10(r) + 4 * Math.log10(9e3 / SUN));
+			return x > 20 && x < width - 40 && y > 12 && y < height - 8 ? [{
+				text: `${r} R☉`,
+				x,
+				y: y - 6,
+				size: 10,
+				tone: "muted"
+			}] : [];
+		});
+		Draft.captions(ctx, "radius-names", radiusCaptions);
+		const bands = guides !== "sequences" ? [] : SEQUENCES.map(({ shape }) => curve(shape.map(([t, logL]) => place(t, logL))));
+		Draft.paths(ctx, "sequences", bands, {
+			stroke: ctx.theme.axis,
+			width: 14,
+			opacity: .45
+		});
+		if (mark === "contours") {
+			const shapes = GridContours.bands(stars.map((d) => [d.x, d.y]), width, height, Math.max(9, width / 44), () => true, 5);
+			const fills = ctx.marks("density", "path", shapes, (_, i) => i).attr("fill", (d) => ctx.palette.sequential(d.level * .8)).attr("fill-opacity", .8).attr("stroke", ctx.theme.surface);
+			ctx.set(fills, { d: (d) => d.d }, { d: (d) => d.d });
+			ctx.hover(fills, (d) => ({
+				title: "Star density",
+				rows: [["Level", `${Math.round(d.level * 100)}%`]]
+			}));
+		} else {
+			const area = scaleSqrt([0, Math.max(1, ...stars.map((d) => Math.sqrt(d.r)))], [2.5, 12]);
+			const radius = (d) => mark === "compressed-radius" ? area(Math.sqrt(d.r)) : 3.5;
+			const heat = (t) => ctx.palette.diverging(Math.max(-1, Math.min(1, (Math.log(SUN) - Math.log(t)) * 1.2)));
+			const dots = ctx.marks("stars", "circle", stars, (d, i) => `${d.name}${i}`).attr("fill", (d) => heat(d.t)).attr("stroke", ctx.theme.ink).attr("stroke-opacity", .35).attr("stroke-width", .5);
+			ctx.set(dots, {
+				cx: (d) => d.x,
+				cy: (d) => d.y,
+				r: radius
+			}, {
+				cx: (d) => d.x,
+				cy: (d) => d.y,
+				r: 0
+			}, 1.5);
+			ctx.hover(dots, (d) => ({
+				title: d.name || d.group,
+				rows: [
+					["Class", d.group],
+					["Temperature", `${d.t.toLocaleString("en")} K`],
+					["Luminosity", `${d.l.toPrecision(3)} L☉`],
+					["Radius", `${d.r.toPrecision(3)} R☉`]
+				]
+			}));
+		}
+		const names = guides !== "sequences" ? [] : Draft.declutter(SEQUENCES.map(({ name, at: [t, logL] }) => {
+			const [x, y] = place(t, logL);
+			return {
+				text: name,
+				x,
+				y,
+				size: 10.5,
+				tone: "ink"
+			};
+		}), width, height);
+		Draft.captions(ctx, "sequence-names", names).attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("paint-order", "stroke");
+	}
+};
+var SUPER = (power) => String(power).replace(/-/g, "⁻").replace(/\d/g, (d) => "⁰¹²³⁴⁵⁶⁷⁸⁹"[+d]);
+export { HertzsprungRussell, StellarAbscissa, StellarGuides, StellarMark, StellarOrdinate };

package/dist/charts/scientific/HodographChart.js

@@ -0,0 +1,265 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { RadialChart } from "../../core/RadialChart.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { curveCatmullRom, curveLinear, line, max, mean, range } from "d3";
+// src/charts/scientific/HodographChart.ts
+var HodographFrame = /* @__PURE__ */ function(HodographFrame) {
+	HodographFrame["Polar"] = "polar-rings";
+	HodographFrame["Grid"] = "uv-grid";
+	return HodographFrame;
+}({});
+var HodographMark = /* @__PURE__ */ function(HodographMark) {
+	HodographMark["Trace"] = "trace";
+	HodographMark["Vectors"] = "wind-vectors";
+	return HodographMark;
+}({});
+var HodographStorm = /* @__PURE__ */ function(HodographStorm) {
+	HodographStorm["None"] = "no-storm";
+	HodographStorm["Bunkers"] = "bunkers-motion";
+	HodographStorm["Helicity"] = "storm-helicity";
+	return HodographStorm;
+}({});
+var LAYERS = [
+	[0, 1e3],
+	[1e3, 3e3],
+	[3e3, 6e3],
+	[6e3, 9e3],
+	[9e3, 12e3]
+];
+/** Wind vectors at each height joined tip to tip, revealing shear and storm rotation potential. */
+var HodographChart = class extends RadialChart {
+	static meta = {
+		id: "hodograph",
+		name: "Hodograph",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Traces the tips of wind vectors with height to show vertical shear and supercell storm motion.",
+		tags: [
+			"meteorology",
+			"wind shear",
+			"helicity"
+		],
+		sample: (seed) => ScientificSample.sounding(seed),
+		variants: {
+			frame: Object.values(HodographFrame),
+			mark: Object.values(HodographMark),
+			storm: Object.values(HodographStorm),
+			smooth: [true, false],
+			ceiling: [12e3, 6e3]
+		},
+		valid: (values) => values.mark === "trace" || values.smooth === true
+	};
+	layers = [];
+	defaults() {
+		return {
+			u: "u",
+			v: "v",
+			altitude: "height",
+			frame: "polar-rings",
+			mark: "trace",
+			storm: "bunkers-motion",
+			smooth: true,
+			ceiling: 12e3
+		};
+	}
+	plotMargin() {
+		return {
+			top: 16,
+			right: 16,
+			bottom: 16,
+			left: 16
+		};
+	}
+	legendItems() {
+		return this.layers;
+	}
+	winds() {
+		const { data, u, v, altitude, ceiling } = this.options;
+		return data.flatMap((row) => {
+			const [a, b, c] = [
+				row[u],
+				row[v],
+				row[altitude]
+			].map(Draft.number);
+			return a === null || b === null || c === null ? [] : [{
+				u: a,
+				v: b,
+				height: c
+			}];
+		}).filter((d) => d.height <= ceiling).sort((a, b) => a.height - b.height);
+	}
+	interpolate(winds, height) {
+		const upper = winds.findIndex((d) => d.height >= height);
+		if (upper < 0) return null;
+		if (upper === 0) return winds[0];
+		const a = winds[upper - 1], b = winds[upper], t = (height - a.height) / (b.height - a.height || 1);
+		return {
+			u: a.u + (b.u - a.u) * t,
+			v: a.v + (b.v - a.v) * t,
+			height
+		};
+	}
+	/** Bunkers right-moving storm: 0–6 km mean wind plus 7.5 m/s to the right of the shear. */
+	bunkers(winds) {
+		const deep = winds.filter((d) => d.height <= 6e3);
+		const low = this.interpolate(winds, 500), high = this.interpolate(winds, 5500);
+		if (deep.length < 2 || !low || !high) return null;
+		const su = high.u - low.u, sv = high.v - low.v, shear = Math.hypot(su, sv) || 1;
+		return {
+			u: (mean(deep, (d) => d.u) ?? 0) + 7.5 * sv / shear,
+			v: (mean(deep, (d) => d.v) ?? 0) - 7.5 * su / shear
+		};
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	drawRadial(ctx, { radius: outer }) {
+		const { frame, mark, storm, smooth } = this.options;
+		const winds = this.winds();
+		const radius = outer - 8;
+		const reach = Math.max(10, max(winds, (d) => Math.hypot(d.u, d.v)) ?? 10) * 1.08;
+		const step = reach > 60 ? 20 : 10;
+		const top = Math.ceil(reach / step) * step, k = radius / top;
+		const at = (u, v) => [u * k, -v * k];
+		const circles = range(step, top + 1, step);
+		Draft.paths(ctx, "rings", frame === "polar-rings" ? circles.map((r) => `M${-r * k},0A${r * k},${r * k} 0 1 1 ${r * k},0A${r * k},${r * k} 0 1 1 ${-r * k},0`) : []);
+		const lines = frame === "uv-grid" ? [...circles, ...circles.map((r) => -r)].flatMap((r) => [{
+			x1: r * k,
+			x2: r * k,
+			y1: -radius,
+			y2: radius
+		}, {
+			x1: -radius,
+			x2: radius,
+			y1: r * k,
+			y2: r * k
+		}]) : [];
+		Draft.rules(ctx, "grid", lines);
+		Draft.rules(ctx, "axes", [{
+			x1: -radius,
+			x2: radius,
+			y1: 0,
+			y2: 0
+		}, {
+			x1: 0,
+			x2: 0,
+			y1: -radius,
+			y2: radius
+		}], { stroke: ctx.theme.axis });
+		const scale = circles.filter((r) => r * k > 14).map((r) => ({
+			text: `${r}`,
+			x: 4,
+			y: r * k - 3,
+			anchor: "start",
+			size: 10,
+			tone: "muted"
+		}));
+		Draft.captions(ctx, "scale", [...scale, {
+			text: "m/s",
+			x: -4,
+			y: radius - 3,
+			anchor: "end",
+			size: 10,
+			tone: "muted"
+		}]);
+		const shown = LAYERS.map(([low, high], i) => {
+			const inside = winds.filter((d) => d.height > low && d.height < high);
+			const ends = [this.interpolate(winds, low) ?? (i === 0 ? winds[0] : null), this.interpolate(winds, high) ?? (inside.length ? winds[winds.length - 1] : null)];
+			return {
+				name: `${low / 1e3}–${high / 1e3} km`,
+				color: ctx.palette.sequential(.3 + i * .17),
+				points: [
+					ends[0],
+					...inside,
+					ends[1]
+				].filter(Boolean)
+			};
+		}).filter((layer) => layer.points.length > 1);
+		this.layers = shown.map(({ name, color }) => ({
+			key: name,
+			color
+		}));
+		const curve = line().x((d) => at(d.u, d.v)[0]).y((d) => at(d.u, d.v)[1]).curve(smooth ? curveCatmullRom : curveLinear);
+		const motion = this.bunkers(winds);
+		if (storm === "storm-helicity" && motion) {
+			const low = winds.filter((d) => d.height <= 3e3);
+			let helicity = 0;
+			low.slice(1).forEach((d, i) => {
+				const p = low[i];
+				helicity += (d.u - motion.u) * (p.v - motion.v) - (p.u - motion.u) * (d.v - motion.v);
+			});
+			Draft.paths(ctx, "helicity", low.length > 1 ? [Draft.polygon([at(motion.u, motion.v), ...low.map((d) => at(d.u, d.v))])] : [], { stroke: "none" }, ctx.palette.diverging(.7)).attr("fill-opacity", .25);
+			Draft.captions(ctx, "helicity-value", [{
+				text: `SRH₀₋₃ ${Math.round(helicity)} m²/s²`,
+				x: -radius,
+				y: radius - 16,
+				anchor: "start",
+				size: 11,
+				tone: "ink",
+				weight: 600
+			}]);
+		}
+		const ribbons = ctx.marks("layers", "path", mark === "trace" ? shown : [], (d) => d.name).attr("fill", "none").attr("stroke", (d) => d.color).attr("stroke-width", 3).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		ctx.set(ribbons, { d: (d) => curve(d.points) ?? "" }, { d: (d) => curve(d.points) ?? "" });
+		ctx.drawOn(ribbons);
+		ctx.hover(ribbons, (d) => ({
+			title: d.name,
+			color: d.color,
+			rows: [["Shear", `${Math.hypot(d.points[d.points.length - 1].u - d.points[0].u, d.points[d.points.length - 1].v - d.points[0].v).toFixed(1)} m/s`]]
+		}));
+		const colorAt = (height) => shown.find((layer) => layer.points[0].height <= height && height <= layer.points[layer.points.length - 1].height)?.color ?? ctx.theme.inkMuted;
+		const arrows = ctx.marks("vectors", "path", mark === "wind-vectors" ? winds : [], (d) => d.height).attr("fill", "none").attr("stroke", (d) => colorAt(d.height)).attr("stroke-width", 2).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		const arrow = (d) => {
+			const [x, y] = at(d.u, d.v), angle = Math.atan2(y, x), head = (turn) => [x - 7 * Math.cos(angle + turn), y - 7 * Math.sin(angle + turn)];
+			const [lx, ly] = head(.45), [rx, ry] = head(-.45);
+			return `M0,0L${x},${y}M${lx},${ly}L${x},${y}L${rx},${ry}`;
+		};
+		ctx.set(arrows, { d: arrow }, { d: arrow }, 15);
+		const heights = ctx.marks("levels", "circle", mark === "trace" ? winds : [], (d) => d.height).attr("fill", "transparent");
+		ctx.set(heights, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 7
+		}, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 7
+		});
+		const joints = mark === "trace" ? shown.slice(1).map((layer) => layer.points[0]) : [];
+		const knots = ctx.marks("joints", "circle", joints, (d) => d.height).attr("fill", ctx.theme.surface).attr("stroke", ctx.theme.ink).attr("stroke-width", 1.5).style("pointer-events", "none");
+		ctx.set(knots, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 3.5
+		}, {
+			cx: (d) => at(d.u, d.v)[0],
+			cy: (d) => at(d.u, d.v)[1],
+			r: 0
+		}, 40);
+		Draft.captions(ctx, "joint-names", joints.map((d) => ({
+			text: `${d.height / 1e3}`,
+			x: at(d.u, d.v)[0] + 7,
+			y: at(d.u, d.v)[1] - 6,
+			anchor: "start",
+			size: 10,
+			tone: "ink"
+		})));
+		const tip = (d) => ({
+			title: `${d.height.toLocaleString("en")} m`,
+			rows: [["Speed", `${Math.hypot(d.u, d.v).toFixed(1)} m/s`], ["u, v", `${d.u}, ${d.v}`]]
+		});
+		ctx.hover(heights, tip);
+		ctx.hover(arrows, tip);
+		const motions = storm !== "no-storm" && motion ? [motion] : [];
+		const stormMark = ctx.marks("storm", "path", motions, () => "storm").attr("d", "M0,-7L6,3.5H-6Z").attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(stormMark, { transform: (d) => `translate(${at(d.u, d.v).join(",")})` }, { transform: (d) => `translate(${at(d.u, d.v).join(",")})` });
+		ctx.hover(stormMark, (d) => ({
+			title: "Right-moving storm",
+			rows: [["Speed", `${Math.hypot(d.u, d.v).toFixed(1)} m/s`]]
+		}));
+	}
+};
+export { HodographChart, HodographFrame, HodographMark, HodographStorm };