@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/threeglobe/GlobeEnums.js

@@ -0,0 +1,230 @@
+// src/charts/threeglobe/GlobeEnums.ts
+/** The body data is drawn on. */
+var GlobeSurface = /* @__PURE__ */ function(GlobeSurface) {
+	GlobeSurface["Sphere"] = "sphere";
+	GlobeSurface["Cylinder"] = "cylinder";
+	GlobeSurface["Plane"] = "plane";
+	return GlobeSurface;
+}({});
+/** How the basemap draws land. */
+var GlobeLand = /* @__PURE__ */ function(GlobeLand) {
+	GlobeLand["Solid"] = "solid";
+	GlobeLand["Dotted"] = "dotted";
+	GlobeLand["Outline"] = "outline";
+	GlobeLand["Bare"] = "bare";
+	return GlobeLand;
+}({});
+/** Map projection for planar surfaces. */
+var GlobeProjection = /* @__PURE__ */ function(GlobeProjection) {
+	GlobeProjection["NaturalEarth"] = "natural-earth";
+	GlobeProjection["Equirectangular"] = "equirectangular";
+	GlobeProjection["Mercator"] = "mercator";
+	GlobeProjection["EqualEarth"] = "equal-earth";
+	GlobeProjection["Robinson"] = "robinson";
+	GlobeProjection["Mollweide"] = "mollweide";
+	GlobeProjection["WinkelTripel"] = "winkel-tripel";
+	GlobeProjection["Sinusoidal"] = "sinusoidal";
+	GlobeProjection["Goode"] = "goode";
+	GlobeProjection["AzimuthalEquidistant"] = "azimuthal-equidistant";
+	return GlobeProjection;
+}({});
+/** How a location is marked. */
+var GlobeMarker = /* @__PURE__ */ function(GlobeMarker) {
+	GlobeMarker["Pin"] = "pin";
+	GlobeMarker["Dot"] = "dot";
+	GlobeMarker["Beacon"] = "beacon";
+	return GlobeMarker;
+}({});
+/** Point mark shape. */
+var GlobeSymbol = /* @__PURE__ */ function(GlobeSymbol) {
+	GlobeSymbol["Disc"] = "disc";
+	GlobeSymbol["Sphere"] = "sphere";
+	GlobeSymbol["Ring"] = "ring";
+	GlobeSymbol["Diamond"] = "diamond";
+	return GlobeSymbol;
+}({});
+/** Value-to-size mapping for point marks. */
+var GlobeSizing = /* @__PURE__ */ function(GlobeSizing) {
+	GlobeSizing["Fixed"] = "fixed";
+	GlobeSizing["Area"] = "area";
+	return GlobeSizing;
+}({});
+/** Vertical shape of a link. */
+var GlobeArcProfile = /* @__PURE__ */ function(GlobeArcProfile) {
+	GlobeArcProfile["Lofted"] = "lofted";
+	GlobeArcProfile["Fixed"] = "fixed";
+	GlobeArcProfile["Hugging"] = "hugging";
+	return GlobeArcProfile;
+}({});
+/** Whether a link's width carries its value. */
+var GlobeLinkWidth = /* @__PURE__ */ function(GlobeLinkWidth) {
+	GlobeLinkWidth["Value"] = "value";
+	GlobeLinkWidth["Constant"] = "constant";
+	return GlobeLinkWidth;
+}({});
+/** Arc stroke treatment. */
+var GlobeArcStroke = /* @__PURE__ */ function(GlobeArcStroke) {
+	GlobeArcStroke["Solid"] = "solid";
+	GlobeArcStroke["Beaded"] = "beaded";
+	return GlobeArcStroke;
+}({});
+/** Colour classification for regions. */
+var GlobeClassify = /* @__PURE__ */ function(GlobeClassify) {
+	GlobeClassify["Continuous"] = "continuous";
+	GlobeClassify["EqualInterval"] = "equal-interval";
+	GlobeClassify["Quantile"] = "quantile";
+	GlobeClassify["Rounded"] = "rounded";
+	return GlobeClassify;
+}({});
+/** How much height a region gains from its value. */
+var GlobeRelief = /* @__PURE__ */ function(GlobeRelief) {
+	GlobeRelief["Flat"] = "flat";
+	GlobeRelief["Stepped"] = "stepped";
+	GlobeRelief["Proportional"] = "proportional";
+	return GlobeRelief;
+}({});
+/** Spike shape. */
+var GlobeSpike = /* @__PURE__ */ function(GlobeSpike) {
+	GlobeSpike["Needle"] = "needle";
+	GlobeSpike["Cone"] = "cone";
+	GlobeSpike["Pyramid"] = "pyramid";
+	GlobeSpike["Blade"] = "blade";
+	GlobeSpike["Lollipop"] = "lollipop";
+	return GlobeSpike;
+}({});
+/** Binning cell for sphere grids. */
+var GlobeCell = /* @__PURE__ */ function(GlobeCell) {
+	GlobeCell["Hexagon"] = "hexagon";
+	GlobeCell["Triangle"] = "triangle";
+	GlobeCell["Quad"] = "quad";
+	return GlobeCell;
+}({});
+/** Cell count of a binning grid. */
+var GlobeResolution = /* @__PURE__ */ function(GlobeResolution) {
+	GlobeResolution["Coarse"] = "coarse";
+	GlobeResolution["Medium"] = "medium";
+	GlobeResolution["Fine"] = "fine";
+	return GlobeResolution;
+}({});
+/** Bin aggregation. */
+var GlobeAggregate = /* @__PURE__ */ function(GlobeAggregate) {
+	GlobeAggregate["Count"] = "count";
+	GlobeAggregate["Sum"] = "sum";
+	GlobeAggregate["Mean"] = "mean";
+	return GlobeAggregate;
+}({});
+/** Animated particle drawn along a flow. */
+var GlobeParticle = /* @__PURE__ */ function(GlobeParticle) {
+	GlobeParticle["Comet"] = "comet";
+	GlobeParticle["Bead"] = "bead";
+	GlobeParticle["Dash"] = "dash";
+	GlobeParticle["Arrow"] = "arrow";
+	return GlobeParticle;
+}({});
+/** Ribbon end shape. */
+var GlobeRibbonEnd = /* @__PURE__ */ function(GlobeRibbonEnd) {
+	GlobeRibbonEnd["Flat"] = "flat";
+	GlobeRibbonEnd["Tapered"] = "tapered";
+	GlobeRibbonEnd["Lens"] = "lens";
+	return GlobeRibbonEnd;
+}({});
+/** Ribbon cross-section. */
+var GlobeRibbonSection = /* @__PURE__ */ function(GlobeRibbonSection) {
+	GlobeRibbonSection["Sheet"] = "sheet";
+	GlobeRibbonSection["Bar"] = "bar";
+	return GlobeRibbonSection;
+}({});
+/** Which graticule lines carry data. */
+var GlobeLineFamily = /* @__PURE__ */ function(GlobeLineFamily) {
+	GlobeLineFamily["Parallels"] = "parallels";
+	GlobeLineFamily["Meridians"] = "meridians";
+	GlobeLineFamily["Both"] = "both";
+	return GlobeLineFamily;
+}({});
+/** Bubble solid. */
+var GlobeBubble = /* @__PURE__ */ function(GlobeBubble) {
+	GlobeBubble["Sphere"] = "sphere";
+	GlobeBubble["Dome"] = "dome";
+	GlobeBubble["Disc"] = "disc";
+	GlobeBubble["Column"] = "column";
+	return GlobeBubble;
+}({});
+/** Tile outline. */
+var GlobeTile = /* @__PURE__ */ function(GlobeTile) {
+	GlobeTile["Square"] = "square";
+	GlobeTile["Hexagon"] = "hexagon";
+	GlobeTile["Circle"] = "circle";
+	GlobeTile["Diamond"] = "diamond";
+	return GlobeTile;
+}({});
+/** What drives a trajectory's altitude. */
+var GlobeAltitude = /* @__PURE__ */ function(GlobeAltitude) {
+	GlobeAltitude["Surface"] = "surface";
+	GlobeAltitude["Value"] = "value";
+	GlobeAltitude["Time"] = "time";
+	return GlobeAltitude;
+}({});
+/** Trajectory stroke. */
+var GlobeTrail = /* @__PURE__ */ function(GlobeTrail) {
+	GlobeTrail["Tube"] = "tube";
+	GlobeTrail["Dots"] = "dots";
+	GlobeTrail["Ribbon"] = "ribbon";
+	return GlobeTrail;
+}({});
+/** Density kernel. */
+var GlobeKernel = /* @__PURE__ */ function(GlobeKernel) {
+	GlobeKernel["Gaussian"] = "gaussian";
+	GlobeKernel["Epanechnikov"] = "epanechnikov";
+	GlobeKernel["Triangular"] = "triangular";
+	return GlobeKernel;
+}({});
+/** Footprint of a prism. */
+var GlobeFootprint = /* @__PURE__ */ function(GlobeFootprint) {
+	GlobeFootprint["Region"] = "region";
+	GlobeFootprint["Inset"] = "inset";
+	GlobeFootprint["Proportional"] = "proportional";
+	GlobeFootprint["Hexagon"] = "hexagon";
+	GlobeFootprint["Circle"] = "circle";
+	return GlobeFootprint;
+}({});
+/** Ring chart form. */
+var GlobeRingForm = /* @__PURE__ */ function(GlobeRingForm) {
+	GlobeRingForm["Ripple"] = "ripple";
+	GlobeRingForm["Annulus"] = "annulus";
+	GlobeRingForm["Cap"] = "cap";
+	GlobeRingForm["Orbit"] = "orbit";
+	return GlobeRingForm;
+}({});
+/** Contour rendering. */
+var GlobeContourMode = /* @__PURE__ */ function(GlobeContourMode) {
+	GlobeContourMode["Lines"] = "lines";
+	GlobeContourMode["Bands"] = "bands";
+	GlobeContourMode["Terraces"] = "terraces";
+	return GlobeContourMode;
+}({});
+/** Contour field source. */
+var GlobeFieldWeight = /* @__PURE__ */ function(GlobeFieldWeight) {
+	GlobeFieldWeight["Density"] = "density";
+	GlobeFieldWeight["Value"] = "value";
+	return GlobeFieldWeight;
+}({});
+/** Streamline stroke. */
+var GlobeStreamStroke = /* @__PURE__ */ function(GlobeStreamStroke) {
+	GlobeStreamStroke["Tube"] = "tube";
+	GlobeStreamStroke["Comet"] = "comet";
+	GlobeStreamStroke["Arrow"] = "arrow";
+	return GlobeStreamStroke;
+}({});
+/** Where streamlines start. */
+var GlobeSeeding = /* @__PURE__ */ function(GlobeSeeding) {
+	GlobeSeeding["Lattice"] = "lattice";
+	GlobeSeeding["Random"] = "random";
+	return GlobeSeeding;
+}({});
+/** Dot placement inside a region. */
+var GlobeDotPlacement = /* @__PURE__ */ function(GlobeDotPlacement) {
+	GlobeDotPlacement["Random"] = "random";
+	GlobeDotPlacement["Lattice"] = "lattice";
+	return GlobeDotPlacement;
+}({});
+export { GlobeAggregate, GlobeAltitude, GlobeArcProfile, GlobeArcStroke, GlobeBubble, GlobeCell, GlobeClassify, GlobeContourMode, GlobeDotPlacement, GlobeFieldWeight, GlobeFootprint, GlobeKernel, GlobeLand, GlobeLineFamily, GlobeLinkWidth, GlobeMarker, GlobeParticle, GlobeProjection, GlobeRelief, GlobeResolution, GlobeRibbonEnd, GlobeRibbonSection, GlobeRingForm, GlobeSeeding, GlobeSizing, GlobeSpike, GlobeStreamStroke, GlobeSurface, GlobeSymbol, GlobeTile, GlobeTrail };

