@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/geomaps/FloorPlanSamples.js

@@ -0,0 +1,416 @@
+import { SampleData } from "../../data/SampleData.js";
+import { FloorDoorSwing } from "./FloorPlanModel.js";
+// src/charts/geomaps/FloorPlanSamples.ts
+var box = (x0, y0, x1, y1) => [
+	[x0, y0],
+	[x1, y0],
+	[x1, y1],
+	[x0, y1]
+];
+var { Left, Right, None } = FloorDoorSwing;
+var CORRIDOR = box(0, 8, 40, 12);
+var STAIR = box(26, 12, 30, 20);
+/** Floor, name and polygon, in metres. A null floor would mean every floor; these plans name theirs. */
+var ROOMS = [
+	[
+		1,
+		"Lobby",
+		box(0, 0, 14, 8)
+	],
+	[
+		1,
+		"Reception",
+		box(14, 0, 22, 8)
+	],
+	[
+		1,
+		"Cafe",
+		[
+			[22, 0],
+			[40, 0],
+			[40, 20],
+			[30, 20],
+			[30, 8],
+			[22, 8]
+		]
+	],
+	[
+		1,
+		"Corridor",
+		box(0, 8, 30, 12),
+		false
+	],
+	[
+		1,
+		"Meeting A",
+		box(0, 12, 9, 20)
+	],
+	[
+		1,
+		"Meeting B",
+		box(9, 12, 18, 20)
+	],
+	[
+		1,
+		"WC",
+		box(18, 12, 22, 20)
+	],
+	[
+		1,
+		"Store",
+		box(22, 12, 26, 20)
+	],
+	[
+		1,
+		"Stair",
+		STAIR,
+		false
+	],
+	[
+		2,
+		"Director",
+		box(0, 0, 10, 8)
+	],
+	[
+		2,
+		"Open office",
+		[box(10, 0, 40, 8), box(22, 3, 28, 5)]
+	],
+	[
+		2,
+		"Corridor",
+		CORRIDOR,
+		false
+	],
+	[
+		2,
+		"Focus room one",
+		box(0, 12, 5, 20)
+	],
+	[
+		2,
+		"Focus room two",
+		box(5, 12, 10, 20)
+	],
+	[
+		2,
+		"Conference room",
+		box(10, 12, 22, 20)
+	],
+	[
+		2,
+		"Phone",
+		box(22, 12, 26, 20)
+	],
+	[
+		2,
+		"Stair",
+		STAIR,
+		false
+	],
+	[
+		2,
+		"Server room",
+		box(30, 12, 40, 20)
+	],
+	[
+		3,
+		"Wet lab",
+		box(0, 0, 18, 8)
+	],
+	[
+		3,
+		"Dry lab",
+		box(18, 0, 32, 8)
+	],
+	[
+		3,
+		"Cold room",
+		box(32, 0, 40, 8)
+	],
+	[
+		3,
+		"Corridor",
+		CORRIDOR,
+		false
+	],
+	[
+		3,
+		"Preparation",
+		box(0, 12, 12, 20)
+	],
+	[
+		3,
+		"Instrument bay",
+		box(12, 12, 26, 20)
+	],
+	[
+		3,
+		"Stair",
+		STAIR,
+		false
+	],
+	[
+		3,
+		"Plant room",
+		box(30, 12, 40, 20)
+	]
+];
+/** Floor, hinge, latch, swing. */
+var DOORS = [
+	[
+		1,
+		[6, 8],
+		[8, 8],
+		None
+	],
+	[
+		1,
+		[17, 8],
+		[18, 8],
+		Right
+	],
+	[
+		1,
+		[30, 9.5],
+		[30, 11],
+		None
+	],
+	[
+		1,
+		[4, 12],
+		[5, 12],
+		Left
+	],
+	[
+		1,
+		[13, 12],
+		[14, 12],
+		Left
+	],
+	[
+		1,
+		[19.5, 12],
+		[20.5, 12],
+		Left
+	],
+	[
+		1,
+		[23.5, 12],
+		[24.5, 12],
+		Left
+	],
+	[
+		1,
+		[27.5, 12],
+		[28.5, 12],
+		None
+	],
+	[
+		2,
+		[4.5, 8],
+		[5.5, 8],
+		Right
+	],
+	[
+		2,
+		[24, 8],
+		[26, 8],
+		None
+	],
+	[
+		2,
+		[2, 12],
+		[3, 12],
+		Left
+	],
+	[
+		2,
+		[7, 12],
+		[8, 12],
+		Left
+	],
+	[
+		2,
+		[15, 12],
+		[16, 12],
+		Left
+	],
+	[
+		2,
+		[23.5, 12],
+		[24.5, 12],
+		Left
+	],
+	[
+		2,
+		[27.5, 12],
+		[28.5, 12],
+		None
+	],
+	[
+		2,
+		[34, 12],
+		[35, 12],
+		Left
+	],
+	[
+		3,
+		[8, 8],
+		[9, 8],
+		Right
+	],
+	[
+		3,
+		[25, 8],
+		[26, 8],
+		Right
+	],
+	[
+		3,
+		[35.5, 8],
+		[36.5, 8],
+		Right
+	],
+	[
+		3,
+		[5, 12],
+		[6, 12],
+		Left
+	],
+	[
+		3,
+		[18, 12],
+		[20, 12],
+		None
+	],
+	[
+		3,
+		[27.5, 12],
+		[28.5, 12],
+		None
+	],
+	[
+		3,
+		[34.5, 12],
+		[35.5, 12],
+		Left
+	]
+];
+/** Floor, kind, position. */
+var ASSETS = [
+	[
+		1,
+		"Extinguisher",
+		1,
+		9
+	],
+	[
+		1,
+		"Extinguisher",
+		21,
+		11
+	],
+	[
+		1,
+		"Defibrillator",
+		13,
+		1.5
+	],
+	[
+		1,
+		"Access point",
+		34,
+		14
+	],
+	[
+		1,
+		"Printer",
+		15.5,
+		1.5
+	],
+	[
+		2,
+		"Extinguisher",
+		1,
+		9
+	],
+	[
+		2,
+		"Extinguisher",
+		38,
+		11
+	],
+	[
+		2,
+		"Printer",
+		12,
+		6.5
+	],
+	[
+		2,
+		"Access point",
+		34,
+		2
+	],
+	[
+		2,
+		"Access point",
+		16,
+		2
+	],
+	[
+		3,
+		"Extinguisher",
+		1,
+		9
+	],
+	[
+		3,
+		"Extinguisher",
+		38,
+		11
+	],
+	[
+		3,
+		"Defibrillator",
+		16,
+		1.5
+	],
+	[
+		3,
+		"Access point",
+		24,
+		2
+	]
+];
+/** A synthetic three-storey building. The layout is invented and every value is simulated, not a measurement. */
+var FloorPlanSamples = class {
+	/** Simulated occupancy per cent, drawn from `SampleData`. Corridors and stairs have no sensor, so no value. */
+	static building(seed) {
+		const draws = SampleData.distribution(seed, ROOMS.length, 1);
+		return {
+			rooms: ROOMS.map(([level, name, points, metered = true], i) => ({
+				level,
+				name,
+				points,
+				value: metered ? Math.round(Math.max(2, Math.min(98, 52 + (draws[i].value - 40) / 8 * 20))) : null
+			})),
+			doors: DOORS.map(([level, from, to, swing]) => ({
+				level,
+				from,
+				to,
+				swing,
+				name: swing === None ? "Opening" : "Door"
+			})),
+			assets: ASSETS.map(([level, type, x, y], i) => ({
+				id: `tag-${i}`,
+				level,
+				type,
+				x,
+				y
+			}))
+		};
+	}
+};
+export { FloorPlanSamples };

