gps-plus-slam-app-framework 1.0.0

package/dist/visualization/gps-event-markers.js

@@ -0,0 +1,159 @@
+import { createLogger } from "../utils/logger.js";
+import { disposeMeshArray } from "./three-dispose.js";
+import { getArWorldGroup, getScene } from "../ar/webxr-session.js";
+import { VIS_COLORS } from "./vis-colors.js";
+import * as THREE from "three";
+//#region ../src/visualization/gps-event-markers.ts
+/**
+* GPS Event Markers Visualizer
+*
+* Creates and manages Three.js meshes for visualizing GPS events
+* in the 3D AR scene. Shows two types of markers:
+* - Raw GPS markers (yellow): Where GPS readings were received — added to scene root
+* - Fused markers (cyan): AR odometry positions — added to arWorldGroup so that
+*   scene-graph propagation (arWorldGroup.matrix × odomPos) handles alignment
+*
+* ARCHITECTURE NOTE:
+* - Raw GPS markers are in scene root (GPS world space), fixed forever
+* - Fused markers are children of arWorldGroup with position = raw odom coords;
+*   when applyAlignmentMatrix() updates arWorldGroup.matrix, all fused markers'
+*   world positions update automatically via Three.js scene-graph propagation.
+*/
+const log = createLogger("GpsEventVisualizer");
+/** Sphere radius in meters (8cm - smaller than reference point markers) */
+const GPS_MARKER_RADIUS = .08;
+/** Slightly larger radius for alignment snapshots to stand out */
+const SNAPSHOT_MARKER_RADIUS = .1;
+/**
+* Manager for GPS event visualization
+*/
+var GpsEventVisualizer = class {
+	rawGpsMarkers = [];
+	fusedMarkers = [];
+	snapshotMarkers = [];
+	zeroRef = null;
+	eventCounter = 0;
+	snapshotCounter = 0;
+	/**
+	* Set the GPS zero reference (origin for coordinate conversion).
+	* Must be called before adding GPS events.
+	*
+	* @param zero - GPS coordinates of the origin
+	*/
+	setZeroRef(zero) {
+		this.zeroRef = zero;
+	}
+	/**
+	* Get the current zero reference
+	*/
+	getZeroRef() {
+		return this.zeroRef;
+	}
+	/**
+	* Add a GPS event to the visualization.
+	* Creates both a raw GPS marker and a fused alignment marker.
+	*
+	* @param gpsCoords - GPS position as [x, y, z] meters from zero reference
+	* @param odomPosition - AR odometry position at the time of GPS reading
+	*/
+	addGpsEvent(gpsCoords, odomPosition) {
+		if (!this.zeroRef) {
+			log.warn("No zero reference set");
+			return;
+		}
+		const scene = getScene();
+		if (!scene) {
+			log.warn("Scene not available");
+			return;
+		}
+		const eventId = this.eventCounter++;
+		const rawMesh = this.createMarkerMesh(VIS_COLORS.RAW_GPS.hex, "raw-gps", eventId);
+		rawMesh.position.set(gpsCoords[0], gpsCoords[1], gpsCoords[2]);
+		scene.add(rawMesh);
+		this.rawGpsMarkers.push(rawMesh);
+		const arWorldGroup = getArWorldGroup();
+		if (!arWorldGroup) {
+			log.warn("arWorldGroup not available, skipping fused marker");
+			return;
+		}
+		const fusedMesh = this.createMarkerMesh(VIS_COLORS.FUSED_VIO.hex, "fused", eventId);
+		fusedMesh.position.set(odomPosition[0], odomPosition[1], odomPosition[2]);
+		arWorldGroup.add(fusedMesh);
+		this.fusedMarkers.push(fusedMesh);
+		log.debug(`Added GPS event ${eventId}: raw=[${gpsCoords.join(",")}] odom=[${odomPosition.join(",")}]`);
+	}
+	/**
+	* Add an alignment snapshot marker at the given NUE position.
+	* Snapshots represent the system's best GPS estimate at each alignment update.
+	* Added to scene root (GPS world space), not arWorldGroup.
+	*/
+	addAlignmentSnapshot(nuePosition) {
+		const scene = getScene();
+		if (!scene) {
+			log.warn("Scene not available for alignment snapshot");
+			return;
+		}
+		const id = this.snapshotCounter++;
+		const mesh = this.createMarkerMesh(VIS_COLORS.ALIGNMENT_SNAPSHOT.hex, "alignment-snapshot", id, SNAPSHOT_MARKER_RADIUS, .5);
+		mesh.position.set(nuePosition[0], nuePosition[1], nuePosition[2]);
+		scene.add(mesh);
+		this.snapshotMarkers.push(mesh);
+		log.debug(`Added alignment snapshot ${id}: pos=[${nuePosition.join(",")}]`);
+	}
+	/**
+	* Get the NUE positions of all alignment snapshot markers.
+	* Used at session end to convert to GPS coordinates for the summary map.
+	*/
+	getAlignmentSnapshotPositions() {
+		return this.snapshotMarkers.map((m) => [
+			m.position.x,
+			m.position.y,
+			m.position.z
+		]);
+	}
+	/**
+	* Create a sphere marker mesh with the given color and name.
+	*/
+	createMarkerMesh(color, namePrefix, eventId, radius = GPS_MARKER_RADIUS, opacity = .3) {
+		const geometry = new THREE.SphereGeometry(radius, 12, 12);
+		const material = new THREE.MeshBasicMaterial({
+			color,
+			transparent: true,
+			opacity,
+			depthWrite: false
+		});
+		const mesh = new THREE.Mesh(geometry, material);
+		mesh.name = `${namePrefix}-${eventId}`;
+		return mesh;
+	}
+	/**
+	* Clear all markers from the scene and reset state.
+	*/
+	clearAll() {
+		const scene = getScene();
+		const arWorldGroup = getArWorldGroup();
+		disposeMeshArray(this.rawGpsMarkers, scene);
+		disposeMeshArray(this.fusedMarkers, arWorldGroup);
+		disposeMeshArray(this.snapshotMarkers, scene);
+		this.zeroRef = null;
+		this.eventCounter = 0;
+		this.snapshotCounter = 0;
+	}
+	/**
+	* Get count of visible markers.
+	*/
+	getCounts() {
+		return {
+			raw: this.rawGpsMarkers.length,
+			fused: this.fusedMarkers.length,
+			snapshots: this.snapshotMarkers.length
+		};
+	}
+};
+/**
+* Singleton instance for global use.
+* Import this to visualize GPS events.
+*/
+const gpsEventVisualizer = new GpsEventVisualizer();
+//#endregion
+export { GpsEventVisualizer, gpsEventVisualizer };