package/dist/charts/threeglobe/GlobeMath.js

@@ -0,0 +1,25 @@
+import { ScaleKind } from "../../core/enums.js";
+import { max, min, scaleLinear, scaleLog, scaleSqrt } from "d3";
+// src/charts/threeglobe/GlobeMath.ts
+/** Maps absolute values to 0..1. Zero stays at zero except on log scales, where the smallest positive value is the floor. */
+function magnitude(values, kind = ScaleKind.Linear) {
+	const sizes = values.map(Math.abs).filter(Number.isFinite);
+	const top = max(sizes) || 1;
+	if (kind === ScaleKind.Log) {
+		const floor = min(sizes.filter((v) => v > 0)) ?? 1;
+		const scale = scaleLog([floor * .5, Math.max(top, floor)], [0, 1]).clamp(true);
+		return (value) => value ? scale(Math.abs(value)) : 0;
+	}
+	const scale = (kind === ScaleKind.Sqrt ? scaleSqrt() : scaleLinear()).domain([0, top]).range([0, 1]).clamp(true);
+	return (value) => scale(Math.abs(value));
+}
+/** A readable number for keys and tooltips. */
+function short(value) {
+	const size = Math.abs(value);
+	return size >= 1e6 ? `${+(value / 1e6).toFixed(1)}M` : size >= 1e4 ? `${+(value / 1e3).toFixed(1)}k` : `${+value.toFixed(size < 10 ? 2 : 1)}`;
+}
+var finite = (value, fallback = 0) => {
+	const number = typeof value === "number" ? value : value == null || value === "" ? NaN : +value;
+	return Number.isFinite(number) ? number : fallback;
+};
+export { finite, magnitude, short };

