bruce-cesium 6.6.1 → 6.6.2

package/dist/bruce-cesium.umd.js

@@ -12816,235 +12816,6 @@
         return [id, cell];
     }
 
-    const DEFAULT_GROUNDED_HEIGHT = 300;
-    const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
-    const NET_STEP_PERCENT = 5;
-    const BORDER_STEPS = 3;
-    function isDefined(value) {
-        return value !== null && value !== undefined;
-    }
-    function netScanViewForBoundaries(viewer, center) {
-        let maxLong = -2 * Math.PI;
-        let minLong = 2 * Math.PI;
-        let maxLat = -2 * Math.PI;
-        let minLat = 2 * Math.PI;
-        let found = 0;
-        const updateMinMax = (lon, lat) => {
-            if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
-                return;
-            }
-            maxLong = Math.max(maxLong, lon);
-            maxLat = Math.max(maxLat, lat);
-            minLong = Math.min(minLong, lon);
-            minLat = Math.min(minLat, lat);
-        };
-        const updateMinMaxForPoint = (stepX, stepY) => {
-            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 {
-                const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
-                if (intersection) {
-                    const point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
-                    updateMinMax(point.longitude, point.latitude);
-                    found++;
-                }
-            }
-            catch (e) {
-                console.error(e);
-            }
-        };
-        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);
-        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 (center && found <= 0) {
-            updateMinMax(Cesium.Math.toRadians(center.longitude), Cesium.Math.toRadians(center.latitude));
-            found += 1;
-            const size = viewer.camera.positionCartographic.height;
-            const pitch = viewer.camera.pitch;
-            const distance = size / Math.tan(pitch);
-            const p1 = offsetPoint({
-                altitude: center.altitude,
-                latitude: center.latitude,
-                longitude: center.longitude
-            }, distance, 45);
-            const p2 = offsetPoint({
-                altitude: center.altitude,
-                latitude: center.latitude,
-                longitude: center.longitude
-            }, -distance, 45);
-            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 (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) {
-            return {
-                east: maxLong,
-                west: minLong,
-                north: maxLat,
-                south: minLat
-            };
-        }
-        return null;
-    }
-    function offsetPoint(point, distance, heading) {
-        const radius = 6371e3;
-        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(phi2),
-            longitude: Cesium.Math.toDegrees(lambda2)
-        };
-    }
-    function offsetPos3d(pos3d, distance, heading) {
-        const carto = Cesium.Cartographic.fromCartesian(pos3d);
-        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);
-    }
-    function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
-        const ray = viewer.camera.getPickRay(screenPos);
-        const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-        return intersection || null;
-    }
-    function getGroundCenterOfCameraRay(viewer, screenPos) {
-        var _a, _b;
-        const ray = viewer.camera.getPickRay(screenPos);
-        const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
-        if (intersection) {
-            return intersection;
-        }
-        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 null;
-    }
-    (function (ViewGroundArea) {
-        function ToBboxPolygon(bounds) {
-            return `${bounds.west},${bounds.south} ${bounds.west},${bounds.north} ${bounds.east},${bounds.north} ${bounds.east},${bounds.south}`;
-        }
-        ViewGroundArea.ToBboxPolygon = ToBboxPolygon;
-        function NormalizeBounds(bounds, altitude) {
-            if (!bounds ||
-                !isDefined(bounds.east) ||
-                !isDefined(bounds.west) ||
-                !isDefined(bounds.north) ||
-                !isDefined(bounds.south)) {
-                return null;
-            }
-            const viewRect = { ...bounds };
-            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));
-            if (isDefined(altitude)) {
-                viewRect.alt = altitude;
-            }
-            return viewRect;
-        }
-        ViewGroundArea.NormalizeBounds = NormalizeBounds;
-        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);
-                    }
-                }
-            }
-            viewRect = NormalizeBounds(viewRect, (_b = viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height);
-            if (center && viewRect) {
-                return {
-                    bounds: viewRect,
-                    target: center
-                };
-            }
-            return null;
-        }
-        ViewGroundArea.GetViewArea = GetViewArea;
-    })(exports.ViewGroundArea || (exports.ViewGroundArea = {}));
-
     const MAX_AREA_IN_DEGREES$1 = 90;
     const MAX_RETRY_ATTEMPTS = 1;
     const RETRY_DELAY_INCREMENT = 500;
@@ -13064,6 +12835,23 @@
             }, milliseconds);
         });
     }