package/dist/visualization/index.d.ts

@@ -0,0 +1,12 @@
+import { n as createCameraFollower, t as CameraFollower } from "../camera-follower-BMqPddxx.js";
+import { n as createAlignmentLerper, t as AlignmentLerper } from "../alignment-lerper-D9BeDwZX.js";
+import { n as createCss3dRendererManager, t as Css3dRendererManager } from "../css3d-renderer-manager-rgLMVAvd.js";
+import { i as createGpsCompassCubes, n as COMPASS_CUBE_SIZE, r as GpsCompassCubes, t as COMPASS_CUBE_DISTANCE } from "../gps-compass-cubes-C-6JEnpR.js";
+import { n as gpsEventVisualizer, t as GpsEventVisualizer } from "../gps-event-markers-DpEy2qRd.js";
+import { a as DEFAULT_Z_OFFSET, n as DEFAULT_LEAFLET_MAP_SIZE_PX, o as LeafletMapOverlay, r as DEFAULT_WORLD_SIZE, s as LeafletMapOverlayOptions } from "../leaflet-map-overlay-CvfQXTye.js";
+import { n as clampedAlpha, t as DEFAULT_LERP_RATE } from "../lerp-utils-87NWjUOD.js";
+import { a as MapOverlayOptions, c as tileXYToLatLon, i as MapOverlay, n as DEFAULT_MAP_SIZE, o as TextureLoaderInterface, r as DEFAULT_ZOOM, s as latLonToTileXY, t as DEFAULT_HEIGHT_OFFSET } from "../map-overlay-DuiZuCTx.js";
+import { n as refPointVisualizer, t as RefPointVisualizer } from "../reference-points-CFWy8_wj.js";
+import { n as disposeMeshArray, r as disposeObject3D, t as DisposeOptions } from "../three-dispose-CCBHjE_a.js";
+import { t as VIS_COLORS } from "../vis-colors-Qi2vlRGt.js";
+export { type AlignmentLerper, COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, type CameraFollower, type Css3dRendererManager, DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_LERP_RATE, DEFAULT_MAP_SIZE, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, type DisposeOptions, type GpsCompassCubes, GpsEventVisualizer, LeafletMapOverlay, type LeafletMapOverlayOptions, MapOverlay, type MapOverlayOptions, RefPointVisualizer, type TextureLoaderInterface, VIS_COLORS, clampedAlpha, createAlignmentLerper, createCameraFollower, createCss3dRendererManager, createGpsCompassCubes, disposeMeshArray, disposeObject3D, gpsEventVisualizer, latLonToTileXY, refPointVisualizer, tileXYToLatLon };