package/dist/charts/threeglobe/GlobeProjections.js

@@ -0,0 +1,18 @@
+import { GlobeProjection } from "./GlobeEnums.js";
+import { geoAzimuthalEquidistant, geoEqualEarth, geoEquirectangular, geoMercator, geoNaturalEarth1 } from "d3";
+import { geoInterruptedHomolosine, geoMollweide, geoRobinson, geoSinusoidal, geoWinkel3 } from "d3-geo-projection";
+// src/charts/threeglobe/GlobeProjections.ts
+var factories = {
+	[GlobeProjection.NaturalEarth]: geoNaturalEarth1,
+	[GlobeProjection.Equirectangular]: geoEquirectangular,
+	[GlobeProjection.Mercator]: geoMercator,
+	[GlobeProjection.EqualEarth]: geoEqualEarth,
+	[GlobeProjection.Robinson]: geoRobinson,
+	[GlobeProjection.Mollweide]: geoMollweide,
+	[GlobeProjection.WinkelTripel]: geoWinkel3,
+	[GlobeProjection.Sinusoidal]: geoSinusoidal,
+	[GlobeProjection.Goode]: geoInterruptedHomolosine,
+	[GlobeProjection.AzimuthalEquidistant]: () => geoAzimuthalEquidistant().rotate([0, -90]).clipAngle(179.5)
+};
+var projectionFor = (kind) => factories[kind]();
+export { projectionFor };