package/dist/charts/geomaps/GeoChart.js

@@ -0,0 +1,196 @@
+import { Chart2D } from "../../core/Chart2D.js";
+import { LegendPosition } from "../../core/enums.js";
+import { GeoFraming, GeoProjectionKind, GeoProjections } from "./GeoProjection.js";
+import { GeoViewport } from "./GeoViewport.js";
+import { color, forceCollide, forceSimulation, forceX, forceY, geoArea, geoBounds, geoGraticule, geoPath, range } from "d3";
+// src/charts/geomaps/GeoChart.ts
+var SPHERE = { type: "Sphere" };
+var USA_BOX = {
+	type: "MultiPoint",
+	coordinates: [[-122, 28], [-69, 48]]
+};
+var ids = 0;
+/**
+* Base of every map: projection, framing, sphere, graticule and key strip.
+* Subclasses say what to fit (`target`) and draw marks in `drawMap`.
+*/
+var GeoChart = class extends Chart2D {
+	clipId = `geo-clip-${++ids}`;
+	/** Programmatic pan and zoom: `zoomIn`, `zoomOut`, `reset`, `fit`. */
+	viewport = new GeoViewport(this);
+	defaults() {
+		return {
+			projection: GeoProjectionKind.NaturalEarth,
+			framing: GeoFraming.Auto,
+			graticule: true,
+			graticuleStep: 30,
+			legend: LegendPosition.None,
+			zoom: false,
+			maxZoom: 16
+		};
+	}
+	plotMargin() {
+		return {
+			top: 6,
+			right: 8,
+			bottom: 6,
+			left: 8
+		};
+	}
+	/** Height of the key strip under the map. */
+	keyHeight() {
+		return 0;
+	}
+	/** Room to keep clear inside the map, for marks that stand taller than their location. */
+	inset(_ctx) {
+		return {};
+	}
+	drawKey(_ctx, _frame) {}
+	/** Whether the globe's outline frames the map; abstract layouts turn it off. */
+	get framed() {
+		return true;
+	}
+	/** Called as the view moves. `settled` is true once a gesture ends. */
+	viewMoved(_transform, settled) {
+		if (settled) this.settled(this.viewport.scale);
+	}
+	/** A gesture ended at this zoom. */
+	settled(_scale) {}
+	/** Under-map layer such as tiles. */
+	drawBackdrop(_ctx, _frame) {}
+	get zoomable() {
+		return !!this.options.zoom;
+	}
+	/** Whether the map redraws from its projection as it moves, rather than scaling what is drawn. */
+	get semanticZoom() {
+		return false;
+	}
+	viewLimits({ width, height }) {
+		return {
+			scale: [1, this.options.maxZoom],
+			pan: [[0, 0], [width, height]]
+		};
+	}
+	draw(outer) {
+		const frame = this.frame(outer);
+		const ctx = this.viewport.attach(outer, {
+			enabled: this.zoomable,
+			width: frame.width,
+			height: frame.height,
+			limits: this.viewLimits(frame),
+			semantic: this.semanticZoom,
+			pinned: this.framed,
+			smooth: this.animated
+		});
+		this.drawBackdrop(ctx, frame);
+		this.drawBase(ctx, frame);
+		this.drawMap(ctx, frame);
+		this.drawKey(outer, frame);
+		this.viewport.finish(outer);
+	}
+	/** Wraps a fitted projection in the frame marks draw against. */
+	frameOf(projection, width, height) {
+		const path = geoPath(projection);
+		return {
+			projection,
+			path,
+			width,
+			height,
+			locate(lon, lat) {
+				const [x, y] = path.centroid({
+					type: "Point",
+					coordinates: [lon, lat]
+				});
+				return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;
+			},
+			anchor(feature) {
+				const { geometry } = feature;
+				const parts = geometry?.type === "MultiPolygon" ? geometry.coordinates.map((coordinates) => ({
+					type: "Polygon",
+					coordinates
+				})) : [geometry];
+				const main = parts.reduce((best, part) => geoArea(part) > geoArea(best) ? part : best, parts[0]);
+				const [x, y] = path.centroid(main);
+				return Number.isFinite(x) && Number.isFinite(y) ? [x, y] : null;
+			}
+		};
+	}
+	frame(ctx) {
+		const { projection: kind = GeoProjectionKind.NaturalEarth, rotate, framing } = this.options;
+		const width = ctx.plot.width, height = Math.max(40, ctx.plot.height - this.keyHeight());
+		const { top = 0, right = 0, bottom = 0, left = 0 } = this.inset(ctx);
+		const projection = GeoProjections.create(kind);
+		const target = framing === GeoFraming.Sphere ? null : this.target();
+		const box = target ? geoBounds(target) : null;
+		const bounded = box?.flat().every(Number.isFinite) ? box : null;
+		const span = bounded ? (bounded[1][0] - bounded[0][0] + 360) % 360 || 360 : 360;
+		const zoomed = !!bounded && (framing === GeoFraming.Data || span < 240 && bounded[1][1] - bounded[0][1] < 110);
+		const outline = kind === GeoProjectionKind.AlbersUsa ? target ?? USA_BOX : zoomed && span + (bounded[1][1] - bounded[0][1]) > .01 ? target : zoomed ? this.padded(bounded) : GeoProjections.outline(kind);
+		if (rotate) GeoProjections.rotate(projection, rotate);
+		else if (zoomed) GeoProjections.center(projection, kind, bounded);
+		const extent = [[left + 1, top + 1], [width - right - 1, height - bottom - 1]];
+		projection.fitExtent(extent, outline);
+		if (!projection.translate().every(Number.isFinite)) projection.fitExtent(extent, USA_BOX);
+		if (zoomed || GeoProjections.unbounded(kind)) projection.clipExtent?.([[0, 0], [width, height]]);
+		return this.frameOf(projection, width, height);
+	}
+	/** A single point has no extent to fit: frame the few degrees around it. */
+	padded([[west, south]]) {
+		return {
+			type: "MultiPoint",
+			coordinates: [[west - 4, south - 3], [west + 4, south + 3]]
+		};
+	}
+	drawBase(ctx, { path }) {
+		const { theme } = ctx;
+		ctx.root.attr("clip-path", GeoProjections.lobed(this.options.projection) ? this.clip(ctx, path(SPHERE) ?? "", "lobes") : null);
+		ctx.marks("sphere", "path", this.framed ? [SPHERE] : []).attr("d", (d) => path(d) ?? "").attr("fill", theme.grid).attr("fill-opacity", .28).attr("stroke", theme.axis).attr("stroke-width", 1).attr("stroke-opacity", .8);
+		const step = this.options.graticuleStep;
+		const lines = this.options.graticule ? [geoGraticule().step([step, step])()] : [];
+		ctx.marks("graticule", "path", lines).attr("d", (d) => path(d) ?? "").attr("fill", "none").attr("stroke", theme.grid).attr("stroke-width", .75);
+	}
+	/** Region border: a hairline of surface, thin enough to keep small countries visible. */
+	hairline(ctx) {
+		return Math.max(.35, Math.min(1, ctx.plot.width / 900));
+	}
+	/** Fades filled shapes in, with their geometry in place from the first frame. */
+	fill(ctx, marks, d, opacity = 1, stagger = 0) {
+		return ctx.set(marks, {
+			d,
+			"fill-opacity": opacity
+		}, {
+			d,
+			"fill-opacity": 0
+		}, stagger);
+	}
+	/** Text-legible ink for any colour string a scale can return. */
+	inkOn(ctx, fill) {
+		return ctx.palette.inkOn(color(fill)?.formatHex() ?? fill);
+	}
+	/** Surface-coloured halo so labels stay readable over land and marks. */
+	halo(ctx, labels) {
+		return labels.attr("paint-order", "stroke").attr("stroke", ctx.theme.surface).attr("stroke-width", 3).attr("stroke-linejoin", "round");
+	}
+	/** A `clip-path` reference limited to `d`, regenerated on each paint. */
+	clip(ctx, d, name = "mask") {
+		const id = `${this.clipId}-${name}`, holder = ctx.group(`clip-${name}`);
+		let shape = holder.select("clipPath");
+		if (shape.empty()) shape = holder.append("clipPath").attr("id", id);
+		shape.selectAll("path").data([d]).join("path").attr("d", (value) => value);
+		return `url(#${id})`;
+	}
+	/** Pushes overlapping discs apart while pulling each towards its true position, inside the map. */
+	dodge(discs, frame, gap = 1, ticks = 160) {
+		const keep = (d) => {
+			d.x = Math.max(d.r + 1, Math.min(frame.width - d.r - 1, d.x));
+			d.y = Math.max(d.r + 1, Math.min(frame.height - d.r - 1, d.y));
+		};
+		const simulation = forceSimulation(discs).stop().force("x", forceX((d) => d.homeX).strength(.09)).force("y", forceY((d) => d.homeY).strength(.09)).force("collide", forceCollide((d) => d.r + gap).iterations(3));
+		for (const _ of range(ticks)) {
+			simulation.tick();
+			discs.forEach(keep);
+		}
+		return discs;
+	}
+};
+export { GeoChart };

