bruce-cesium 7.7.6 → 7.7.8

package/dist/lib/utils/cesium-map-grid.js

@@ -0,0 +1,807 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CesiumMapGrid = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const viewer_utils_1 = require("../viewer/viewer-utils");
+const view_utils_1 = require("./view-utils");
+const gltf_gizmo_1 = require("./gltf-gizmo");
+// viewer[CLASS_INSTANCE_KEY] will point at an instance of MapGridHandler.
+const CLASS_INSTANCE_KEY = "nextspace-navigator-grid-handler";
+// viewer[UPDATE_MARKER_KEY] will point at a number that is incremented every time the grid is updated.
+// This is used to determine if the grid is still valid or if it needs to be redrawn.
+const UPDATE_MARKER_KEY = "nextspace-marker-grid";
+// viewer[LAST_SETTINGS_KEY] will point at the last settings used for the grid.
+const LAST_SETTINGS_KEY = "nextspace-navigator-last-settings-grid";
+/*
+ * The point a distance in metres along a heading in degrees from another, over a spherical earth.
+ */
+function offsetPoint(point, distance, heading) {
+    // Radius of earth.
+    const radius = 6371e3;
+    const δ = distance / radius;
+    const θ = Cesium.Math.toRadians(heading);
+    const φ1 = Cesium.Math.toRadians(point.latitude);
+    const λ1 = Cesium.Math.toRadians(point.longitude);
+    const sinφ2 = Math.sin(φ1) * Math.cos(δ) + Math.cos(φ1) * Math.sin(δ) * Math.cos(θ);
+    const φ2 = Math.asin(sinφ2);
+    const y = Math.sin(θ) * Math.sin(δ) * Math.cos(φ1);
+    const x = Math.cos(δ) - Math.sin(φ1) * sinφ2;
+    const λ2 = λ1 + Math.atan2(y, x);
+    return {
+        altitude: point.altitude,
+        latitude: Cesium.Math.toDegrees(φ2),
+        longitude: Cesium.Math.toDegrees(λ2)
+    };
+}
+/**
+ * Handler for drawing a grid of lines on the map with a specified spacing.
+ * Initially this grid is for model-space viewing which means we start at 0,0 lat/lon and have it expand from there.
+ * However, it should be a general-use tool for drawing a grid anywhere.
+ *
+ * It reacts to camera changes and draws the grid within view with padding.
+ * This helps avoid performance issues around drawing too many lines.
+ */
+class MapGridHandler {
+    constructor(viewer, spacingInMeters = 100, modelSpace = false) {
+        this.gridCenterGizmoPieces = [];
+        this.maxCacheSize = 1000;
+        // === Thresholds for grid stability.
+        // As a fraction of current grid extent.
+        this.CAMERA_MOVE_THRESHOLD = 0.5;
+        // 40% change in camera height triggers redraw.
+        this.HEIGHT_CHANGE_THRESHOLD = 0.4;
+        // 40% change in grid extent triggers redraw.
+        this.GRID_EXTENT_CHANGE_THRESHOLD = 0.4;
+        // 5km - distance that triggers origin reset.
+        this.EXTREME_DISTANCE_THRESHOLD = 5000;
+        // Grid limits to prevent drawing too many lines.
+        this.MAX_LINES = 500;
+        // 50% padding around visible area.
+        this.VIEW_PADDING_FACTOR = 0.5;
+        // Minimum pixels between grid lines to show them.
+        this.MIN_GRID_PIXEL_SIZE = 20;
+        // Base ratio - will be adjusted dynamically based on spacing size and camera height.
+        this.BASE_MAX_VISIBILITY_RATIO = 30;
+        // Height to spacing ratio.
+        this.HEIGHT_TO_SPACING_RATIO = 100;
+        // === Label settings
+        // Label every nth intersection.
+        this.LABEL_INTERVAL = 2;
+        // Maximum number of labels to show.
+        this.MAX_LABELS = 100;
+        // Spacing levels to use for adaptive spacing.
+        this.SPACING_LEVELS = [
+            1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 300, 400, 500, 1000, 2000, 2500, 5000, 10000, 20000, 25000, 50000, 100000
+        ];
+        // Minimum zoom distance to prevent precision issues.
+        this.MINIMUM_ZOOM_DISTANCE = 40;
+        // Base spacing to use for adaptive spacing.
+        this.BASE_SPACING = 1;
+        // Maximum number of attempts to find a suitable spacing.
+        this.MAX_ADAPTIVE_ATTEMPTS = 5;
+        this.viewer = viewer;
+        this.spacingInMeters = spacingInMeters;
+        this.isUpdating = false;
+        this.modelSpace = modelSpace;
+        this.lastCameraPosition = null;
+        this.fixedGridOrigin = null;
+        this.lastGridExtent = 0;
+        this.offsetCache = new Map();
+        this.gridPrimitives = new Cesium.PrimitiveCollection();
+        this.viewer.scene.primitives.add(this.gridPrimitives);
+        this.currentMarker = viewer[UPDATE_MARKER_KEY] || 1;
+        const isMac = typeof navigator !== "undefined" && (navigator.platform.toUpperCase().indexOf("MAC") !== -1 ||
+            navigator.userAgent.toUpperCase().indexOf("MAC") !== -1);
+        if (modelSpace && isMac) {
+            console.log("[MAC-FIX] Applying camera distance limits for Mac");
+            viewer.scene.screenSpaceCameraController.minimumZoomDistance = this.MINIMUM_ZOOM_DISTANCE;
+        }
+        const manager = viewer_utils_1.ViewerUtils.GetManager({
+            viewer: this.viewer,
+            createIfMissing: false
+        });
+        if (manager) {
+            this.cameraChangeRemoval = manager.Monitor.Updated().Subscribe(() => {
+                this.onCameraChanged();
+            });
+        }
+        // Initial grid draw.
+        this.onCameraChanged();
+    }
+    Update(spacingInMeters, modelSpace) {
+        this.currentMarker = this.viewer[UPDATE_MARKER_KEY] || 1;
+        let needsUpdate = false;
+        if (this.spacingInMeters !== spacingInMeters) {
+            this.spacingInMeters = spacingInMeters;
+            needsUpdate = true;
+        }
+        if (modelSpace !== undefined && this.modelSpace !== modelSpace) {
+            this.modelSpace = modelSpace;
+            needsUpdate = true;
+        }
+        if (needsUpdate) {
+            this.clearGrid();
+            // When spacing or model space changes, clear the cached origin to force recalculation
+            // This ensures grid alignment at the new spacing.
+            this.fixedGridOrigin = null;
+            this.offsetCache.clear();
+            this.onCameraChanged();
+        }
+    }
+    Dispose() {
+        this.clearGrid();
+        this.clearGizmoPieces();
+        if (this.cameraChangeRemoval) {
+            this.cameraChangeRemoval();
+            this.cameraChangeRemoval = null;
+        }
+        if (this.gridPrimitives) {
+            this.viewer.scene.primitives.remove(this.gridPrimitives);
+            this.gridPrimitives = null;
+        }
+        if (this.viewer) {
+            this.viewer = null;
+        }
+        this.offsetCache.clear();
+        this.fixedGridOrigin = null;
+    }
+    clearGrid() {
+        if (this.gridPrimitives) {
+            this.gridPrimitives.removeAll();
+            this.gridLines = null;
+            this.gridLabels = null;
+        }
+    }
+    calculateAdaptiveSpacing(cameraHeight, baseSpacing) {
+        // Define spacing levels that look good (powers of 2, 5, and 10)
+        const spacingLevels = this.SPACING_LEVELS;
+        // Ensure base spacing is at least 1m
+        const adjustedBaseSpacing = Math.max(this.BASE_SPACING, baseSpacing);
+        // For very close cameras, use much smaller spacing regardless of base
+        if (cameraHeight < 10) {
+            // Find the smallest reasonable spacing for this height
+            // Rule: spacing should be roughly 1/20th to 1/50th of camera height, but at least 1m
+            const targetSpacing = Math.max(this.BASE_SPACING, cameraHeight / 30);
+            // Find the closest spacing level to our target
+            let bestSpacing = this.BASE_SPACING; // Start with minimum
+            let bestDifference = Math.abs(1 - targetSpacing);
+            for (const spacing of spacingLevels) {
+                if (spacing >= this.BASE_SPACING) { // Only consider valid spacings
+                    const difference = Math.abs(spacing - targetSpacing);
+                    if (difference < bestDifference) {
+                        bestSpacing = spacing;
+                        bestDifference = difference;
+                    }
+                }
+            }
+            return bestSpacing;
+        }
+        // For medium distances (10m - 200m), scale more gradually
+        if (cameraHeight < 200) {
+            const targetSpacing = cameraHeight / 10; // More conservative scaling// Find closest spacing level, but prefer going up from base spacing
+            let bestSpacing = adjustedBaseSpacing;
+            let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+            for (const spacing of spacingLevels) {
+                if (spacing >= Math.min(adjustedBaseSpacing, targetSpacing)) {
+                    const difference = Math.abs(spacing - targetSpacing);
+                    if (difference < bestDifference) {
+                        bestSpacing = spacing;
+                        bestDifference = difference;
+                    }
+                }
+            }
+            return bestSpacing;
+        }
+        // For far distances (100m+), scale up aggressively
+        const targetSpacing = cameraHeight / 20;
+        // Find the spacing level that's closest to target but not smaller than base
+        let bestSpacing = adjustedBaseSpacing;
+        let bestDifference = Math.abs(adjustedBaseSpacing - targetSpacing);
+        for (const spacing of spacingLevels) {
+            if (spacing >= adjustedBaseSpacing) {
+                const difference = Math.abs(spacing - targetSpacing);
+                if (difference < bestDifference) {
+                    bestSpacing = spacing;
+                    bestDifference = difference;
+                }
+            }
+        }
+        return bestSpacing;
+    }
+    /*
+     * The point model-space treats as 0,0,0: the UCS in UCS placement, otherwise 0,0 lat/lon at sea level.
+     */
+    modelSpaceOrigin() {
+        const origin = view_utils_1.ViewUtils.IsModelSpaceUcs(this.viewer) ? view_utils_1.ViewUtils.GetModelSpaceOrigin(this.viewer) : null;
+        return origin !== null && origin !== void 0 ? origin : { latitude: 0, longitude: 0, altitude: 0 };
+    }
+    /*
+     * The origin as a scene position, where the axis gizmo sits.
+     */
+    modelSpaceOriginPos3d() {
+        const origin = this.modelSpaceOrigin();
+        return Cesium.Cartesian3.fromDegrees(origin.longitude, origin.latitude, origin.altitude);
+    }
+    drawGizmoPieces() {
+        if (this.gridCenterGizmoPieces.length) {
+            return;
+        }
+        // X.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Cesium.Entity({
+                model: {
+                    uri: gltf_gizmo_1.GltfGizmo.GetUri(gltf_gizmo_1.GltfGizmo.EPiece.X),
+                    heightReference: Cesium.HeightReference.NONE,
+                    shadows: Cesium.ShadowMode.DISABLED,
+                    distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new Cesium.ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+        // Y.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Cesium.Entity({
+                model: {
+                    uri: gltf_gizmo_1.GltfGizmo.GetUri(gltf_gizmo_1.GltfGizmo.EPiece.Y),
+                    heightReference: Cesium.HeightReference.NONE,
+                    shadows: Cesium.ShadowMode.DISABLED,
+                    distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new Cesium.ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+        // Z.
+        {
+            const pos3d = this.modelSpaceOriginPos3d();
+            const scale = new Cesium.CallbackProperty(() => Cesium.Cartesian3.distance(this.viewer.camera.position, pos3d) * 0.0002, false);
+            const orientation = Cesium.Transforms.headingPitchRollQuaternion(pos3d, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(90), 0, 0));
+            const entity = this.viewer.entities.add(new Cesium.Entity({
+                model: {
+                    uri: gltf_gizmo_1.GltfGizmo.GetUri(gltf_gizmo_1.GltfGizmo.EPiece.Z),
+                    heightReference: Cesium.HeightReference.NONE,
+                    shadows: Cesium.ShadowMode.DISABLED,
+                    distanceDisplayCondition: new Cesium.DistanceDisplayCondition(0, Number.MAX_VALUE),
+                    scale
+                },
+                position: pos3d,
+                orientation: new Cesium.ConstantProperty(orientation)
+            }));
+            this.gridCenterGizmoPieces.push(entity);
+        }
+    }
+    clearGizmoPieces() {
+        for (const piece of this.gridCenterGizmoPieces) {
+            if (piece && this.viewer.entities.contains(piece)) {
+                this.viewer.entities.remove(piece);
+            }
+        }
+        this.gridCenterGizmoPieces = [];
+    }
+    onCameraChanged() {
+        if (this.isUpdating) {
+            return;
+        }
+        else if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+            return;
+        }
+        this.isUpdating = true;
+        // Small delay to avoid excessive updates during camera movement.
+        setTimeout(() => {
+            if (this.currentMarker !== this.viewer[UPDATE_MARKER_KEY]) {
+                this.isUpdating = false;
+                return;
+            }
+            try {
+                // The grid goes first, since it notices when the origin has moved and the gizmo has to follow.
+                this.updateGrid();
+                if (this.modelSpace) {
+                    this.drawGizmoPieces();
+                }
+                else {
+                    this.clearGizmoPieces();
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                this.isUpdating = false;
+            }
+        }, 100);
+    }
+    cachedOffsetPoint(point, distance, heading) {
+        const key = `${point.latitude.toFixed(8)},${point.longitude.toFixed(8)},${distance.toFixed(1)},${heading}`;
+        if (this.offsetCache.has(key)) {
+            return this.offsetCache.get(key);
+        }
+        const result = offsetPoint(point, distance, heading);
+        this.offsetCache.set(key, result);
+        if (this.offsetCache.size > this.maxCacheSize) {
+            const keys = Array.from(this.offsetCache.keys());
+            for (let i = 0; i < 100; i++) {
+                this.offsetCache.delete(keys[i]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Calculates a dynamic visibility ratio based on spacing size.
+     * For small grid spacings, we can show the grid from farther away.
+     * For large grid spacings, we need to hide it sooner to prevent performance issues.
+     */
+    getMaxVisibilityRatio() {
+        if (this.spacingInMeters <= 10) {
+            return this.BASE_MAX_VISIBILITY_RATIO;
+        }
+        if (this.spacingInMeters <= 100) {
+            const factor = 1 - ((this.spacingInMeters - 10) / 90);
+            return this.BASE_MAX_VISIBILITY_RATIO * (0.5 + (factor * 0.5));
+        }
+        const largeGridFactor = Math.min(1, 100 / this.spacingInMeters);
+        return this.BASE_MAX_VISIBILITY_RATIO * 0.5 * largeGridFactor;
+    }
+    updateGrid() {
+        const cameraPosition = this.viewer.camera.position;
+        const cameraCartographic = Cesium.Cartographic.fromCartesian(cameraPosition);
+        const cameraHeight = cameraCartographic.height;
+        let adaptiveSpacing = this.calculateAdaptiveSpacing(cameraHeight, this.spacingInMeters);
+        // Calculate visible area.
+        const visibleArea = this.calculateVisibleArea();
+        if (!visibleArea) {
+            return;
+        }
+        let densityCheckPassed = false;
+        let attempts = 0;
+        while (!densityCheckPassed && attempts < this.MAX_ADAPTIVE_ATTEMPTS) {
+            if (this.isGridDensityAcceptable(visibleArea, cameraHeight, adaptiveSpacing)) {
+                densityCheckPassed = true;
+            }
+            else {
+                adaptiveSpacing *= 2;
+                attempts++;
+            }
+        }
+        // The origin follows the UCS of what is shown, so the grid moves with it when that changes.
+        if (this.modelSpace && this.fixedGridOrigin && !bruce_models_1.Carto.IsEqual(this.fixedGridOrigin, this.modelSpaceOrigin())) {
+            this.fixedGridOrigin = null;
+            this.lastCameraPosition = null;
+            this.clearGizmoPieces();
+        }
+        // Calculate grid origin if we don't have one yet.
+        if (!this.fixedGridOrigin) {
+            if (this.modelSpace) {
+                this.fixedGridOrigin = this.modelSpaceOrigin();
+            }
+            else {
+                const centerCartographic = Cesium.Cartographic.fromCartesian(visibleArea.centerCartesian);
+                const centerPoint = {
+                    latitude: Cesium.Math.toDegrees(centerCartographic.latitude),
+                    longitude: Cesium.Math.toDegrees(centerCartographic.longitude),
+                    altitude: 0
+                };
+                // Simple attempt at snapping to the grid, should do something smarter.
+                this.fixedGridOrigin = {
+                    latitude: Math.round(centerPoint.latitude * 100000) / 100000,
+                    longitude: Math.round(centerPoint.longitude * 100000) / 100000,
+                    altitude: 0
+                };
+            }
+        }
+        // Calculate appropriate grid extent based on camera height.
+        // For larger grid spacings, we use a tighter extent to prevent performance issues.
+        const scaledExtentFactor = Math.max(0.5, Math.min(3, 3 - Math.log10(Math.max(1, adaptiveSpacing)) * 0.5));
+        const visibilityRadius = Math.min(cameraHeight * scaledExtentFactor, Infinity);
+        // Check if we should redraw the grid.
+        const shouldRedraw = this.shouldRedrawGrid(cameraPosition, cameraHeight, visibilityRadius, adaptiveSpacing);
+        if (!shouldRedraw) {
+            return;
+        }
+        // Remember current settings for next comparison.
+        this.lastCameraHeight = cameraHeight;
+        this.lastCameraPosition = cameraPosition.clone();
+        this.lastGridExtent = visibilityRadius;
+        // Clear existing grid and create a new one.
+        this.clearGrid();
+        this.gridLines = new Cesium.PolylineCollection();
+        this.gridLabels = new Cesium.LabelCollection({
+            scene: this.viewer.scene
+        });
+        this.gridPrimitives.add(this.gridLines);
+        this.gridPrimitives.add(this.gridLabels);
+        // Generate grid lines and labels using our fixed origin.
+        this.generateGridLines(this.fixedGridOrigin, visibilityRadius, adaptiveSpacing);
+    }
+    shouldRedrawGrid(cameraPosition, cameraHeight, gridExtent, currentSpacing) {
+        // check if the spacing has changed
+        if (this.lastUsedSpacing && this.lastUsedSpacing !== currentSpacing) {
+            return true;
+        }
+        // Always draw if we don't have a grid yet.
+        if (!this.gridLines || !this.lastCameraPosition || !this.fixedGridOrigin) {
+            return true;
+        }
+        // Check for significant height change.
+        const heightRatio = cameraHeight / this.lastCameraHeight;
+        if (heightRatio > (1 + this.HEIGHT_CHANGE_THRESHOLD) ||
+            heightRatio < (1 - this.HEIGHT_CHANGE_THRESHOLD)) {
+            return true;
+        }
+        // Check for significant position change relative to current grid extent.
+        const distance = Cesium.Cartesian3.distance(cameraPosition, this.lastCameraPosition);
+        const moveThreshold = gridExtent * this.CAMERA_MOVE_THRESHOLD;
+        if (distance > moveThreshold) {
+            return true;
+        }
+        // Check for significant grid extent change.
+        const extentRatio = gridExtent / this.lastGridExtent;
+        if (extentRatio > (1 + this.GRID_EXTENT_CHANGE_THRESHOLD) ||
+            extentRatio < (1 - this.GRID_EXTENT_CHANGE_THRESHOLD)) {
+            return true;
+        }
+        // No significant changes, keep current grid.
+        return false;
+    }
+    isGridDensityAcceptable(visibleArea, cameraHeight, spacingToCheck = this.spacingInMeters) {
+        const lonRange = visibleArea.eastLon - visibleArea.westLon;
+        const latRange = visibleArea.northLat - visibleArea.southLat;
+        // Convert to approximate meters at center
+        const centerCartographic = Cesium.Cartographic.fromCartesian(visibleArea.centerCartesian);
+        const metersPerDegreeLon = 111319.9 * Math.cos(centerCartographic.latitude);
+        const metersPerDegreeLat = 111319.9;
+        const widthInMeters = lonRange * metersPerDegreeLon;
+        const heightInMeters = latRange * metersPerDegreeLat;
+        const canvas = this.viewer.scene.canvas;
+        const spacingInDegrees = spacingToCheck / metersPerDegreeLon;
+        const canvasWidth = canvas.clientWidth;
+        const pixelsPerDegree = canvasWidth / lonRange;
+        const pixelsBetweenGridLines = pixelsPerDegree * spacingInDegrees;
+        const minPixelSize = 1;
+        return pixelsBetweenGridLines >= minPixelSize;
+    }
+    calculateVisibleArea() {
+        const scene = this.viewer.scene;
+        const camera = scene.camera;
+        const globe = scene.globe;
+        // Get the corners of the view frustum
+        const canvas = scene.canvas;
+        const corners = [
+            new Cesium.Cartesian2(0, 0),
+            new Cesium.Cartesian2(canvas.clientWidth, 0),
+            new Cesium.Cartesian2(0, canvas.clientHeight),
+            new Cesium.Cartesian2(canvas.clientWidth, canvas.clientHeight),
+            new Cesium.Cartesian2(canvas.clientWidth / 2, canvas.clientHeight / 2) // Center
+        ];
+        // Project corners to the globe
+        const cartographicCorners = [];
+        for (const corner of corners) {
+            const ray = camera.getPickRay(corner);
+            if (!ray) {
+                continue;
+            }
+            const position = globe.pick(ray, scene);
+            if (!position) {
+                continue;
+            }
+            cartographicCorners.push(Cesium.Cartographic.fromCartesian(position));
+        }
+        if (cartographicCorners.length === 0) {
+            return null;
+        }
+        // Find the bounding rectangle
+        let westLon = Number.POSITIVE_INFINITY;
+        let eastLon = Number.NEGATIVE_INFINITY;
+        let southLat = Number.POSITIVE_INFINITY;
+        let northLat = Number.NEGATIVE_INFINITY;
+        for (const corner of cartographicCorners) {
+            westLon = Math.min(westLon, corner.longitude);
+            eastLon = Math.max(eastLon, corner.longitude);
+            southLat = Math.min(southLat, corner.latitude);
+            northLat = Math.max(northLat, corner.latitude);
+        }
+        // Add some padding around the visible area
+        const lonPadding = (eastLon - westLon) * this.VIEW_PADDING_FACTOR;
+        const latPadding = (northLat - southLat) * this.VIEW_PADDING_FACTOR;
+        westLon -= lonPadding;
+        eastLon += lonPadding;
+        southLat -= latPadding;
+        northLat += latPadding;
+        // Get center position for reference
+        const centerCartographic = new Cesium.Cartographic((westLon + eastLon) / 2, (southLat + northLat) / 2);
+        const centerCartesian = Cesium.Cartesian3.fromRadians(centerCartographic.longitude, centerCartographic.latitude, 0);
+        return {
+            westLon: Cesium.Math.toDegrees(westLon),
+            eastLon: Cesium.Math.toDegrees(eastLon),
+            southLat: Cesium.Math.toDegrees(southLat),
+            northLat: Cesium.Math.toDegrees(northLat),
+            centerCartesian: centerCartesian
+        };
+    }
+    generateGridLines(originPoint, visibilityRadius, actualSpacing = this.spacingInMeters) {
+        // Number of grid cells in each direction (add 1 for edge lines).
+        const gridCellCount = Math.ceil(visibilityRadius / actualSpacing) + 1;
+        const maxCells = Math.min(gridCellCount, Math.floor(this.MAX_LINES / 2));
+        // Calculate interval to skip lines for density control.
+        const spacingFactor = actualSpacing / 100;
+        const heightFactor = this.lastCameraHeight / 500;
+        let lineSkipInterval = Math.floor(spacingFactor * heightFactor);
+        lineSkipInterval = Math.min(Math.max(lineSkipInterval, 1), 10); // Clamp between 1 and 10
+        const intersections = [];
+        // Generate north-south grid lines (longitude lines)
+        for (let i = -maxCells; i <= maxCells; i++) {
+            if (i % lineSkipInterval !== 0) {
+                continue;
+            }
+            const positions = [];
+            // Create a vertical line at this longitude offset.
+            // East heading for longitude.
+            const startPoint = this.cachedOffsetPoint(originPoint, i * actualSpacing, 90);
+            // Draw the line from south to north
+            for (let j = -maxCells; j <= maxCells; j++) {
+                if (j % lineSkipInterval !== 0) {
+                    continue;
+                }
+                // North heading for latitude.
+                const linePoint = this.cachedOffsetPoint(startPoint, j * actualSpacing, 0);
+                const position = Cesium.Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                positions.push(position);
+                intersections.push({
+                    position: position,
+                    i: i,
+                    j: j
+                });
+            }
+            if (positions.length >= 2) {
+                // Check if this is the primary Y axis (i=0) in model space
+                const isPrimaryYAxis = this.modelSpace && i === 0;
+                this.addGridLine(positions, isPrimaryYAxis ? "y" : null);
+            }
+        }
+        // Generate east-west grid lines (latitude lines).
+        for (let j = -maxCells; j <= maxCells; j++) {
+            if (j % lineSkipInterval !== 0) {
+                continue;
+            }
+            const positions = [];
+            // Create a horizontal line at this latitude offset
+            // North heading for latitude.
+            const startPoint = this.cachedOffsetPoint(originPoint, j * actualSpacing, 0);
+            // Draw the line from west to east.
+            for (let i = -maxCells; i <= maxCells; i++) {
+                if (i % lineSkipInterval !== 0) {
+                    continue;
+                }
+                // East heading for longitude.
+                const linePoint = this.cachedOffsetPoint(startPoint, i * actualSpacing, 90);
+                const position = Cesium.Cartesian3.fromDegrees(linePoint.longitude, linePoint.latitude, linePoint.altitude);
+                positions.push(position);
+            }
+            if (positions.length >= 2) {
+                // Check if this is the primary X axis (j=0) in model space
+                const isPrimaryXAxis = this.modelSpace && j === 0;
+                this.addGridLine(positions, isPrimaryXAxis ? "x" : null);
+            }
+        }
+        this.addGridLabels(intersections, actualSpacing);
+    }
+    addGridLabels(intersections, actualSpacing) {
+        if (!this.gridLabels) {
+            return;
+        }
+        // Determine label interval based on number of intersections.
+        // Use higher interval for more intersections to prevent crowding.
+        const totalIntersections = intersections.length;
+        let labelInterval = this.LABEL_INTERVAL;
+        if (totalIntersections > 1000) {
+            labelInterval = 5;
+        }
+        else if (totalIntersections > 500) {
+            labelInterval = 3;
+        }
+        let labelCount = 0;
+        // Filter intersections to only those at the labelInterval.
+        const labelPoints = intersections.filter(point => {
+            // Always label the origin (0,0).
+            if (point.i === 0 && point.j === 0) {
+                return true;
+            }
+            return (point.i % labelInterval === 0 && point.j % labelInterval === 0);
+        });
+        // Sort points by distance from origin.
+        labelPoints.sort((a, b) => {
+            const distA = Math.abs(a.i) + Math.abs(a.j);
+            const distB = Math.abs(b.i) + Math.abs(b.j);
+            return distA - distB;
+        });
+        // Add labels, prioritizing those closest to the origin.
+        for (const point of labelPoints) {
+            if (labelCount >= this.MAX_LABELS) {
+                // Limit reached.
+                break;
+            }
+            let labelText;
+            // Model space coordinates (meters from origin).
+            if (this.modelSpace) {
+                const xMeters = point.i * actualSpacing;
+                const yMeters = point.j * actualSpacing;
+                if (point.i === 0 && point.j === 0) {
+                    labelText = "0,0,0";
+                }
+                else {
+                    labelText = `${xMeters},${yMeters}`;
+                }
+            }
+            // Geographic coordinates (degrees).
+            else {
+                const cartographic = Cesium.Cartographic.fromCartesian(point.position);
+                const latitude = Cesium.Math.toDegrees(cartographic.latitude);
+                const longitude = Cesium.Math.toDegrees(cartographic.longitude);
+                const latFormatted = latitude.toFixed(5);
+                const lonFormatted = longitude.toFixed(5);
+                labelText = `${latFormatted}, ${lonFormatted}`;
+            }
+            this.gridLabels.add({
+                position: point.position,
+                text: labelText,
+                font: this.modelSpace && point.i === 0 && point.j === 0 ? "20px sans-serif" : "14px sans-serif",
+                fillColor: this.modelSpace && point.i === 0 && point.j === 0 ? Cesium.Color.WHITE : Cesium.Color.WHITE.withAlpha(0.5),
+                style: Cesium.LabelStyle.FILL,
+                horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
+                verticalOrigin: Cesium.VerticalOrigin.TOP,
+                pixelOffset: new Cesium.Cartesian2(0, 10),
+                // Fade out with distance.
+                translucencyByDistance: new Cesium.NearFarScalar(1000, 1.0, 15000, 0.4)
+            });
+            labelCount++;
+        }
+    }
+    addGridLine(positions, primaryAxis = null) {
+        if (!this.gridLines || positions.length < 2) {
+            return;
+        }
+        let lineColor;
+        let lineWidth = 1.0;
+        let lineAlpha = 0.2;
+        // Red for X axis.
+        if (primaryAxis === "x") {
+            lineColor = Cesium.Color.RED;
+            lineAlpha = 0.5;
+            lineWidth = 1.5;
+        }
+        // Green for Y axis.
+        else if (primaryAxis === "y") {
+            lineColor = Cesium.Color.GREEN;
+            lineAlpha = 0.5;
+            lineWidth = 1.5;
+        }
+        // Default gray for regular grid lines.
+        else {
+            lineColor = Cesium.Color.LIGHTGRAY;
+        }
+        this.gridLines.add({
+            positions: positions,
+            width: lineWidth,
+            material: Cesium.Material.fromType("Color", {
+                color: lineColor.withAlpha(lineAlpha)
+            })
+        });
+    }
+}
+// Grid square size used when settings name none, in metres.
+const DEFAULT_SPACING = 50;
+var CesiumMapGrid;
+(function (CesiumMapGrid) {
+    function GetCurrentSpacing(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return 0;
+        }
+        const handler = viewer[CLASS_INSTANCE_KEY];
+        return handler ? handler.getCurrentSpacing() : 0;
+    }
+    CesiumMapGrid.GetCurrentSpacing = GetCurrentSpacing;
+    function Remove(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return;
+        }
+        else if (!viewer[LAST_SETTINGS_KEY]) {
+            return;
+        }
+        if (!viewer[UPDATE_MARKER_KEY]) {
+            viewer[UPDATE_MARKER_KEY] = 1;
+        }
+        else {
+            viewer[UPDATE_MARKER_KEY]++;
+        }
+        // Dispose of the handler.
+        if (viewer[CLASS_INSTANCE_KEY]) {
+            viewer[CLASS_INSTANCE_KEY].Dispose();
+            viewer[CLASS_INSTANCE_KEY] = null;
+        }
+        viewer[LAST_SETTINGS_KEY] = {
+            ...viewer[LAST_SETTINGS_KEY],
+            enabled: false
+        };
+    }
+    CesiumMapGrid.Remove = Remove;
+    function Draw(viewer, spacingInMeters, modelSpace = true) {
+        if (!viewer || viewer.isDestroyed()) {
+            return;
+        }
+        let settings = viewer[LAST_SETTINGS_KEY];
+        if (settings) {
+            // See if the settings are the same as the last time.
+            if (settings.spacing === spacingInMeters &&
+                settings.modelSpace === modelSpace &&
+                settings.enabled) {
+                return;
+            }
+        }
+        if (!viewer[UPDATE_MARKER_KEY]) {
+            viewer[UPDATE_MARKER_KEY] = 1;
+        }
+        else {
+            viewer[UPDATE_MARKER_KEY]++;
+        }
+        settings = {
+            ...settings,
+            enabled: true,
+            spacing: spacingInMeters,
+            modelSpace: modelSpace
+        };
+        viewer[LAST_SETTINGS_KEY] = settings;
+        // Create or update the handler.
+        if (viewer[CLASS_INSTANCE_KEY]) {
+            viewer[CLASS_INSTANCE_KEY].Update(spacingInMeters, modelSpace);
+        }
+        else {
+            viewer[CLASS_INSTANCE_KEY] = new MapGridHandler(viewer, spacingInMeters, modelSpace);
+        }
+    }
+    CesiumMapGrid.Draw = Draw;
+    /**
+     * Draws a bookmark's grid, or removes the grid when it has none; only model-space draws one.
+     */
+    function Apply(viewer, grid, modelSpace) {
+        if ((grid === null || grid === void 0 ? void 0 : grid.enabled) && modelSpace) {
+            Draw(viewer, Number(grid.spacing) || DEFAULT_SPACING, modelSpace);
+        }
+        else {
+            Remove(viewer);
+        }
+    }
+    CesiumMapGrid.Apply = Apply;
+    function GetIsEnabled(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return false;
+        }
+        const settings = viewer[LAST_SETTINGS_KEY];
+        if (settings) {
+            return Boolean(settings.enabled);
+        }
+        return false;
+    }
+    CesiumMapGrid.GetIsEnabled = GetIsEnabled;
+    /**
+     * Returns the last applied grid settings.
+     */
+    function GetSettings(viewer) {
+        if (!viewer || viewer.isDestroyed()) {
+            return null;
+        }
+        return viewer[LAST_SETTINGS_KEY];
+    }
+    CesiumMapGrid.GetSettings = GetSettings;
+})(CesiumMapGrid = exports.CesiumMapGrid || (exports.CesiumMapGrid = {}));
+//# sourceMappingURL=cesium-map-grid.js.map