package/dist/charts/threeglobe/GlobeSamples.js

@@ -0,0 +1,74 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/threeglobe/GlobeSamples.ts
+/** Reshapes `SampleData` into the geographic rows the globe charts read. */
+var GlobeSamples = class {
+	/** `{ name, lon, lat, value, group }`: points clustered around cities. */
+	static scatter(seed, count = 320) {
+		const cities = SampleData.cities(seed);
+		return SampleData.points(seed, count, 3).map((point, i) => {
+			const city = cities[(i * 7 + Math.floor(+point.size)) % cities.length], spread = 3 + +city.value / 100 * 9;
+			return {
+				name: String(city.name),
+				group: point.group,
+				value: +point.size,
+				lon: +city.lon + (+point.x % 11 - 5.5) / 5.5 * spread,
+				lat: Math.max(-85, Math.min(85, +city.lat + (+point.y % 7 - 3.5) / 3.5 * spread * .7))
+			};
+		});
+	}
+	/** `{ from, to, fromLon, fromLat, toLon, toLat, value }`: routes out of the three biggest hubs. */
+	static routes(seed) {
+		const cities = SampleData.cities(seed), hubs = [...cities].sort((a, b) => +b.value - +a.value).slice(0, 3);
+		return cities.flatMap((city, i) => hubs.filter((hub, h) => hub !== city && (i + h) % 2 === 0).map((hub) => ({
+			from: hub.name,
+			to: city.name,
+			fromLon: hub.lon,
+			fromLat: hub.lat,
+			toLon: city.lon,
+			toLat: city.lat,
+			value: Math.round((+hub.value + +city.value) / 2)
+		})));
+	}
+	/** `{ track, lon, lat, time, value }`: wandering paths between cities. */
+	static tracks(seed, tracks = 5, steps = 30) {
+		const cities = SampleData.cities(seed), walk = SampleData.timeSeries(seed, steps, 1);
+		return Array.from({ length: tracks }, (_, t) => {
+			const [a, b] = [cities[t * 3 % cities.length], cities[(t * 3 + 7) % cities.length]];
+			const span = (+b.lon - +a.lon + 540) % 360 - 180;
+			return walk.map((step, i) => {
+				const p = i / (steps - 1), bend = Math.sin(p * Math.PI) * (8 + t * 3) * (t % 2 ? -1 : 1);
+				return {
+					track: `Track ${t + 1}`,
+					lon: +a.lon + span * p,
+					lat: +a.lat + (+b.lat - +a.lat) * p + bend,
+					time: i,
+					value: +step.value
+				};
+			});
+		}).flat();
+	}
+	/** World regions with a second variable, `properties.share`. */
+	static regions(seed) {
+		const world = SampleData.world(seed), other = SampleData.world(seed + 1);
+		return {
+			...world,
+			features: world.features.map((feature, i) => ({
+				...feature,
+				properties: {
+					...feature.properties,
+					share: other.features[i].properties.value
+				}
+			}))
+		};
+	}
+	/** A global potential: `x` is longitude, `y` latitude. */
+	static field(seed) {
+		const { z } = SampleData.surface(seed, 37);
+		return {
+			x: Array.from({ length: 37 }, (_, i) => -180 + i * 10),
+			y: Array.from({ length: 37 }, (_, i) => -90 + i * 5),
+			z: z.map((row) => row.map((value, i) => value + .35 * Math.sin(i / 36 * Math.PI * 6)))
+		};
+	}
+};
+export { GlobeSamples };