package/dist/charts/geomaps/GeoClasses.js

@@ -0,0 +1,89 @@
+import { extent, quantileSorted, range } from "d3";
+// src/charts/geomaps/GeoClasses.ts
+var GeoClassification = /* @__PURE__ */ function(GeoClassification) {
+	GeoClassification["Continuous"] = "continuous";
+	GeoClassification["Quantile"] = "quantile";
+	GeoClassification["EqualInterval"] = "equal-interval";
+	GeoClassification["NaturalBreaks"] = "natural-breaks";
+	return GeoClassification;
+}({});
+/** Jenks natural breaks by dynamic programming: minimises within-class variance. */
+function naturalBreaks(sorted, bins) {
+	const n = sorted.length;
+	const prefix = [0], squares = [0];
+	for (const value of sorted) {
+		prefix.push(prefix.at(-1) + value);
+		squares.push(squares.at(-1) + value * value);
+	}
+	const cost = (from, to) => {
+		const total = prefix[to + 1] - prefix[from];
+		return squares[to + 1] - squares[from] - total * total / (to - from + 1);
+	};
+	let best = sorted.map((_, i) => cost(0, i));
+	const cuts = [];
+	for (let k = 1; k < bins; k++) {
+		const next = best.slice(), cut = new Array(n).fill(0);
+		for (let i = k; i < n; i++) {
+			next[i] = Infinity;
+			for (let j = k; j <= i; j++) {
+				const trial = best[j - 1] + cost(j, i);
+				if (trial < next[i]) {
+					next[i] = trial;
+					cut[i] = j;
+				}
+			}
+		}
+		best = next;
+		cuts.push(cut);
+	}
+	const breaks = [];
+	let end = n - 1;
+	for (let k = bins - 2; k >= 0; k--) {
+		end = cuts[k][end] - 1;
+		breaks.unshift((sorted[end] + sorted[end + 1]) / 2);
+	}
+	return breaks;
+}
+/** Turns a value column into class breaks and a 0..1 tone. Tolerates empty and constant columns. */
+var GeoClasses = class {
+	/** Ascending class limits, first = minimum, last = maximum. Continuous scales have just the two. */
+	breaks;
+	min;
+	max;
+	classed;
+	constructor(values, method = "continuous", bins = 5) {
+		const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+		const [low = 0, high = 1] = extent(sorted);
+		this.min = low;
+		this.max = high > low ? high : low + 1;
+		this.classed = method !== "continuous";
+		const inner = () => {
+			if (sorted.length <= bins) return [];
+			if (method === "quantile") return range(1, bins).map((i) => quantileSorted(sorted, i / bins));
+			if (method === "natural-breaks") return naturalBreaks(sorted, bins);
+			if (method === "equal-interval") return range(1, bins).map((i) => this.min + (this.max - this.min) * i / bins);
+			return [];
+		};
+		this.breaks = [.../* @__PURE__ */ new Set([
+			this.min,
+			...inner(),
+			this.max
+		])];
+	}
+	get bins() {
+		return this.breaks.length - 1;
+	}
+	bin(value) {
+		const i = this.breaks.findIndex((limit) => value < limit);
+		return Math.min(this.bins - 1, Math.max(0, (i < 0 ? this.bins : i) - 1));
+	}
+	/** Position on a 0..1 colour ramp: the class centre when classed, proportional otherwise. */
+	tone(value) {
+		return this.classed ? (this.bin(value) + .5) / this.bins : (value - this.min) / (this.max - this.min);
+	}
+	/** Representative value of a class. */
+	center(bin) {
+		return (this.breaks[bin] + this.breaks[bin + 1]) / 2;
+	}
+};
+export { GeoClasses, GeoClassification };