bruce-cesium 6.5.2 → 6.5.3

package/dist/bruce-cesium.umd.js

@@ -14777,23 +14777,13 @@
         DataLabRenderManager.Manager = Manager;
     })(exports.DataLabRenderManager || (exports.DataLabRenderManager = {}));
 
-    const TIME_LAG = 300;
-    const POSITION_CHECK_TIMER = 950;
     const DEFAULT_GROUNDED_HEIGHT = 300;
     const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
     const NET_STEP_PERCENT = 5;
     const BORDER_STEPS = 3;
-    var ESearchStatus;
-    (function (ESearchStatus) {
-        ESearchStatus[ESearchStatus["LocationFound"] = 1] = "LocationFound";
-        ESearchStatus[ESearchStatus["LocationChanged"] = 2] = "LocationChanged";
-        ESearchStatus[ESearchStatus["LocationMissing"] = 3] = "LocationMissing";
-    })(ESearchStatus || (ESearchStatus = {}));
-    /**
-     * @param viewer
-     * @param center the previously calculated center of the view area. This is in degrees.
-     * @returns
-     */
+    function isDefined(value) {
+        return value !== null && value !== undefined;
+    }
     function netScanViewForBoundaries(viewer, center) {
         let maxLong = -2 * Math.PI;
         let minLong = 2 * Math.PI;
@@ -14801,7 +14791,6 @@
         let minLat = 2 * Math.PI;
         let found = 0;
         const updateMinMax = (lon, lat) => {
-            // Check to see if given lon/lat (in radians) are within valid range.
             if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
                 return;
             }
@@ -14811,13 +14800,13 @@
             minLat = Math.min(minLat, lat);
         };
         const updateMinMaxForPoint = (stepX, stepY) => {
-            const x = Math.round(0 + (viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
-            const y = Math.round(0 + (viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
+            const x = Math.round((viewer.container.clientWidth / 100) * (stepX * NET_STEP_PERCENT));
+            const y = Math.round((viewer.container.clientHeight / 100) * (stepY * NET_STEP_PERCENT));
             const winPos = new Cesium.Cartesian2(x, y);
             try {
-                let intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+                const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
                 if (intersection) {
-                    let point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+                    const point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
                     updateMinMax(point.longitude, point.latitude);
                     found++;
                 }
@@ -14826,115 +14815,78 @@
                 console.error(e);
             }
         };
-        // Outer circle.
         updateMinMaxForPoint(BORDER_STEPS, BORDER_STEPS);
         updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, BORDER_STEPS);
         updateMinMaxForPoint(BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
         updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS, (100 / NET_STEP_PERCENT) - BORDER_STEPS);
-        // Inner circle.
         updateMinMaxForPoint(BORDER_STEPS * 2, BORDER_STEPS * 2);
         updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, BORDER_STEPS * 2);
         updateMinMaxForPoint(BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
         updateMinMaxForPoint((100 / NET_STEP_PERCENT) - BORDER_STEPS * 2, (100 / NET_STEP_PERCENT) - BORDER_STEPS * 2);
-        // If we failed to find intersections and a center-point was provided, then we can use that to make some guesses.
-        // This happens if terrain is hidden, and there's nothing to intersect with.
         if (center && found <= 0) {
             updateMinMax(Cesium.Math.toRadians(center.longitude), Cesium.Math.toRadians(center.latitude));
             found += 1;
-            // We'll use the camera height as an indicator on size of the rect.
-            let size = viewer.camera.positionCartographic.height;
+            const size = viewer.camera.positionCartographic.height;
             const pitch = viewer.camera.pitch;
             const distance = size / Math.tan(pitch);
-            const p1 = _offsetPoint({
+            const p1 = offsetPoint({
                 altitude: center.altitude,
                 latitude: center.latitude,
                 longitude: center.longitude
             }, distance, 45);
-            const p2 = _offsetPoint({
+            const p2 = offsetPoint({
                 altitude: center.altitude,
                 latitude: center.latitude,
                 longitude: center.longitude
             }, -distance, 45);
-            if (p1 === null || p1 === void 0 ? void 0 : p1.latitude) {
+            if (isDefined(p1 === null || p1 === void 0 ? void 0 : p1.latitude) && isDefined(p1 === null || p1 === void 0 ? void 0 : p1.longitude)) {
                 updateMinMax(Cesium.Math.toRadians(p1.longitude), Cesium.Math.toRadians(p1.latitude));
             }
-            if (p2 === null || p2 === void 0 ? void 0 : p2.latitude) {
+            if (isDefined(p2 === null || p2 === void 0 ? void 0 : p2.latitude) && isDefined(p2 === null || p2 === void 0 ? void 0 : p2.longitude)) {
                 updateMinMax(Cesium.Math.toRadians(p2.longitude), Cesium.Math.toRadians(p2.latitude));
             }
         }
         if (found > 0) {
-            const viewRect = {
+            return {
                 east: maxLong,
                 west: minLong,
                 north: maxLat,
                 south: minLat
             };
-            return viewRect;
         }
         return null;
     }
-    /**
-     * Moves a given point by a given distance towards a heading.
-     * @param point in degrees.
-     * @param distance in meters.
-     * @param heading in degrees.
-     * @returns
-     */
-    function _offsetPoint(point, distance, heading) {
-        // Radius of earth.
+    function offsetPoint(point, distance, heading) {
         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);
+        const delta = distance / radius;
+        const theta = Cesium.Math.toRadians(heading);
+        const phi1 = Cesium.Math.toRadians(point.latitude);
+        const lambda1 = Cesium.Math.toRadians(point.longitude);
+        const sinPhi2 = Math.sin(phi1) * Math.cos(delta) + Math.cos(phi1) * Math.sin(delta) * Math.cos(theta);
+        const phi2 = Math.asin(sinPhi2);
+        const y = Math.sin(theta) * Math.sin(delta) * Math.cos(phi1);
+        const x = Math.cos(delta) - Math.sin(phi1) * sinPhi2;
+        const lambda2 = lambda1 + Math.atan2(y, x);
         return {
             altitude: point.altitude,
-            latitude: Cesium.Math.toDegrees(φ2),
-            longitude: Cesium.Math.toDegrees(λ2)
+            latitude: Cesium.Math.toDegrees(phi2),
+            longitude: Cesium.Math.toDegrees(lambda2)
         };
     }
-    /**
-     * @param pos3d
-     * @param distance in meters
-     * @param heading in degrees
-     * @returns
-     */
-    function _offsetPos3d(pos3d, distance, heading) {
+    function offsetPos3d(pos3d, distance, heading) {
         const carto = Cesium.Cartographic.fromCartesian(pos3d);
-        const newCarto = _offsetPoint({
+        const newCarto = offsetPoint({
             altitude: carto.height,
             latitude: Cesium.Math.toDegrees(carto.latitude),
             longitude: Cesium.Math.toDegrees(carto.longitude)
         }, distance, heading);
         return Cesium.Cartesian3.fromDegrees(newCarto.longitude, newCarto.latitude, newCarto.altitude);
     }
-    /**
-     * Returns the intersection of the camera ray with the ground.
-     * @param viewer
-     * @param screenPos
-     * @returns
-     */
     function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
         const ray = viewer.camera.getPickRay(screenPos);
         const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-        if (intersection) {
-            return intersection;
-        }
-        return null;
+        return intersection || null;
     }
-    /**
-     * Returns the intersection of the camera ray with the ground.
-     * If no intersection is found, then a "guess" is made based on the camera angle and height.
-     * The guess is made at the center of the view! It ignores the screenPos.
-     * @param viewer
-     * @param screenPos
-     * @returns
-     */
     function getGroundCenterOfCameraRay(viewer, screenPos) {
         var _a, _b;
         const ray = viewer.camera.getPickRay(screenPos);
@@ -14942,19 +14894,113 @@
         if (intersection) {
             return intersection;
         }
-        // The fallback will be to "guess" where the intersection might be.
-        // This happens if terrain is hidden, and there's nothing to intersect with.
-        // We will use the camera angle + camera height.
-        // Eg: if camera is looking straight down and is 100 meters above the ground, then the intersection will be 100 meters below the camera.
-        let cameraHeight = viewer.camera.positionCartographic.height;
-        if (!isNaN(cameraHeight) && cameraHeight != null && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
+        const cameraHeight = viewer.camera.positionCartographic.height;
+        if (!isNaN(cameraHeight) && isDefined(cameraHeight) && ((_b = (_a = viewer.camera) === null || _a === void 0 ? void 0 : _a.position) === null || _b === void 0 ? void 0 : _b.clone)) {
             const cameraPos3d = viewer.camera.position.clone();
             const pitch = viewer.camera.pitch;
             const distance = cameraHeight / Math.tan(pitch);
-            return _offsetPos3d(cameraPos3d, -distance, Cesium.Math.toDegrees(viewer.camera.heading));
+            return offsetPos3d(cameraPos3d, -distance, Cesium.Math.toDegrees(viewer.camera.heading));
         }
         return null;
     }
+    (function (CesiumViewGroundArea) {
+        function ToBboxPolygon(bounds) {
+            return `${bounds.west},${bounds.south} ${bounds.west},${bounds.north} ${bounds.east},${bounds.north} ${bounds.east},${bounds.south}`;
+        }
+        CesiumViewGroundArea.ToBboxPolygon = ToBboxPolygon;
+        async function GetViewArea(viewer) {
+            var _a, _b;
+            if (!viewer || viewer.isDestroyed()) {
+                return null;
+            }
+            if (!viewer.container || ((_a = viewer.container.style) === null || _a === void 0 ? void 0 : _a.display) == "none") {
+                return null;
+            }
+            let viewRect = null;
+            let center = null;
+            const camera = viewer.camera;
+            const terrData = await exports.DrawingUtils.GetTerrainHeight({
+                pos3d: camera.position,
+                viewer
+            });
+            const cameraPosition = viewer.camera.positionCartographic;
+            const terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
+            if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
+                viewRect = {};
+                const viewRectRad = netScanViewForBoundaries(viewer);
+                if (viewRectRad &&
+                    isDefined(viewRectRad.east) &&
+                    isDefined(viewRectRad.west) &&
+                    isDefined(viewRectRad.north) &&
+                    isDefined(viewRectRad.south)) {
+                    viewRect.east = Cesium.Math.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                    viewRect.west = Cesium.Math.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                    viewRect.south = Cesium.Math.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                    viewRect.north = Cesium.Math.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+                }
+                else {
+                    viewRect.east = Cesium.Math.toDegrees(cameraPosition.longitude);
+                    viewRect.west = Cesium.Math.toDegrees(cameraPosition.longitude);
+                    viewRect.south = Cesium.Math.toDegrees(cameraPosition.latitude);
+                    viewRect.north = Cesium.Math.toDegrees(cameraPosition.latitude);
+                }
+                center = {
+                    altitude: camera.positionCartographic.height,
+                    latitude: Cesium.Math.toDegrees(camera.positionCartographic.latitude),
+                    longitude: Cesium.Math.toDegrees(camera.positionCartographic.longitude)
+                };
+            }
+            else {
+                const windowPosition = new Cesium.Cartesian2(viewer.container.clientWidth / 2, viewer.container.clientHeight / 2);
+                const intersection = getGroundCenterOfCameraRay(viewer, windowPosition);
+                let point = null;
+                if (intersection) {
+                    point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+                }
+                if (point) {
+                    center = {
+                        altitude: point.height,
+                        latitude: Cesium.Math.toDegrees(point.latitude),
+                        longitude: Cesium.Math.toDegrees(point.longitude)
+                    };
+                    const viewRectRad = netScanViewForBoundaries(viewer, center);
+                    if (viewRectRad) {
+                        viewRect = {};
+                        viewRect.east = Cesium.Math.toDegrees(viewRectRad.east);
+                        viewRect.west = Cesium.Math.toDegrees(viewRectRad.west);
+                        viewRect.south = Cesium.Math.toDegrees(viewRectRad.south);
+                        viewRect.north = Cesium.Math.toDegrees(viewRectRad.north);
+                    }
+                }
+            }
+            if (viewRect) {
+                const centerLong = (viewRect.east + viewRect.west) / 2;
+                const centerLat = (viewRect.north + viewRect.south) / 2;
+                viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
+                viewRect.alt = (_b = viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height;
+            }
+            if (center && viewRect) {
+                return {
+                    bounds: viewRect,
+                    target: center
+                };
+            }
+            return null;
+        }
+        CesiumViewGroundArea.GetViewArea = GetViewArea;
+    })(exports.CesiumViewGroundArea || (exports.CesiumViewGroundArea = {}));
+
+    const TIME_LAG = 300;
+    const POSITION_CHECK_TIMER = 950;
+    var ESearchStatus;
+    (function (ESearchStatus) {
+        ESearchStatus[ESearchStatus["LocationFound"] = 1] = "LocationFound";
+        ESearchStatus[ESearchStatus["LocationChanged"] = 2] = "LocationChanged";
+        ESearchStatus[ESearchStatus["LocationMissing"] = 3] = "LocationMissing";
+    })(ESearchStatus || (ESearchStatus = {}));
     function areBoundsEqual(a, b) {
         return a.north == b.north && a.south == b.south && a.east == b.east && a.west == b.west;
     }
@@ -15035,7 +15081,7 @@
                 this.destroyEntity();
             }
             async tryDoUpdate() {
-                var _a, _b;
+                var _a;
                 if (!this.viewer || this.viewer.isDestroyed()) {
                     this.Dispose();
                     return ESearchStatus.LocationMissing;
@@ -15043,73 +15089,10 @@
                 if (!this.viewer.container || ((_a = this.viewer.container.style) === null || _a === void 0 ? void 0 : _a.display) == "none") {
                     return ESearchStatus.LocationMissing;
                 }
-                let viewRect = null;
-                let center = null;
-                const camera = this.viewer.camera;
-                const terrData = await exports.DrawingUtils.GetTerrainHeight({
-                    pos3d: camera.position,
-                    viewer: this.viewer
-                });
-                const cameraPosition = this.viewer.camera.positionCartographic;
-                const terrHeight = terrData.error ? cameraPosition.height + DEFAULT_GROUNDED_HEIGHT : terrData.height;
-                // We are almost at the ground, screw horizon, just load around.
-                if (terrHeight && ((cameraPosition.height - terrHeight) < DEFAULT_GROUNDED_HEIGHT)) {
-                    // View area calculation.
-                    viewRect = {};
-                    const viewRectRad = netScanViewForBoundaries(this.viewer);
-                    if (viewRectRad &&
-                        viewRectRad.east &&
-                        viewRectRad.west &&
-                        viewRectRad.north &&
-                        viewRectRad.south) {
-                        viewRect.east = Cesium.Math.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
-                        viewRect.west = Cesium.Math.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
-                        viewRect.south = Cesium.Math.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
-                        viewRect.north = Cesium.Math.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
-                    }
-                    else {
-                        viewRect.east = cameraPosition.longitude;
-                        viewRect.west = cameraPosition.longitude;
-                        viewRect.south = cameraPosition.latitude;
-                        viewRect.north = cameraPosition.latitude;
-                    }
-                    center = {};
-                    center.latitude = Cesium.Math.toDegrees(camera.positionCartographic.latitude);
-                    center.longitude = Cesium.Math.toDegrees(camera.positionCartographic.longitude);
-                }
-                else {
-                    // View area calculation.
-                    const windowPosition = new Cesium.Cartesian2(this.viewer.container.clientWidth / 2, this.viewer.container.clientHeight / 2);
-                    const intersection = getGroundCenterOfCameraRay(this.viewer, windowPosition);
-                    let point = null;
-                    if (intersection) {
-                        point = Cesium.Cartographic.fromCartesian(intersection, this.viewer.scene.globe.ellipsoid);
-                    }
-                    if (point) {
-                        center = {};
-                        center.latitude = Cesium.Math.toDegrees(point.latitude);
-                        center.longitude = Cesium.Math.toDegrees(point.longitude);
-                        let viewRectRad = netScanViewForBoundaries(this.viewer, center);
-                        if (viewRectRad) {
-                            viewRect = {};
-                            viewRect.east = Cesium.Math.toDegrees(viewRectRad.east);
-                            viewRect.west = Cesium.Math.toDegrees(viewRectRad.west);
-                            viewRect.south = Cesium.Math.toDegrees(viewRectRad.south);
-                            viewRect.north = Cesium.Math.toDegrees(viewRectRad.north);
-                        }
-                    }
-                }
-                // Minimal field of view.
-                if (viewRect) {
-                    const centerLong = (viewRect.east + viewRect.west) / 2;
-                    const centerLat = (viewRect.north + viewRect.south) / 2;
-                    viewRect.east = Math.max(viewRect.east, centerLong + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                    viewRect.west = Math.min(viewRect.west, centerLong - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                    viewRect.south = Math.min(viewRect.south, centerLat - (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                    viewRect.north = Math.max(viewRect.north, centerLat + (MINIMUM_VIEW_AREA_SIZE_DEGREES / 2));
-                    viewRect.alt = (_b = this.viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height;
-                }
-                if (center && viewRect) {
+                const viewArea = await exports.CesiumViewGroundArea.GetViewArea(this.viewer);
+                if ((viewArea === null || viewArea === void 0 ? void 0 : viewArea.target) && (viewArea === null || viewArea === void 0 ? void 0 : viewArea.bounds)) {
+                    const center = viewArea.target;
+                    const viewRect = viewArea.bounds;
                     if ((!this.target || (this.target && !arePosEqual(this.target, center))) ||
                         (!this.bounds || (this.bounds && !areBoundsEqual(this.bounds, viewRect)))) {
                         this.target = center;
@@ -26127,7 +26110,7 @@
                 data.actions.get(EAction.Backward)) {
                 const heading = getMovementHeading(viewer);
                 const pos = viewer.camera.positionCartographic;
-                const newPos = _offsetPoint$1({
+                const newPos = _offsetPoint({
                     altitude: pos.height,
                     latitude: Cesium.Math.toDegrees(pos.latitude),
                     longitude: Cesium.Math.toDegrees(pos.longitude)
@@ -26144,7 +26127,7 @@
      * @param heading in degrees.
      * @returns
      */
-    function _offsetPoint$1(point, distance, heading) {
+    function _offsetPoint(point, distance, heading) {
         // Radius of earth.
         const radius = 6371e3;
         const δ = distance / radius;
@@ -30094,7 +30077,7 @@
                     // This gives a better experience than looking straight down.
                     if (!is2d) {
                         // Combine the elevation with the sideways offset.
-                        const finalStartingPosition = _offsetPos3d$1(elevatedPos3d, -range, Cesium.Math.toDegrees(params.viewer.camera.heading));
+                        const finalStartingPosition = _offsetPos3d(elevatedPos3d, -range, Cesium.Math.toDegrees(params.viewer.camera.heading));
                         // Calculate the direction from the elevated and offset starting position towards the destination.
                         const direction = Cesium.Cartesian3.subtract(destination, finalStartingPosition, new Cesium.Cartesian3());
                         Cesium.Cartesian3.normalize(direction, direction);
@@ -30150,7 +30133,7 @@
      * @param heading in degrees.
      * @returns
      */
-    function _offsetPoint$2(point, distance, heading) {
+    function _offsetPoint$1(point, distance, heading) {
         // Radius of earth.
         const radius = 6371e3;
         const δ = distance / radius;
@@ -30174,9 +30157,9 @@
      * @param heading in degrees
      * @returns
      */
-    function _offsetPos3d$1(pos3d, distance, heading) {
+    function _offsetPos3d(pos3d, distance, heading) {
         const carto = Cesium.Cartographic.fromCartesian(pos3d);
-        const newCarto = _offsetPoint$2({
+        const newCarto = _offsetPoint$1({
             altitude: carto.height,
             latitude: Cesium.Math.toDegrees(carto.latitude),
             longitude: Cesium.Math.toDegrees(carto.longitude)
@@ -35219,7 +35202,7 @@
         }
     }
 
-    const VERSION = "6.5.2";
+    const VERSION = "6.5.3";
     /**
      * Updates the environment instance used by bruce-cesium to one specified.
      * This can be used to ensure that the instance a parent is referencing is shared between bruce-cesium, bruce-models, and the parent app.