package/dist/charts/threeglobe/Graticule3DGlobe.js

@@ -0,0 +1,91 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GeoMesher } from "./GeoMesher.js";
+import { densityRaster } from "./GeoField.js";
+import { GlobeKernel, GlobeLand, GlobeLineFamily, GlobeLinkWidth } from "./GlobeEnums.js";
+import { GlobeSamples } from "./GlobeSamples.js";
+import { MeshBuffer } from "./MeshBuffer.js";
+import { SiteGlobeChart } from "./SiteGlobeChart.js";
+import { Color } from "three";
+// src/charts/threeglobe/Graticule3DGlobe.ts
+var REACH = .2;
+/** The graticule itself as the data carrier: parallels swell over dense places, like ridgelines wrapped around the earth. */
+var Graticule3DGlobe = class extends SiteGlobeChart {
+	static meta = {
+		id: "graticule-3d-globe",
+		name: "Graticule globe",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Geo,
+		description: "Draws the world as parallels and meridians that lift and thicken with the local density of the data.",
+		tags: [
+			"wireframe",
+			"ridgeline",
+			"joy plot",
+			"lines"
+		],
+		sample: (seed) => GlobeSamples.scatter(seed, 240),
+		variants: {
+			family: Object.values(GlobeLineFamily),
+			step: [
+				5,
+				10,
+				15
+			],
+			displace: [true, false],
+			landOnly: [true, false],
+			weight: Object.values(GlobeLinkWidth)
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			family: GlobeLineFamily.Parallels,
+			step: 5,
+			displace: true,
+			landOnly: true,
+			weight: GlobeLinkWidth.Value,
+			land: GlobeLand.Bare
+		};
+	}
+	lines() {
+		const { family, step } = this.options, sample = 3, lines = [];
+		if (family !== GlobeLineFamily.Meridians) for (let lat = -90 + step; lat < 90; lat += step) lines.push(Array.from({ length: 121 }, (_, i) => [-180 + i * sample, lat]));
+		if (family !== GlobeLineFamily.Parallels) for (let lon = -180; lon < 180; lon += step) lines.push(Array.from({ length: 53 }, (_, i) => [lon, -78 + i * sample]));
+		return lines;
+	}
+	/** Bilinear read of the density raster. */
+	read(field, lon, lat) {
+		const x = Math.min(field.columns - 1.001, (lon + 180) / field.step), y = Math.min(field.rows - 1.001, (90 - lat) / field.step);
+		const [i, j] = [Math.floor(x), Math.floor(y)], [u, v] = [x - i, y - j], at = (a, b) => field.values[a + b * field.columns];
+		return (at(i, j) * (1 - u) + at(i + 1, j) * u) * (1 - v) + (at(i, j + 1) * (1 - u) + at(i + 1, j + 1) * u) * v;
+	}
+	draw(ctx) {
+		const { displace, landOnly, weight } = this.options;
+		const field = densityRaster(this.sites, 4, 7, GlobeKernel.Gaussian, () => 1);
+		const onLand = GeoMesher.locator(this.basemap), buffer = new MeshBuffer();
+		const shade = new Color(), low = ctx.color(this.theme.inkMuted);
+		let owner = 0;
+		for (const line of this.lines()) {
+			const runs = [[]];
+			for (const point of line) if (!landOnly || onLand(point[0], point[1]) >= 0) runs.at(-1).push(point);
+			else if (runs.at(-1).length) runs.push([]);
+			for (const run of runs) {
+				if (run.length < 2) continue;
+				const heights = run.map(([lon, lat]) => this.read(field, lon, lat));
+				const points = run.map(([lon, lat], i) => this.body.place(lon, lat, .004 + (displace ? heights[i] * REACH : 0)));
+				const at = (t) => heights[Math.round(t * (run.length - 1))];
+				buffer.tube(points, (t) => weight === GlobeLinkWidth.Value ? .003 + at(t) * .006 : .0034, (t) => {
+					const level = at(t);
+					return level < .03 ? low : shade.set(this.heat(ctx, level)).clone();
+				}, owner++, 4);
+			}
+		}
+		const mesh = buffer.build(ctx, {
+			sweep: true,
+			roughness: .7
+		});
+		ctx.root.add(mesh);
+		this.drawKey(ctx, this.ramp(ctx), 0, 1);
+	}
+};
+export { Graticule3DGlobe };