package/dist/visualization/index.js

@@ -0,0 +1,12 @@
+import { disposeMeshArray, disposeObject3D } from "./three-dispose.js";
+import { createCss3dRendererManager } from "./css3d-renderer-manager.js";
+import { DEFAULT_LERP_RATE, clampedAlpha } from "./lerp-utils.js";
+import { createCameraFollower } from "./camera-follower.js";
+import { createAlignmentLerper } from "./alignment-lerper.js";
+import { VIS_COLORS } from "./vis-colors.js";
+import { COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, createGpsCompassCubes } from "./gps-compass-cubes.js";
+import { GpsEventVisualizer, gpsEventVisualizer } from "./gps-event-markers.js";
+import { DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_WORLD_SIZE, DEFAULT_Z_OFFSET, LeafletMapOverlay } from "./leaflet-map-overlay.js";
+import { DEFAULT_HEIGHT_OFFSET, DEFAULT_MAP_SIZE, DEFAULT_ZOOM, MapOverlay, latLonToTileXY, tileXYToLatLon } from "./map-overlay.js";
+import { RefPointVisualizer, refPointVisualizer } from "./reference-points.js";
+export { COMPASS_CUBE_DISTANCE, COMPASS_CUBE_SIZE, DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_LERP_RATE, DEFAULT_MAP_SIZE, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, GpsEventVisualizer, LeafletMapOverlay, MapOverlay, RefPointVisualizer, VIS_COLORS, clampedAlpha, createAlignmentLerper, createCameraFollower, createCss3dRendererManager, createGpsCompassCubes, disposeMeshArray, disposeObject3D, gpsEventVisualizer, latLonToTileXY, refPointVisualizer, tileXYToLatLon };

package/dist/visualization/leaflet-map-overlay.d.ts

@@ -0,0 +1,2 @@
+import { a as DEFAULT_Z_OFFSET, i as DEFAULT_ZOOM, n as DEFAULT_LEAFLET_MAP_SIZE_PX, o as LeafletMapOverlay, r as DEFAULT_WORLD_SIZE, s as LeafletMapOverlayOptions, t as DEFAULT_HEIGHT_OFFSET } from "../leaflet-map-overlay-CvfQXTye.js";
+export { DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, LeafletMapOverlay, LeafletMapOverlayOptions };

package/dist/visualization/leaflet-map-overlay.js

