gps-plus-slam-app-framework 1.1.0 → 1.2.0

package/dist/ar/occupancy-grid.js

@@ -0,0 +1,164 @@
+import { createDepthUnprojector } from "./depth-unprojection.js";
+import { bresenham3d } from "./bresenham3d.js";
+//#region ../src/ar/occupancy-grid.ts
+var OccupancyGrid = class {
+	cellSizeM;
+	carveStopCells;
+	cells = /* @__PURE__ */ new Map();
+	constructor(options) {
+		const cellSizeM = options?.cellSizeM ?? .15;
+		const carveStopCells = options?.carveStopCells ?? 2;
+		if (!Number.isFinite(cellSizeM) || cellSizeM <= 0) throw new RangeError(`cellSizeM must be a positive number, got ${cellSizeM}`);
+		if (!Number.isSafeInteger(carveStopCells) || carveStopCells < 0) throw new RangeError(`carveStopCells must be a non-negative integer, got ${carveStopCells}`);
+		this.cellSizeM = cellSizeM;
+		this.carveStopCells = carveStopCells;
+	}
+	/** Number of occupied cells. */
+	get size() {
+		return this.cells.size;
+	}
+	/**
+	* Fold one depth sample into the grid: unproject each point, carve free
+	* space from the camera cell to the point cell, then count the point's
+	* cell as occupied. Points that cannot be unprojected (no
+	* projectionMatrix on old recordings, invalid depth/coords) are skipped.
+	*
+	* Carving and incrementing run as two separate passes over the sample's
+	* points: all rays are carved first, then every endpoint is incremented.
+	* A single interleaved pass would be order-dependent — a deeper point's
+	* carve could erase the endpoint a nearer point added earlier in the same
+	* sample. Splitting the passes makes the result deterministic and lets an
+	* endpoint observed within a sample survive other rays in that same
+	* sample. (Deeper-carves-nearer still applies ACROSS samples: a later
+	* sample's ray carves an earlier sample's endpoint as before.)
+	*
+	* @returns the number of points actually added.
+	*/
+	addSample(sample) {
+		if (!isFiniteTriple(sample.cameraPos)) return 0;
+		const unprojector = createDepthUnprojector(sample.cameraPos, sample.cameraRot, sample.projectionMatrix);
+		if (!unprojector) return 0;
+		const cameraCell = this.cellForPosition(sample.cameraPos);
+		const endpoints = [];
+		for (const point of sample.points) {
+			const world = unprojector.unproject(point);
+			if (!world) continue;
+			const cell = this.cellForPosition(world);
+			if (!cellsEqual(cameraCell, cell)) this.carve(cameraCell, cell);
+			endpoints.push({
+				cell,
+				rgb: point.rgb
+			});
+		}
+		for (const endpoint of endpoints) this.increment(endpoint.cell, endpoint.rgb);
+		return endpoints.length;
+	}
+	/** Occupied cells observed at least `minObservations` times (default 1). */
+	getOccupiedCells(minObservations = 1) {
+		const result = [];
+		for (const record of this.cells.values()) if (record.count >= minObservations) result.push(record.cell);
+		return result;
+	}
+	/** Quantize a raw-WebXR position to its grid cell (round per axis). */
+	cellForPosition(pos) {
+		return [
+			Math.round(pos[0] / this.cellSizeM) + 0,
+			Math.round(pos[1] / this.cellSizeM) + 0,
+			Math.round(pos[2] / this.cellSizeM) + 0
+		];
+	}
+	/** Center of a cell in raw WebXR space (round-consistent: cell · cellSizeM). */
+	getCellCenter(cell) {
+		return [
+			cell[0] * this.cellSizeM,
+			cell[1] * this.cellSizeM,
+			cell[2] * this.cellSizeM
+		];
+	}
+	/**
+	* Running-average color of the cell's colored observations (Iter 8), or
+	* null when the cell is unknown or was only ever observed without color
+	* (rgb option off / pre-Iter-8 recordings) — consumers fall back to
+	* height-based coloring. Channels are rounded and clamped to 0–255.
+	*/
+	getCellColor(cell) {
+		const record = this.cells.get(cellKey(cell));
+		if (!record || record.colorCount === 0) return null;
+		const average = (sum) => Math.min(255, Math.max(0, Math.round(sum / record.colorCount)));
+		return [
+			average(record.colorSum[0]),
+			average(record.colorSum[1]),
+			average(record.colorSum[2])
+		];
+	}
+	/**
+	* Walk the grid from `startPos` to `endPos` and return the center of the
+	* first cell occupied at least `minObservations` times, or null.
+	* Port of Unity's `TryRaycast` (hook for cursor/floor-detection parity).
+	*/
+	raycast(startPos, endPos, minObservations = 1) {
+		if (!isFiniteTriple(startPos) || !isFiniteTriple(endPos)) return null;
+		let hit = null;
+		bresenham3d(this.cellForPosition(startPos), this.cellForPosition(endPos), (cell) => {
+			const record = this.cells.get(cellKey(cell));
+			if (record && record.count >= minObservations) {
+				hit = cell;
+				return false;
+			}
+			return true;
+		});
+		return hit ? this.getCellCenter(hit) : null;
+	}
+	/** Remove all occupied cells (e.g. on store swap / new session). */
+	clear() {
+		this.cells.clear();
+	}
+	/**
+	* Delete occupied cells along the camera→point ray (the space was seen
+	* through, so it must be free), stopping `carveStopCells` dominant-axis
+	* steps before the endpoint. The endpoint cell itself is additionally
+	* protected so a current observation is never erased (relevant for
+	* carveStopCells = 0 and for the unconditional start-cell visit).
+	*/
+	carve(cameraCell, pointCell) {
+		bresenham3d(cameraCell, pointCell, (cell) => {
+			if (!cellsEqual(cell, pointCell)) this.cells.delete(cellKey(cell));
+			return true;
+		}, this.carveStopCells);
+	}
+	increment(cell, rgb) {
+		const key = cellKey(cell);
+		let record = this.cells.get(key);
+		if (!record) {
+			record = {
+				cell,
+				count: 0,
+				colorCount: 0,
+				colorSum: [
+					0,
+					0,
+					0
+				]
+			};
+			this.cells.set(key, record);
+		}
+		record.count++;
+		if (rgb && isFiniteTriple(rgb)) {
+			record.colorCount++;
+			record.colorSum[0] += rgb[0];
+			record.colorSum[1] += rgb[1];
+			record.colorSum[2] += rgb[2];
+		}
+	}
+};
+function cellKey(cell) {
+	return `${cell[0]},${cell[1]},${cell[2]}`;
+}
+function cellsEqual(a, b) {
+	return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+}
+function isFiniteTriple(v) {
+	return Number.isFinite(v[0]) && Number.isFinite(v[1]) && Number.isFinite(v[2]);
+}
+//#endregion
+export { OccupancyGrid };