package/dist/charts/threeglobe/HeatGlobe.js

@@ -0,0 +1,107 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { densityRaster } from "./GeoField.js";
+import { GlobeKernel, GlobeLand, GlobeRelief, GlobeSurface } from "./GlobeEnums.js";
+import { GlobeSamples } from "./GlobeSamples.js";
+import { MeshBuffer } from "./MeshBuffer.js";
+import { SiteGlobeChart } from "./SiteGlobeChart.js";
+import { Vector3 } from "three";
+// src/charts/threeglobe/HeatGlobe.ts
+var STEP = 3;
+var FLOOR = .004;
+var FADE = .3;
+var TALL = .17;
+var TERRACES = 5;
+/** A continuous density surface draped over the earth: for concentrations too numerous to read as points. */
+var HeatGlobe = class extends SiteGlobeChart {
+	static meta = {
+		id: "heat-globe",
+		name: "Heat globe",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Geo,
+		description: "Smooths points with a spherical kernel into a draped surface, optionally raised into relief.",
+		tags: [
+			"heatmap",
+			"density",
+			"kde",
+			"hotspots"
+		],
+		sample: (seed) => GlobeSamples.scatter(seed, 320),
+		variants: {
+			kernel: Object.values(GlobeKernel),
+			bandwidth: [
+				8,
+				4,
+				14
+			],
+			relief: [
+				GlobeRelief.Proportional,
+				GlobeRelief.Flat,
+				GlobeRelief.Stepped
+			],
+			weighted: [false, true],
+			surface: [GlobeSurface.Sphere, GlobeSurface.Plane]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			kernel: GlobeKernel.Gaussian,
+			bandwidth: 8,
+			relief: GlobeRelief.Proportional,
+			weighted: false,
+			land: GlobeLand.Solid
+		};
+	}
+	draw(ctx) {
+		const { kernel, bandwidth, relief, weighted } = this.options;
+		const { columns, rows, values } = densityRaster(this.sites, STEP, bandwidth, kernel, (site) => weighted ? Math.abs(site.value) : 1), lift = new Float64Array(values.length);
+		values.forEach((level, i) => {
+			lift[i] = .006 + (relief === GlobeRelief.Proportional ? level * TALL : relief === GlobeRelief.Stepped ? Math.ceil(level * TERRACES) / TERRACES * TALL : 0);
+		});
+		const shades = Array.from({ length: 65 }, (_, i) => ctx.color(this.heat(ctx, i / 64)));
+		const buffer = new MeshBuffer(), used = /* @__PURE__ */ new Map(), at = new Vector3(), start = new Vector3(), n = new Vector3();
+		const vertex = (i, j) => {
+			const key = i + j * columns;
+			let id = used.get(key);
+			if (id === void 0) {
+				const [lon, lat] = [-180 + i * STEP, 90 - j * STEP];
+				this.body.place(lon, lat, lift[key], at);
+				this.body.place(lon, lat, .006, start);
+				used.set(key, id = buffer.vertex(at, this.body.normal(at, n), shades[Math.round(values[key] * 64)], start, Math.min(1, values[key] / FADE)));
+			}
+			return id;
+		};
+		for (let j = 0; j + 1 < rows; j++) for (let i = 0; i + 1 < columns; i++) {
+			const corners = [
+				i + j * columns,
+				i + 1 + j * columns,
+				i + (j + 1) * columns,
+				i + 1 + (j + 1) * columns
+			];
+			if (Math.max(...corners.map((corner) => values[corner])) < FLOOR) continue;
+			const [a, b, c, d] = [
+				vertex(i, j),
+				vertex(i + 1, j),
+				vertex(i, j + 1),
+				vertex(i + 1, j + 1)
+			];
+			buffer.face(a, c, b, 0);
+			buffer.face(b, c, d, 0);
+		}
+		if (!buffer.faces) return;
+		const mesh = buffer.build(ctx, {
+			roughness: .75,
+			relit: true,
+			fade: true
+		});
+		mesh.castShadow = relief !== GlobeRelief.Flat;
+		ctx.root.add(mesh);
+		this.drawKey(ctx, relief === GlobeRelief.Stepped ? Array.from({ length: TERRACES }, (_, i) => ({
+			from: i / TERRACES,
+			to: (i + 1) / TERRACES,
+			color: this.heat(ctx, (i + .5) / TERRACES)
+		})) : this.ramp(ctx), 0, 1);
+	}
+};
+export { HeatGlobe };