@@ -0,0 +1,313 @@
+import { createLogger } from "../utils/logger.js";
+import { VIS_COLORS } from "./vis-colors.js";
+import { CSS3DObject } from "three/addons/renderers/CSS3DRenderer.js";
+import L from "leaflet";
+//#region ../src/visualization/leaflet-map-overlay.ts
+const log = createLogger("LeafletMapOverlay");
+/** Default pixel size of the Leaflet map container */
+const DEFAULT_LEAFLET_MAP_SIZE_PX = 600;
+/** Default world-space size in meters (matches old MapOverlay) */
+const DEFAULT_WORLD_SIZE = 10;
+/** Default height offset below camera (negative = below) */
+const DEFAULT_HEIGHT_OFFSET = -4;
+/** Default forward offset from parent (negative = forward in parent-local Z) */
+const DEFAULT_Z_OFFSET = -1;
+/** Default zoom level for the Leaflet map */
+const DEFAULT_ZOOM = 17;
+/** Minimum allowed zoom level */
+const MIN_ZOOM = 0;
+/** Maximum allowed zoom level */
+const MAX_ZOOM = 19;
+var LeafletMapOverlay = class {
+	scene;
+	camera;
+	mapParent;
+	worldSize;
+	heightOffset;
+	mapSizePx;
+	tileServerUrl;
+	onTileError;
+	offscreenRoot;
+	zoomLevel;
+	gpsPosition = null;
+	visible = false;
+	mapContainer = null;
+	leafletMap = null;
+	tileLayer = null;
+	cssObject = null;
+	rawGpsPoints = [];
+	fusedPoints = [];
+	snapshotPoints = [];
+	refPoints = [];
+	userMarker = null;
+	rawGpsPolyline = null;
+	fusedPolyline = null;
+	snapshotPolyline = null;
+	constructor(scene, camera, options = {}) {
+		this.scene = scene;
+		this.camera = camera;
+		this.mapParent = options.mapParent ?? camera;
+		this.worldSize = options.worldSize ?? 10;
+		this.heightOffset = options.heightOffset ?? -4;
+		this.mapSizePx = options.mapSizePx ?? 600;
+		this.zoomLevel = options.zoomLevel ?? 17;
+		this.tileServerUrl = options.tileServerUrl ?? "https://tile.openstreetmap.org/{z}/{x}/{y}.png";
+		this.onTileError = options.onTileError;
+		this.offscreenRoot = options.offscreenRoot ?? document.body;
+	}
+	setGpsPosition(lat, lon) {
+		this.gpsPosition = {
+			lat,
+			lon
+		};
+		if (this.leafletMap) {
+			this.leafletMap.setView([lat, lon], this.zoomLevel);
+			this.updateUserMarker();
+		}
+	}
+	getGpsPosition() {
+		return this.gpsPosition;
+	}
+	show() {
+		if (!this.gpsPosition) {
+			log.warn("Cannot show map — no GPS position set");
+			return;
+		}
+		if (this.visible) return;
+		this.createLeafletMap();
+		this.createCssObject();
+		this.applyBufferedOverlays();
+		this.visible = true;
+		log.info("Leaflet map overlay shown");
+	}
+	hide() {
+		if (!this.visible) return;
+		this.removeCssObject();
+		this.visible = false;
+		log.info("Leaflet map overlay hidden");
+	}
+	toggle() {
+		if (this.visible) this.hide();
+		else this.show();
+	}
+	isVisible() {
+		return this.visible;
+	}
+	addRawGpsPoint(lat, lon) {
+		this.rawGpsPoints.push([lat, lon]);
+		if (this.leafletMap) {
+			if (!this.rawGpsPolyline) this.rawGpsPolyline = L.polyline([], {
+				color: VIS_COLORS.RAW_GPS.css,
+				weight: 3,
+				opacity: .8
+			}).addTo(this.leafletMap);
+			this.rawGpsPolyline.addLatLng([lat, lon]);
+		}
+	}
+	addFusedPoint(lat, lon) {
+		this.fusedPoints.push([lat, lon]);
+		if (this.leafletMap) {
+			if (!this.fusedPolyline) this.fusedPolyline = L.polyline([], {
+				color: VIS_COLORS.FUSED_VIO.css,
+				weight: 3,
+				opacity: .8
+			}).addTo(this.leafletMap);
+			this.fusedPolyline.addLatLng([lat, lon]);
+		}
+	}
+	addAlignmentSnapshot(lat, lon) {
+		this.snapshotPoints.push([lat, lon]);
+		if (this.leafletMap) {
+			if (!this.snapshotPolyline) this.snapshotPolyline = L.polyline([], {
+				color: VIS_COLORS.ALIGNMENT_SNAPSHOT.css,
+				weight: 3,
+				opacity: .8
+			}).addTo(this.leafletMap);
+			this.snapshotPolyline.addLatLng([lat, lon]);
+		}
+	}
+	addRefPoint(lat, lon, name) {
+		const marker = this.leafletMap ? this.createRefPointMarker(lat, lon, name, false) : null;
+		this.refPoints.push({
+			lat,
+			lng: lon,
+			name,
+			isPrior: false,
+			marker
+		});
+	}
+	addPriorRefPoint(lat, lon, name) {
+		const marker = this.leafletMap ? this.createRefPointMarker(lat, lon, name, true) : null;
+		this.refPoints.push({
+			lat,
+			lng: lon,
+			name,
+			isPrior: true,
+			marker
+		});
+	}
+	addPriorRefPoints(refPoints) {
+		for (const rp of refPoints) this.addPriorRefPoint(rp.lat, rp.lon, rp.name);
+	}
+	clearPriorRefPoints() {
+		this.refPoints = this.refPoints.filter((rp) => {
+			if (rp.isPrior) {
+				rp.marker?.remove();
+				return false;
+			}
+			return true;
+		});
+	}
+	setZoomLevel(zoom) {
+		this.zoomLevel = Math.max(MIN_ZOOM, Math.min(MAX_ZOOM, zoom));
+		if (this.leafletMap) this.leafletMap.setZoom(this.zoomLevel);
+	}
+	getZoomLevel() {
+		return this.zoomLevel;
+	}
+	/** Increment zoom level by 1 (clamped at MAX_ZOOM). */
+	zoomIn() {
+		this.setZoomLevel(this.zoomLevel + 1);
+	}
+	/** Decrement zoom level by 1 (clamped at MIN_ZOOM). */
+	zoomOut() {
+		this.setZoomLevel(this.zoomLevel - 1);
+	}
+	getWorldSize() {
+		return this.worldSize;
+	}
+	getHeightOffset() {
+		return this.heightOffset;
+	}
+	getMapSizePx() {
+		return this.mapSizePx;
+	}
+	/** Expose the Leaflet map instance for testing and advanced usage. */
+	getLeafletMap() {
+		return this.leafletMap;
+	}
+	/**
+	* No-op — kept for backward compatibility with the frame-loop call
+	* in main.ts. The CSS3DObject is a child of the parent, so Three.js
+	* scene graph propagation handles positioning automatically.
+	*/
+	updatePosition() {}
+	dispose() {
+		this.hide();
+		this.destroyLeafletMap();
+		this.rawGpsPoints = [];
+		this.fusedPoints = [];
+		this.snapshotPoints = [];
+		this.refPoints = [];
+		this.cssObject = null;
+		log.info("Leaflet map overlay disposed");
+	}
+	createLeafletMap() {
+		if (this.leafletMap) return;
+		this.mapContainer = document.createElement("div");
+		this.mapContainer.style.width = `${this.mapSizePx}px`;
+		this.mapContainer.style.height = `${this.mapSizePx}px`;
+		this.mapContainer.style.background = "white";
+		this.mapContainer.style.position = "fixed";
+		this.mapContainer.style.left = "-9999px";
+		this.mapContainer.style.top = "-9999px";
+		this.mapContainer.style.pointerEvents = "none";
+		this.offscreenRoot.appendChild(this.mapContainer);
+		const pos = this.gpsPosition;
+		this.leafletMap = L.map(this.mapContainer, {
+			center: [pos.lat, pos.lon],
+			zoom: this.zoomLevel,
+			zoomControl: false,
+			attributionControl: false
+		});
+		this.tileLayer = L.tileLayer(this.tileServerUrl, { maxZoom: MAX_ZOOM });
+		this.tileLayer.on("tileerror", (e) => {
+			log.error("Failed to load map tile:", e.error);
+			this.onTileError?.(e.error);
+		});
+		this.tileLayer.addTo(this.leafletMap);
+	}
+	destroyLeafletMap() {
+		this.userMarker?.remove();
+		this.userMarker = null;
+		this.rawGpsPolyline?.remove();
+		this.rawGpsPolyline = null;
+		this.fusedPolyline?.remove();
+		this.fusedPolyline = null;
+		this.snapshotPolyline?.remove();
+		this.snapshotPolyline = null;
+		for (const rp of this.refPoints) {
+			rp.marker?.remove();
+			rp.marker = null;
+		}
+		if (this.leafletMap) {
+			this.leafletMap.remove();
+			this.leafletMap = null;
+		}
+		if (this.mapContainer?.parentElement) this.mapContainer.parentElement.removeChild(this.mapContainer);
+		this.mapContainer = null;
+		this.tileLayer = null;
+	}
+	createCssObject() {
+		if (!this.mapContainer) return;
+		if (this.cssObject) {
+			this.mapParent.add(this.cssObject);
+			return;
+		}
+		this.mapContainer.style.position = "";
+		this.mapContainer.style.left = "";
+		this.mapContainer.style.top = "";
+		this.cssObject = new CSS3DObject(this.mapContainer);
+		const scale = this.worldSize / this.mapSizePx;
+		this.cssObject.scale.set(scale, scale, scale);
+		this.cssObject.position.set(0, this.heightOffset, -1);
+		this.cssObject.rotation.x = -Math.PI / 2;
+		this.mapParent.add(this.cssObject);
+	}
+	removeCssObject() {
+		if (this.cssObject) this.mapParent.remove(this.cssObject);
+	}
+	applyBufferedOverlays() {
+		if (!this.leafletMap) return;
+		this.updateUserMarker();
+		if (this.rawGpsPoints.length > 0) this.rawGpsPolyline = L.polyline(this.rawGpsPoints, {
+			color: VIS_COLORS.RAW_GPS.css,
+			weight: 3,
+			opacity: .8
+		}).addTo(this.leafletMap);
+		if (this.fusedPoints.length > 0) this.fusedPolyline = L.polyline(this.fusedPoints, {
+			color: VIS_COLORS.FUSED_VIO.css,
+			weight: 3,
+			opacity: .8
+		}).addTo(this.leafletMap);
+		if (this.snapshotPoints.length > 0) this.snapshotPolyline = L.polyline(this.snapshotPoints, {
+			color: VIS_COLORS.ALIGNMENT_SNAPSHOT.css,
+			weight: 3,
+			opacity: .8
+		}).addTo(this.leafletMap);
+		for (const rp of this.refPoints) if (!rp.marker) rp.marker = this.createRefPointMarker(rp.lat, rp.lng, rp.name, rp.isPrior);
+	}
+	updateUserMarker() {
+		if (!this.gpsPosition || !this.leafletMap) return;
+		if (this.userMarker) this.userMarker.setLatLng([this.gpsPosition.lat, this.gpsPosition.lon]);
+		else this.userMarker = L.marker([this.gpsPosition.lat, this.gpsPosition.lon], { icon: L.divIcon({
+			className: "",
+			html: `<div style="background:${VIS_COLORS.USER_POSITION.css};width:14px;height:14px;border-radius:50%;border:3px solid white;box-shadow:0 0 6px rgba(59,130,246,0.6);"></div>`,
+			iconSize: [14, 14],
+			iconAnchor: [7, 7]
+		}) }).addTo(this.leafletMap);
+	}
+	createRefPointMarker(lat, lon, name, isPrior) {
+		const color = isPrior ? VIS_COLORS.PRIOR_REF_POINT.css : VIS_COLORS.CURRENT_REF_POINT.css;
+		const opacity = isPrior ? "opacity:0.8;" : "";
+		const label = isPrior ? `📌 ${name} (prior)` : name;
+		return L.marker([lat, lon], { icon: L.divIcon({
+			className: "",
+			html: `<div style="background:${color};width:12px;height:12px;border-radius:50%;border:2px solid white;${opacity}"></div>`,
+			iconSize: [12, 12],
+			iconAnchor: [6, 6]
+		}) }).bindPopup(label).addTo(this.leafletMap);
+	}
+};
+//#endregion
+export { DEFAULT_HEIGHT_OFFSET, DEFAULT_LEAFLET_MAP_SIZE_PX, DEFAULT_WORLD_SIZE, DEFAULT_ZOOM, DEFAULT_Z_OFFSET, LeafletMapOverlay };