package/dist/ar/replay-scene.d.ts

@@ -1,2 +1,2 @@
-import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-DkNfldPh.js";
+import { a as getCameraFollower, c as getReplayState, d as updateOrbitTarget, i as getAlignmentLerper, l as initReplayScene, n as ReplaySceneState, o as getCameraMode, r as disposeReplayScene, s as getCss3dManager, t as CameraMode, u as toggleCameraMode } from "../replay-scene-Bw58VL6p.js";
 export { CameraMode, ReplaySceneState, disposeReplayScene, getAlignmentLerper, getCameraFollower, getCameraMode, getCss3dManager, getReplayState, initReplayScene, toggleCameraMode, updateOrbitTarget };

package/dist/ar/replay-scene.js

@@ -1,6 +1,6 @@
 import { createLogger } from "../utils/logger.js";
+import { C as setArWorldGroup, O as setScene, S as setArPose, r as createSceneHierarchy, w as setCamera } from "../webxr-session-QhcSSub5.js";
 import { createCss3dRendererManager } from "../visualization/css3d-renderer-manager.js";
-import { createSceneHierarchy, setArPose, setArWorldGroup, setCamera, setScene } from "./webxr-session.js";
 import { createCameraFollower } from "../visualization/camera-follower.js";
 import { createAlignmentLerper } from "../visualization/alignment-lerper.js";
 import { createGpsCompassCubes } from "../visualization/gps-compass-cubes.js";

package/dist/ar/scene-node-names.d.ts