package/dist/charts/threeglobe/HexGlobe.js

@@ -0,0 +1,118 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { GlobeAggregate, GlobeCell, GlobeLand, GlobeResolution } from "./GlobeEnums.js";
+import { magnitude } from "./GlobeMath.js";
+import { GlobeSamples } from "./GlobeSamples.js";
+import { MeshBuffer } from "./MeshBuffer.js";
+import { SiteGlobeChart } from "./SiteGlobeChart.js";
+import { SphereGrid } from "./SphereGrid.js";
+import { SphereSurface } from "./SphereSurface.js";
+import { Vector3 } from "three";
+// src/charts/threeglobe/HexGlobe.ts
+var R = SphereSurface.radius;
+/** Points binned into a true spherical hex grid: for density at world scale without the pile-ups of raw dots. */
+var HexGlobe = class extends SiteGlobeChart {
+	static meta = {
+		id: "hex-globe",
+		name: "Hex globe",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Geo,
+		description: "Aggregates points into near-equal-area spherical cells, shown as coloured and raised prisms.",
+		tags: [
+			"hexbin",
+			"h3",
+			"goldberg",
+			"spatial binning"
+		],
+		sample: (seed) => GlobeSamples.scatter(seed, 320),
+		variants: {
+			cell: Object.values(GlobeCell),
+			resolution: Object.values(GlobeResolution),
+			aggregate: Object.values(GlobeAggregate),
+			extrude: [true, false],
+			empty: [false, true]
+		},
+		valid: (v) => v.extrude === true || v.aggregate === GlobeAggregate.Count
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			cell: GlobeCell.Hexagon,
+			resolution: GlobeResolution.Medium,
+			aggregate: GlobeAggregate.Count,
+			extrude: true,
+			empty: false,
+			land: GlobeLand.Solid
+		};
+	}
+	bins(cells) {
+		const bins = cells.map((cell) => ({
+			cell,
+			count: 0,
+			sum: 0,
+			names: /* @__PURE__ */ new Map()
+		})), at = new Vector3();
+		for (const site of this.sites) {
+			this.body.place(site.lon, site.lat, 0, at).normalize();
+			let best = 0, closest = -2;
+			cells.forEach((cell, i) => {
+				const dot = cell.center.dot(at);
+				if (dot > closest) {
+					closest = dot;
+					best = i;
+				}
+			});
+			const bin = bins[best];
+			bin.count++;
+			bin.sum += site.value;
+			if (site.name) bin.names.set(site.name, (bin.names.get(site.name) ?? 0) + 1);
+		}
+		return bins;
+	}
+	draw(ctx) {
+		const { cell, resolution, aggregate, extrude, empty } = this.options;
+		const all = this.bins(SphereGrid.cells(cell, resolution)), bins = empty ? all : all.filter((bin) => bin.count);
+		const score = (bin) => !bin.count ? 0 : aggregate === GlobeAggregate.Sum ? bin.sum : aggregate === GlobeAggregate.Mean ? bin.sum / bin.count : bin.count;
+		const size = magnitude(bins.map(score));
+		const tint = (bin) => bin.count ? this.heat(ctx, size(score(bin))) : this.landColor;
+		const buffer = new MeshBuffer();
+		bins.forEach((bin, i) => {
+			const lift = extrude && bin.count ? .012 + size(score(bin)) * .2 : .006;
+			this.prism(buffer, bin.cell, lift, ctx.color(tint(bin)), i);
+		});
+		const mesh = buffer.build(ctx, { roughness: .6 });
+		mesh.castShadow = extrude;
+		ctx.root.add(mesh);
+		ctx.pick(mesh, (i) => {
+			const bin = bins[i];
+			return {
+				title: [...bin.names.keys()][0] ?? "Empty cell",
+				rows: [["Points", bin.count], [aggregate, +score(bin).toFixed(2)]],
+				color: tint(bin)
+			};
+		});
+		if (bins.some((bin) => bin.count)) this.drawKey(ctx, this.ramp(ctx), 0, Math.max(...bins.map(score)));
+	}
+	prism(buffer, cell, lift, color, owner) {
+		const { center, corners } = cell, r = R + lift, top = center.clone().multiplyScalar(r);
+		const rim = corners.map((corner) => corner.clone().lerp(center, .14).normalize());
+		const hub = buffer.vertex(top, center, color, center.clone().multiplyScalar(R));
+		const tops = rim.map((corner) => buffer.vertex(corner.clone().multiplyScalar(r), center, color, corner.clone().multiplyScalar(R)));
+		tops.forEach((a, i) => buffer.face(hub, a, tops[(i + 1) % tops.length], owner));
+		const wall = new Vector3();
+		rim.forEach((a, i) => {
+			const b = rim[(i + 1) % rim.length];
+			wall.copy(a).add(b).sub(center).sub(center).normalize();
+			const [ta, tb] = [a.clone().multiplyScalar(r), b.clone().multiplyScalar(r)], [fa, fb] = [a.clone().multiplyScalar(R), b.clone().multiplyScalar(R)];
+			const [p, q, s, t] = [
+				buffer.vertex(ta, wall, color, fa),
+				buffer.vertex(tb, wall, color, fb),
+				buffer.vertex(fa, wall, color),
+				buffer.vertex(fb, wall, color)
+			];
+			buffer.face(p, s, q, owner);
+			buffer.face(q, s, t, owner);
+		});
+	}
+};
+export { HexGlobe };