package/dist/visualization/lerp-utils.d.ts

@@ -0,0 +1,2 @@
+import { n as clampedAlpha, t as DEFAULT_LERP_RATE } from "../lerp-utils-87NWjUOD.js";
+export { DEFAULT_LERP_RATE, clampedAlpha };

package/dist/visualization/lerp-utils.js

@@ -0,0 +1,22 @@
+//#region ../src/visualization/lerp-utils.ts
+/**
+* Shared lerp utilities for visualization modules.
+*
+* Both alignment-lerper and camera-follower need the same smoothing
+* rate constant and clamped-alpha formula. Centralised here (R3) to
+* keep the two modules in sync.
+*/
+/** Default speed multiplier — ~90 % convergence in ~0.3 s at 60 fps. */
+const DEFAULT_LERP_RATE = 8;
+/**
+* Compute a frame-rate-independent lerp/slerp factor clamped to [0, 1].
+*
+* @param lerpRate Speed multiplier (higher = faster convergence).
+* @param dt       Delta time in seconds since last frame.
+* @returns The interpolation alpha, guaranteed ≤ 1.0.
+*/
+function clampedAlpha(lerpRate, dt) {
+	return Math.min(lerpRate * dt, 1);
+}
+//#endregion
+export { DEFAULT_LERP_RATE, clampedAlpha };

package/dist/visualization/map-overlay.d.ts

@@ -0,0 +1,2 @@
+import { a as MapOverlayOptions, c as tileXYToLatLon, i as MapOverlay, n as DEFAULT_MAP_SIZE, o as TextureLoaderInterface, r as DEFAULT_ZOOM, s as latLonToTileXY, t as DEFAULT_HEIGHT_OFFSET } from "../map-overlay-DuiZuCTx.js";
+export { DEFAULT_HEIGHT_OFFSET, DEFAULT_MAP_SIZE, DEFAULT_ZOOM, MapOverlay, MapOverlayOptions, TextureLoaderInterface, latLonToTileXY, tileXYToLatLon };