@@ -1,2 +1,2 @@
-import { t as SCENE_NODE } from "../scene-node-names-IHW7HR4S.js";
+import { t as SCENE_NODE } from "../scene-node-names-Bu0S66H1.js";
 export { SCENE_NODE };

package/dist/ar/webxr-nue-basis.d.ts

@@ -0,0 +1,2 @@
+import { t as WEBXR_TO_NUE } from "../webxr-nue-basis-CqKQmZzT.js";
+export { WEBXR_TO_NUE };

package/dist/{webxr-nue-basis-BbdqhqY6.js → ar/webxr-nue-basis.js}

@@ -51,4 +51,4 @@ const WEBXR_TO_NUE = /* @__PURE__ */ new Matrix4().fromArray([
 	1
 ]);
 //#endregion
-export { WEBXR_TO_NUE as t };
+export { WEBXR_TO_NUE };

package/dist/ar/webxr-session.d.ts

@@ -1,4 +1,4 @@
-import { i as DepthSample, t as ARPose } from "../ar-types-isPsQptb.js";
-import { t as CapturedImage } from "../image-capture-BXZUmj7j.js";
-import { A as setScene, C as resetWebXRState, D as setDepthCaptureCallback, E as setCamera, F as shouldLogCameraAccessDiagnostic, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, N as setTrackingRecoveredCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, S as nueQuaternionToWebXR, T as setArWorldGroup, _ as getXrCameraFromPose, a as createSceneHierarchy, b as isXRCameraLike, c as extractResetTransformData, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, i as buildSessionOptions, j as setTrackingCallbacks, k as setImageCaptureCallback, l as getArPose, m as getImageCaptureFrameCount, n as TrackingSubscribableStore, o as endARSession, p as getDepthSampleCount, r as applyAlignmentMatrix, s as extractPoseFromViewer, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, w as setArPose, x as nuePositionToWebXR, y as isWebXRSupported, z as stopImageCapture } from "../webxr-session-BnArFCew.js";
+import { i as DepthSample, t as ARPose } from "../ar-types-Dan1MVTi.js";
+import { t as CapturedImage } from "../image-capture-DZ4HFRgS.js";
+import { A as setScene, C as resetWebXRState, D as setDepthCaptureCallback, E as setCamera, F as shouldLogCameraAccessDiagnostic, I as startDepthCapture, L as startImageCapture, M as setTrackingLostCallback, N as setTrackingRecoveredCallback, O as setFrameCallback, P as setTrackingStore, R as stopDepthCapture, S as nueQuaternionToWebXR, T as setArWorldGroup, _ as getXrCameraFromPose, a as createSceneHierarchy, b as isXRCameraLike, c as extractResetTransformData, d as getCamera, f as getCurrentArPose, g as getScene, h as getLiveCss3dManager, i as buildSessionOptions, j as setTrackingCallbacks, k as setImageCaptureCallback, l as getArPose, m as getImageCaptureFrameCount, n as TrackingSubscribableStore, o as endARSession, p as getDepthSampleCount, r as applyAlignmentMatrix, s as extractPoseFromViewer, t as SessionFeatureOptions, u as getArWorldGroup, v as initAR, w as setArPose, x as nuePositionToWebXR, y as isWebXRSupported, z as stopImageCapture } from "../webxr-session-DtAG9srK.js";
 export { ARPose, CapturedImage, DepthSample, SessionFeatureOptions, TrackingSubscribableStore, applyAlignmentMatrix, buildSessionOptions, createSceneHierarchy, endARSession, extractPoseFromViewer, extractResetTransformData, getArPose, getArWorldGroup, getCamera, getCurrentArPose, getDepthSampleCount, getImageCaptureFrameCount, getLiveCss3dManager, getScene, getXrCameraFromPose, initAR, isWebXRSupported, isXRCameraLike, nuePositionToWebXR, nueQuaternionToWebXR, resetWebXRState, setArPose, setArWorldGroup, setCamera, setDepthCaptureCallback, setFrameCallback, setImageCaptureCallback, setScene, setTrackingCallbacks, setTrackingLostCallback, setTrackingRecoveredCallback, setTrackingStore, shouldLogCameraAccessDiagnostic, startDepthCapture, startImageCapture, stopDepthCapture, stopImageCapture };