bruce-cesium 6.6.1 → 6.6.2

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
-import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, DataLab, EntityCoords, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Bounds, Carto, ProjectView, ProjectViewBookmark, ProjectViewLegacyTile, Camera, AbstractApi, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils, Session } from 'bruce-models';
+import { Cartes, Entity as Entity$1, Calculator, EntityRelationType, EntityType, Style, ENVIRONMENT, ProjectViewTile, DelayQueue, LRUCache, BruceEvent, ObjectUtils, Geometry, EntityHistoricData, EntityLod, ZoomControl, EntityTag, Tileset, Api, DataLab, EntityCoords, EntitySource, ClientFile, MenuItem, EntityRelation, ProgramKey, Carto, ProjectView, ProjectViewBookmark, Bounds, ProjectViewLegacyTile, Camera, AbstractApi, Session, EntityAttachment, EntityAttachmentType, EntityAttribute, MathUtils } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, Math as Math$1, Cartesian3, JulianDate, Quaternion, Transforms, HeadingPitchRoll, Matrix4, DistanceDisplayCondition, HeightReference, ColorBlendMode, ShadowMode, ClassificationType, Model, HorizontalOrigin, VerticalOrigin, ConstantPositionProperty, PolygonHierarchy, PolylineGraphics, ArcType, CornerType, Cartesian2, SceneTransforms, NearFarScalar, Matrix3, Rectangle, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, IonResource, Cesium3DTileset, OrthographicFrustum, EasingFunction, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, BoundingSphere, GeometryInstance, PolygonPipeline, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
+import { Cartographic, ColorMaterialProperty, Entity, Color, ConstantProperty, CallbackProperty, Primitive, Cesium3DTileFeature, DistanceDisplayCondition, HeightReference, ColorBlendMode, HeadingPitchRoll, Math as Math$1, Transforms, ShadowMode, Cartesian3, ClassificationType, Model, ArcType, CornerType, ConstantPositionProperty, JulianDate, Quaternion, Matrix4, HorizontalOrigin, VerticalOrigin, PolygonHierarchy, PolylineGraphics, Cartesian2, SceneTransforms, Rectangle, NearFarScalar, Matrix3, KmlDataSource, GeoJsonDataSource, SceneMode, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Cesium3DTileset, IonResource, Ion, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, OrthographicFrustum, EasingFunction, EllipsoidGeodesic, sampleTerrainMostDetailed, defined, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, BoundingSphere, GeometryInstance, CesiumInspector, ClockRange, ScreenSpaceEventHandler, ScreenSpaceEventType, Intersect, CzmlDataSource, Fullscreen } from 'cesium';
 
 /**
  * Ensures a number is returned from a given value.
@@ -12852,236 +12852,6 @@ function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
     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 Cartesian2(x, y);
-        try {
-            const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
-            if (intersection) {
-                const point = 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(Math$1.toRadians(center.longitude), Math$1.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(Math$1.toRadians(p1.longitude), Math$1.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(Math$1.toRadians(p2.longitude), Math$1.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 = Math$1.toRadians(heading);
-    const phi1 = Math$1.toRadians(point.latitude);
-    const lambda1 = Math$1.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: Math$1.toDegrees(phi2),
-        longitude: Math$1.toDegrees(lambda2)
-    };
-}
-function offsetPos3d(pos3d, distance, heading) {
-    const carto = Cartographic.fromCartesian(pos3d);
-    const newCarto = offsetPoint({
-        altitude: carto.height,
-        latitude: Math$1.toDegrees(carto.latitude),
-        longitude: Math$1.toDegrees(carto.longitude)
-    }, distance, heading);
-    return 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, Math$1.toDegrees(viewer.camera.heading));
-    }
-    return null;
-}
-var ViewGroundArea;
-(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 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 = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
-                viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
-                viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
-                viewRect.north = Math$1.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
-            }
-            else {
-                viewRect.east = Math$1.toDegrees(cameraPosition.longitude);
-                viewRect.west = Math$1.toDegrees(cameraPosition.longitude);
-                viewRect.south = Math$1.toDegrees(cameraPosition.latitude);
-                viewRect.north = Math$1.toDegrees(cameraPosition.latitude);
-            }
-            center = {
-                altitude: camera.positionCartographic.height,
-                latitude: Math$1.toDegrees(camera.positionCartographic.latitude),
-                longitude: Math$1.toDegrees(camera.positionCartographic.longitude)
-            };
-        }
-        else {
-            const windowPosition = new Cartesian2(viewer.container.clientWidth / 2, viewer.container.clientHeight / 2);
-            const intersection = getGroundCenterOfCameraRay(viewer, windowPosition);
-            let point = null;
-            if (intersection) {
-                point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
-            }
-            if (point) {
-                center = {
-                    altitude: point.height,
-                    latitude: Math$1.toDegrees(point.latitude),
-                    longitude: Math$1.toDegrees(point.longitude)
-                };
-                const viewRectRad = netScanViewForBoundaries(viewer, center);
-                if (viewRectRad) {
-                    viewRect = {};
-                    viewRect.east = Math$1.toDegrees(viewRectRad.east);
-                    viewRect.west = Math$1.toDegrees(viewRectRad.west);
-                    viewRect.south = Math$1.toDegrees(viewRectRad.south);
-                    viewRect.north = Math$1.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;
-})(ViewGroundArea || (ViewGroundArea = {}));
-
 const MAX_AREA_IN_DEGREES$1 = 90;
 const MAX_RETRY_ATTEMPTS = 1;
 const RETRY_DELAY_INCREMENT = 500;
@@ -13101,6 +12871,23 @@ async function delay(milliseconds) {
         }, 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: 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.
@@ -13402,8 +13189,9 @@ var EntityFilterGetter;
                     LogicOperator: "AND",
                     AttributeValue: {
                         AttributePath: "Bruce/Boundaries",
-                        OperandA: ViewGroundArea.ToBboxPolygon(bounds),
-                        Operator: "intersects"
+                        OperandA: createBoundsPolygonGeometry(bounds),
+                        Operator: "intersects",
+                        ValueOption: "CONST"
                     },
                     key: "attribute"
                 }
@@ -15643,6 +15431,236 @@ var DataLabRenderManager;
     DataLabRenderManager.Manager = Manager;
 })(DataLabRenderManager || (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 Cartesian2(x, y);
+        try {
+            const intersection = getAdjustedGroundIntersectionOfCameraRay(viewer, winPos);
+            if (intersection) {
+                const point = 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(Math$1.toRadians(center.longitude), Math$1.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(Math$1.toRadians(p1.longitude), Math$1.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(Math$1.toRadians(p2.longitude), Math$1.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 = Math$1.toRadians(heading);
+    const phi1 = Math$1.toRadians(point.latitude);
+    const lambda1 = Math$1.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: Math$1.toDegrees(phi2),
+        longitude: Math$1.toDegrees(lambda2)
+    };
+}
+function offsetPos3d(pos3d, distance, heading) {
+    const carto = Cartographic.fromCartesian(pos3d);
+    const newCarto = offsetPoint({
+        altitude: carto.height,
+        latitude: Math$1.toDegrees(carto.latitude),
+        longitude: Math$1.toDegrees(carto.longitude)
+    }, distance, heading);
+    return 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, Math$1.toDegrees(viewer.camera.heading));
+    }
+    return null;
+}
+var ViewGroundArea;
+(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 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 = Math$1.toDegrees(Math.max(viewRectRad.east, cameraPosition.longitude));
+                viewRect.west = Math$1.toDegrees(Math.min(viewRectRad.west, cameraPosition.longitude));
+                viewRect.south = Math$1.toDegrees(Math.min(viewRectRad.south, cameraPosition.latitude));
+                viewRect.north = Math$1.toDegrees(Math.max(viewRectRad.north, cameraPosition.latitude));
+            }
+            else {
+                viewRect.east = Math$1.toDegrees(cameraPosition.longitude);
+                viewRect.west = Math$1.toDegrees(cameraPosition.longitude);
+                viewRect.south = Math$1.toDegrees(cameraPosition.latitude);
+                viewRect.north = Math$1.toDegrees(cameraPosition.latitude);
+            }
+            center = {
+                altitude: camera.positionCartographic.height,
+                latitude: Math$1.toDegrees(camera.positionCartographic.latitude),
+                longitude: Math$1.toDegrees(camera.positionCartographic.longitude)
+            };
+        }
+        else {
+            const windowPosition = new Cartesian2(viewer.container.clientWidth / 2, viewer.container.clientHeight / 2);
+            const intersection = getGroundCenterOfCameraRay(viewer, windowPosition);
+            let point = null;
+            if (intersection) {
+                point = Cartographic.fromCartesian(intersection, viewer.scene.globe.ellipsoid);
+            }
+            if (point) {
+                center = {
+                    altitude: point.height,
+                    latitude: Math$1.toDegrees(point.latitude),
+                    longitude: Math$1.toDegrees(point.longitude)
+                };
+                const viewRectRad = netScanViewForBoundaries(viewer, center);
+                if (viewRectRad) {
+                    viewRect = {};
+                    viewRect.east = Math$1.toDegrees(viewRectRad.east);
+                    viewRect.west = Math$1.toDegrees(viewRectRad.west);
+                    viewRect.south = Math$1.toDegrees(viewRectRad.south);
+                    viewRect.north = Math$1.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;
+})(ViewGroundArea || (ViewGroundArea = {}));
+
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
 var ESearchStatus;
@@ -35950,7 +35968,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-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.