floor-editor-ts 1.0.9 → 1.1.0

package/dist/floor-editor.es.js

@@ -62605,6 +62605,48 @@ function wts(cs, wx, wy) {
 		y: (wy - cs.camY) * cs.zoom + cs.height / 2
 	};
 }
+function getFloorBounds(floor, options = {}) {
+	var _floor$walls;
+	if (!((_floor$walls = floor.walls) === null || _floor$walls === void 0 ? void 0 : _floor$walls.length)) return null;
+	let minX = Infinity;
+	let maxX = -Infinity;
+	let minY = Infinity;
+	let maxY = -Infinity;
+	let found = false;
+	function expand(x, y, pad = 0) {
+		minX = Math.min(minX, x - pad);
+		maxX = Math.max(maxX, x + pad);
+		minY = Math.min(minY, y - pad);
+		maxY = Math.max(maxY, y + pad);
+		found = true;
+	}
+	for (const wall of floor.walls) {
+		const pad = options.includeWallThickness ? wall.thickness / 2 : 0;
+		if (wall.curvePoint) {
+			const segments = 24;
+			for (let i = 0; i <= segments; i++) {
+				const t = i / segments;
+				const mt = 1 - t;
+				expand(mt * mt * wall.start.x + 2 * mt * t * wall.curvePoint.x + t * t * wall.end.x, mt * mt * wall.start.y + 2 * mt * t * wall.curvePoint.y + t * t * wall.end.y, pad);
+			}
+		} else {
+			expand(wall.start.x, wall.start.y, pad);
+			expand(wall.end.x, wall.end.y, pad);
+		}
+	}
+	if (!found) return null;
+	const width = maxX - minX;
+	const height = maxY - minY;
+	if (width <= 0 || height <= 0) return null;
+	return {
+		minX,
+		minY,
+		maxX,
+		maxY,
+		width,
+		height
+	};
+}
 function drawWall(cs, w, selected, showDimensions, dimSettings) {
 	const { ctx, zoom, width, height } = cs;
 	const s = wts(cs, w.start.x, w.start.y);
@@ -64133,6 +64175,80 @@ function drawMinimap(cs, minimapCanvas, floor, getWorldBBox) {
 	mctx.lineWidth = 1;
 	mctx.strokeRect(0, 0, mw, mh);
 }
+function drawFloorHeatmap(cs, floor, heatmapMatrix, detectedRooms) {
+	var _heatmapMatrix$;
+	const { ctx, zoom } = cs;
+	const rows = heatmapMatrix.length;
+	const cols = ((_heatmapMatrix$ = heatmapMatrix[0]) === null || _heatmapMatrix$ === void 0 ? void 0 : _heatmapMatrix$.length) || 0;
+	if (rows === 0 || cols === 0) return;
+	const maxValue = Math.max(...heatmapMatrix.flat());
+	if (maxValue <= 0) return;
+	const bounds = getFloorBounds(floor);
+	if (!bounds) return;
+	const { minX, minY, maxX, maxY } = bounds;
+	const boxW = bounds.width;
+	const boxH = bounds.height;
+	if (boxW <= 0 || boxH <= 0) return;
+	const cellW = boxW / cols;
+	const cellH = boxH / rows;
+	ctx.save();
+	const boundP1 = wts(cs, minX, minY);
+	const boundP2 = wts(cs, maxX, maxY);
+	ctx.beginPath();
+	ctx.rect(Math.min(boundP1.x, boundP2.x), Math.min(boundP1.y, boundP2.y), Math.abs(boundP2.x - boundP1.x), Math.abs(boundP2.y - boundP1.y));
+	ctx.clip();
+	let hasRoomClip = false;
+	ctx.beginPath();
+	for (const room of detectedRooms) {
+		const poly = getRoomPolygon(room, floor.walls);
+		if (poly.length < 3) continue;
+		const screenPoly = poly.map((p) => wts(cs, p.x, p.y));
+		ctx.moveTo(screenPoly[0].x, screenPoly[0].y);
+		for (let i = 1; i < screenPoly.length; i++) ctx.lineTo(screenPoly[i].x, screenPoly[i].y);
+		ctx.closePath();
+		hasRoomClip = true;
+	}
+	if (hasRoomClip) ctx.clip();
+	ctx.globalCompositeOperation = "source-over";
+	ctx.filter = `blur(${Math.min(14, Math.max(3, 5 * zoom))}px)`;
+	const radius = Math.max(cellW, cellH) * zoom * 1.15;
+	for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) {
+		const value = heatmapMatrix[y][x];
+		if (!value || value <= 0) continue;
+		const intensity = Math.min(value / maxValue, 1);
+		const s = wts(cs, minX + (x + .5) * cellW, minY + (y + .5) * cellH);
+		const gradient = ctx.createRadialGradient(s.x, s.y, 0, s.x, s.y, radius);
+		const alpha = .08 + intensity * .45;
+		gradient.addColorStop(0, getHeatmapColor(intensity, alpha));
+		gradient.addColorStop(.35, getHeatmapColor(intensity, alpha * .35));
+		gradient.addColorStop(1, getHeatmapColor(intensity, 0));
+		ctx.fillStyle = gradient;
+		ctx.beginPath();
+		ctx.arc(s.x, s.y, radius, 0, Math.PI * 2);
+		ctx.fill();
+	}
+	ctx.filter = "none";
+	ctx.globalCompositeOperation = "source-over";
+	ctx.strokeStyle = "rgba(255, 255, 255, 0.22)";
+	ctx.lineWidth = Math.max(.5, 1 / zoom);
+	ctx.beginPath();
+	for (let x = 0; x <= cols; x++) {
+		const wx = minX + x * cellW;
+		const p1 = wts(cs, wx, minY);
+		const p2 = wts(cs, wx, maxY);
+		ctx.moveTo(p1.x, p1.y);
+		ctx.lineTo(p2.x, p2.y);
+	}
+	for (let y = 0; y <= rows; y++) {
+		const wy = minY + y * cellH;
+		const p1 = wts(cs, minX, wy);
+		const p2 = wts(cs, maxX, wy);
+		ctx.moveTo(p1.x, p1.y);
+		ctx.lineTo(p2.x, p2.y);
+	}
+	ctx.stroke();
+	ctx.restore();
+}
 //#endregion
 //#region src/lib/utils/hitTesting.ts
 function pointInPolygon(p, poly) {
@@ -64511,6 +64627,7 @@ function FloorPlanCanvas($$anchor, $$props) {
 	const RULER_SIZE = 24;
 	let detectedRooms = /* @__PURE__ */ state(proxy([]));
 	let lastWallHash = "";
+	const GRID = 20;
 	const SNAP = 10;
 	const MAGNETIC_SNAP = 15;
 	const WALL_SNAP_DIST = 30;
@@ -64814,6 +64931,46 @@ function FloorPlanCanvas($$anchor, $$props) {
 		markDirty();
 		needsFitToCanvas = true;
 	}
+	function drawGrid() {
+		if (!ctx || !get(showGrid)) return;
+		const step = (get(currentSnapToGrid) ? get(currentGridSize) : GRID) * get(zoom);
+		if (step < 4) return;
+		ctx.strokeStyle = "#e8eaed";
+		ctx.lineWidth = .5;
+		const offX = (get(width) / 2 - get(camX) * get(zoom)) % step;
+		const offY = (get(height) / 2 - get(camY) * get(zoom)) % step;
+		for (let x = offX; x < get(width); x += step) {
+			ctx.beginPath();
+			ctx.moveTo(x, 0);
+			ctx.lineTo(x, get(height));
+			ctx.stroke();
+		}
+		for (let y = offY; y < get(height); y += step) {
+			ctx.beginPath();
+			ctx.moveTo(0, y);
+			ctx.lineTo(get(width), y);
+			ctx.stroke();
+		}
+		const majorStep = 100 * get(zoom);
+		if (majorStep >= 20) {
+			ctx.strokeStyle = "#d1d5db";
+			ctx.lineWidth = .8;
+			const mOffX = (get(width) / 2 - get(camX) * get(zoom)) % majorStep;
+			const mOffY = (get(height) / 2 - get(camY) * get(zoom)) % majorStep;
+			for (let x = mOffX; x < get(width); x += majorStep) {
+				ctx.beginPath();
+				ctx.moveTo(x, 0);
+				ctx.lineTo(x, get(height));
+				ctx.stroke();
+			}
+			for (let y = mOffY; y < get(height); y += majorStep) {
+				ctx.beginPath();
+				ctx.moveTo(0, y);
+				ctx.lineTo(get(width), y);
+				ctx.stroke();
+			}
+		}
+	}
 	/** Get point on wall at parameter t (0-1), handling curves */
 	function wallPointAt(w, t) {
 		if (w.curvePoint) {
@@ -65254,6 +65411,9 @@ function FloorPlanCanvas($$anchor, $$props) {
 		}
 		canvasDirty = false;
 		ctx.clearRect(0, 0, get(width), get(height));
+		ctx.fillStyle = "#f8f9fa";
+		ctx.fillRect(0, 0, $$props.floorMaxWidth, $$props.floorMaxHeight);
+		drawGrid();
 		if (!$$props.viewOnly && get(layerVis).guides) drawGuides$1();
 		drawBackgroundImage();
 		const floor = get(currentFloor);
@@ -65273,6 +65433,7 @@ function FloorPlanCanvas($$anchor, $$props) {
 			return id === selId || multiIds.has(id);
 		}
 		drawRooms$1();
+		if (floor && $$props.heatmapEnabled) drawFloorHeatmap(getCS(), floor, $$props.heatmapMatrix || [], get(detectedRooms));
 		if (!$$props.viewOnly) drawSnapPoints$1();
 		if (get(layerVis).walls) {
 			for (const w of floor.walls) drawWall$1(w, isSelected(w.id));
@@ -70291,7 +70452,9 @@ function App($$anchor, $$props) {
 	let config = /* @__PURE__ */ state(proxy({
 		viewOnly: false,
 		floorMaxWidth: 600,
-		floorMaxHeight: 400
+		floorMaxHeight: 400,
+		heatmapEnabled: false,
+		heatmapMatrix: []
 	}));
 	(_$$props$stores = $$props.stores) === null || _$$props$stores === void 0 || _$$props$stores.floorData.subscribe((v) => set(floorData, v, true));
 	(_$$props$stores2 = $$props.stores) === null || _$$props$stores2 === void 0 || _$$props$stores2.config.subscribe((v) => set(config, v, true));
@@ -70402,6 +70565,14 @@ function App($$anchor, $$props) {
 					var _$$get4;
 					return (_$$get4 = get(config)) === null || _$$get4 === void 0 ? void 0 : _$$get4.floorMaxHeight;
 				});
+				let $3 = /* @__PURE__ */ user_derived(() => {
+					var _$$get5;
+					return (_$$get5 = get(config)) === null || _$$get5 === void 0 ? void 0 : _$$get5.heatmapMatrix;
+				});
+				let $4 = /* @__PURE__ */ user_derived(() => {
+					var _$$get6;
+					return (_$$get6 = get(config)) === null || _$$get6 === void 0 ? void 0 : _$$get6.heatmapEnabled;
+				});
 				FloorPlanCanvas(node_4, {
 					get viewOnly() {
 						return get($0);
@@ -70411,6 +70582,12 @@ function App($$anchor, $$props) {
 					},
 					get floorMaxHeight() {
 						return get($2);
+					},
+					get heatmapMatrix() {
+						return get($3);
+					},
+					get heatmapEnabled() {
+						return get($4);
 					}
 				});
 			}