+    function createBoundsPolygonGeometry(bounds) {
+        const ring = [
+            `${bounds.west},${bounds.south}`,
+            `${bounds.west},${bounds.north}`,
+            `${bounds.east},${bounds.north}`,
+            `${bounds.east},${bounds.south}`,
+            `${bounds.west},${bounds.south}`
+        ].join(" ");
+        return {
+            Polygon: [
+                {
+                    Facing: BModels.Geometry.EPolygonRingType.Boundaries,
+                    LinearRing: ring
+                }
+            ]
+        };
+    }
     /**
      * This is a batched entity getter.
      * It will scan for entity records in a view-area and emit them in batches.
@@ -13365,8 +13153,9 @@
                         LogicOperator: "AND",
                         AttributeValue: {
                             AttributePath: "Bruce/Boundaries",
-                            OperandA: exports.ViewGroundArea.ToBboxPolygon(bounds),
-                            Operator: "intersects"
+                            OperandA: createBoundsPolygonGeometry(bounds),
+                            Operator: "intersects",
+                            ValueOption: "CONST"
                         },
                         key: "attribute"
                     }
@@ -15599,6 +15388,235 @@
         DataLabRenderManager.Manager = Manager;
     })(exports.DataLabRenderManager || (exports.DataLabRenderManager = {}));
 
+    const DEFAULT_GROUNDED_HEIGHT = 300;
+    const MINIMUM_VIEW_AREA_SIZE_DEGREES = 0.01;
+    const NET_STEP_PERCENT = 5;
+    const BORDER_STEPS = 3;
+    function isDefined(value) {
+        return value !== null && value !== undefined;
+    }
+    function netScanViewForBoundaries(viewer, center) {
+        let maxLong = -2 * Math.PI;
+        let minLong = 2 * Math.PI;
+        let maxLat = -2 * Math.PI;
+        let minLat = 2 * Math.PI;
+        let found = 0;
+        const updateMinMax = (lon, lat) => {
+            if (lon < -Math.PI || lon > Math.PI || lat < -Math.PI / 2 || lat > Math.PI / 2) {
+                return;
+            }
+            maxLong = Math.max(maxLong, lon);
+            maxLat = Math.max(maxLat, lat);
+            minLong = Math.min(minLong, lon);
+            minLat = Math.min(minLat, lat);
+        };
+        const updateMinMaxForPoint = (stepX, stepY) => {
+            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 {
+                const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+                if (intersection) {
+                    const point = Cesium.Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+                    updateMinMax(point.longitude, point.latitude);
+                    found++;
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        };
+        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);
+        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 (center && found <= 0) {
+            updateMinMax(Cesium.Math.toRadians(center.longitude), Cesium.Math.toRadians(center.latitude));
+            found += 1;
+            const size = viewer.camera.positionCartographic.height;
+            const pitch = viewer.camera.pitch;
+            const distance = size / Math.tan(pitch);
+            const p1 = offsetPoint({
+                altitude: center.altitude,
+                latitude: center.latitude,
+                longitude: center.longitude
+            }, distance, 45);
+            const p2 = offsetPoint({
+                altitude: center.altitude,
+                latitude: center.latitude,
+                longitude: center.longitude
+            }, -distance, 45);
+            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 (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) {
+            return {
+                east: maxLong,
+                west: minLong,
+                north: maxLat,
+                south: minLat
+            };
+        }
+        return null;
+    }
+    function offsetPoint(point, distance, heading) {
+        const radius = 6371e3;
+        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(phi2),
+            longitude: Cesium.Math.toDegrees(lambda2)
+        };
+    }
+    function offsetPos3d(pos3d, distance, heading) {
+        const carto = Cesium.Cartographic.fromCartesian(pos3d);
+        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);
+    }
+    function getAdjustedGroundIntersectionOfCameraRay(viewer, screenPos) {
+        const ray = viewer.camera.getPickRay(screenPos);
+        const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+        return intersection || null;
+    }
+    function getGroundCenterOfCameraRay(viewer, screenPos) {
+        var _a, _b;
+        const ray = viewer.camera.getPickRay(screenPos);
+        const intersection = ray ? viewer.scene.globe.pick(ray, viewer.scene) : null;
+        if (intersection) {
+            return intersection;
+        }
+        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 null;
+    }
+    (function (ViewGroundArea) {
+        function ToBboxPolygon(bounds) {
+            return `${bounds.west},${bounds.south} ${bounds.west},${bounds.north} ${bounds.east},${bounds.north} ${bounds.east},${bounds.south}`;
+        }
+        ViewGroundArea.ToBboxPolygon = ToBboxPolygon;
+        function NormalizeBounds(bounds, altitude) {
+            if (!bounds ||
+                !isDefined(bounds.east) ||
+                !isDefined(bounds.west) ||
+                !isDefined(bounds.north) ||
+                !isDefined(bounds.south)) {
+                return null;
+            }
+            const viewRect = { ...bounds };
+            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));
+            if (isDefined(altitude)) {
+                viewRect.alt = altitude;
+            }
+            return viewRect;
+        }
+        ViewGroundArea.NormalizeBounds = NormalizeBounds;
+        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);
+                    }
+                }
+            }
+            viewRect = NormalizeBounds(viewRect, (_b = viewer.scene.camera.positionCartographic) === null || _b === void 0 ? void 0 : _b.height);
+            if (center && viewRect) {
+                return {
+                    bounds: viewRect,
+                    target: center
+                };
+            }
+            return null;
+        }
+        ViewGroundArea.GetViewArea = GetViewArea;
+    })(exports.ViewGroundArea || (exports.ViewGroundArea = {}));
+
     const TIME_LAG = 300;
     const POSITION_CHECK_TIMER = 950;
     var ESearchStatus;
@@ -35839,7 +35857,7 @@
         }
     }
 
-    const VERSION = "6.6.1";
+    const VERSION = "6.6.2";
     /**
      * 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.