bruce-cesium 2.9.4 → 2.9.6

package/dist/bruce-cesium.umd.js

@@ -727,6 +727,212 @@
         DrawingUtils.RaisePos3d = RaisePos3d;
     })(exports.DrawingUtils || (exports.DrawingUtils = {}));
 
+    var CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
+    (function (ViewUtils) {
+        function GatherLegacyMapTiles(params) {
+            var viewer = params.viewer;
+            var collection = viewer.imageryLayers;
+            var tiles = [];
+            for (var i = 0; i < collection.length; i++) {
+                var layer = collection.get(i);
+                if (layer._bName) {
+                    tiles.push({
+                        alpha: layer.alpha,
+                        brightness: layer.brightness,
+                        contrast: layer.contrast,
+                        hue: layer.hue,
+                        saturation: layer.saturation,
+                        gamma: layer.gamma,
+                        title: layer._bName,
+                    });
+                }
+            }
+            return {
+                imagery: tiles.reverse()
+            };
+        }
+        ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
+        function GatherLegacyTerrainTile(params) {
+            var viewer = params.viewer;
+            var enabled = viewer.terrainProvider;
+            if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
+                return {
+                    terrain: enabled._bName
+                };
+            }
+            return {
+                terrain: "flatterrain"
+            };
+        }
+        ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
+        function GatherMapTiles(params) {
+            var viewer = params.viewer;
+            var imagery = viewer.imageryLayers;
+            var tiles = [];
+            var _loop_1 = function (i) {
+                var provider = imagery.get(i);
+                if (provider._bMeta) {
+                    var idCombo_1 = provider._bMeta.accountId + provider._bMeta.tilesetId;
+                    if (!tiles.find(function (x) { return x.accountId + x.tilesetId === idCombo_1; })) {
+                        tiles.push({
+                            accountId: provider._bMeta.accountId,
+                            tilesetId: provider._bMeta.tilesetId,
+                            alpha: provider.alpha,
+                            brightness: provider.brightness,
+                            contrast: provider.contrast,
+                            hue: provider.hue,
+                            saturation: provider.saturation,
+                            gamma: provider.gamma
+                        });
+                    }
+                }
+            };
+            for (var i = 0; i < imagery.length; i++) {
+                _loop_1(i);
+            }
+            return {
+                imagery: tiles
+            };
+        }
+        ViewUtils.GatherMapTiles = GatherMapTiles;
+        function GatherTerrainTile(params) {
+            var viewer = params.viewer;
+            var provider = viewer.terrainProvider;
+            if (provider._bMeta) {
+                return {
+                    terrain: {
+                        accountId: provider._bMeta.accountId,
+                        tilesetId: provider._bMeta.tilesetId,
+                    }
+                };
+            }
+            else if (provider instanceof Cesium.EllipsoidTerrainProvider) {
+                return {
+                    terrain: {
+                        tilesetId: bruceModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
+                        accountId: null
+                    }
+                };
+            }
+            return null;
+        }
+        ViewUtils.GatherTerrainTile = GatherTerrainTile;
+        function SetTerrainWireframeStatus(params) {
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                var InspectorClass = Cesium.CesiumInspector;
+                if (InspectorClass) {
+                    var inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
+                    inspector.container.style.display = "none";
+                    params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
+                    params.viewer.scene.requestRender();
+                }
+            }
+            if (params.viewer[CESIUM_INSPECTOR_KEY]) {
+                params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
+            }
+        }
+        ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
+        function GetTerrainWireframeStatus(params) {
+            var _a, _b;
+            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
+                return false;
+            }
+            return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
+        }
+        ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
+        /**
+         * Changes between perspective and orthographic view.
+         * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
+         * @param params
+         */
+        function Set2dStatus(params) {
+            var viewer = params.viewer, is2d = params.status, moveCamera = params.moveCamera;
+            var curLens2d = viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
+            if (curLens2d && !is2d) {
+                viewer.camera.switchToPerspectiveFrustum();
+                viewer.scene.screenSpaceCameraController.enableTilt = true;
+                viewer.scene.requestRender();
+            }
+            else if (!curLens2d && is2d) {
+                viewer.camera.switchToOrthographicFrustum();
+                viewer.scene.screenSpaceCameraController.enableTilt = false;
+                if (moveCamera != false) {
+                    try {
+                        // Face camera downwards to make it look 2d.
+                        // We want to try make it look at the center-point of the current view.
+                        // If center cannot be calculated then we'll simply raise the camera and face it downwards.
+                        var scene = viewer.scene;
+                        var windowPosition = new Cesium.Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
+                        var ray = viewer.camera.getPickRay(windowPosition);
+                        var intersection = scene.globe.pick(ray, scene);
+                        var center = void 0;
+                        if (Cesium.defined(intersection)) {
+                            center = Cesium.Cartographic.fromCartesian(intersection);
+                        }
+                        // Use current camera position if we can't calculate the center.
+                        else {
+                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
+                            center.height = 0;
+                        }
+                        center.height = viewer.camera.positionCartographic.height + 100;
+                        viewer.camera.setView({
+                            destination: Cesium.Cartographic.toCartesian(center),
+                            orientation: {
+                                heading: 0.0,
+                                pitch: Cesium.Math.toRadians(-90.0),
+                                roll: 0.0
+                            }
+                        });
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                viewer.scene.requestRender();
+            }
+        }
+        ViewUtils.Set2dStatus = Set2dStatus;
+        function Get2dStatus(params) {
+            var viewer = params.viewer;
+            return viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
+        }
+        ViewUtils.Get2dStatus = Get2dStatus;
+        function SetLockedCameraStatus(params) {
+            var viewer = params.viewer, status = params.status;
+            var scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
+            if (!scene) {
+                return;
+            }
+            if (status) {
+                scene.screenSpaceCameraController.enableInputs = false;
+                scene.screenSpaceCameraController.enableTranslate = false;
+                scene.screenSpaceCameraController.enableZoom = false;
+                scene.screenSpaceCameraController.enableRotate = false;
+                scene.screenSpaceCameraController.enableTilt = false;
+            }
+            else {
+                scene.screenSpaceCameraController.enableInputs = true;
+                scene.screenSpaceCameraController.enableTranslate = true;
+                scene.screenSpaceCameraController.enableZoom = true;
+                scene.screenSpaceCameraController.enableRotate = true;
+                if (!ViewUtils.Get2dStatus({ viewer: viewer })) {
+                    scene.screenSpaceCameraController.enableTilt = true;
+                }
+            }
+            viewer.scene.requestRender();
+        }
+        ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
+        function GetLockedCameraStatus(params) {
+            var _a;
+            var scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
+            if (!scene) {
+                return false;
+            }
+            return !scene.screenSpaceCameraController.enableTranslate;
+        }
+        ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
+    })(exports.ViewUtils || (exports.ViewUtils = {}));
+
     /**
      * Returns if a given visual is alive and in the scene.
      * @param viewer
@@ -890,10 +1096,522 @@
         return obj;
     }
     (function (EntityUtils) {
+        /**
+         * Returns the location for given entity or entities.
+         * If available it will also compute a rectangle.
+         * It is recommended to fly-to a rectangle if available as it will ensure the full geometry is in view.
+         * @param params
+         */
+        function GetLocation(params) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var api, viewer, samples, visualRegister, minimumAlt, paddingAlt, MAX_DISTANCE_BETWEEN_SAMPLES, MAX_TERRAIN_SAMPLES, terrainSamples, MAX_API_CALLS, apiCalls, MAX_VALID_SAMPLES, validSamples, MIN_RECT_DIAGONAL_LENGTH, data, processPosHeight, ensureHeightRefs, getEntityPositions, allPosses, i, sample, samplePosses, valid, j, samplePos, k, allPos, distance, rect, factor, marginX, marginY, diagonalLen, terrData, posCarto, height, MIN_POSSES_LEN;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            api = params.api, viewer = params.viewer, samples = params.samples, visualRegister = params.visualRegister, minimumAlt = params.minimumAlt, paddingAlt = params.paddingAlt;
+                            if (!paddingAlt) {
+                                paddingAlt = 0;
+                            }
+                            MAX_DISTANCE_BETWEEN_SAMPLES = 5000;
+                            MAX_TERRAIN_SAMPLES = 25;
+                            terrainSamples = 0;
+                            MAX_API_CALLS = 10;
+                            apiCalls = 0;
+                            MAX_VALID_SAMPLES = 20;
+                            validSamples = 0;
+                            MIN_RECT_DIAGONAL_LENGTH = isNaN(minimumAlt) || minimumAlt == null ? 0 : minimumAlt * 10;
+                            if (MIN_RECT_DIAGONAL_LENGTH < 1500) {
+                                MIN_RECT_DIAGONAL_LENGTH = 1500;
+                            }
+                            data = {
+                                pos3d: null,
+                                rectangle: null
+                            };
+                            processPosHeight = function (pos3d, heightRef) { return __awaiter(_this, void 0, void 0, function () {
+                                var carto, baseHeight, terrData, height, carto;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            if (!(!isNaN(minimumAlt) && minimumAlt != null)) return [3 /*break*/, 5];
+                                            carto = Cesium.Cartographic.fromCartesian(pos3d);
+                                            if (!(carto === null || carto === void 0 ? void 0 : carto.latitude)) return [3 /*break*/, 4];
+                                            baseHeight = 0;
+                                            if (!(heightRef == null || heightRef == Cesium.HeightReference.RELATIVE_TO_GROUND || heightRef == Cesium.HeightReference.NONE)) return [3 /*break*/, 3];
+                                            if (!(terrainSamples > MAX_TERRAIN_SAMPLES)) return [3 /*break*/, 1];
+                                            baseHeight = viewer.scene.globe.getHeight(carto);
+                                            return [3 /*break*/, 3];
+                                        case 1: return [4 /*yield*/, exports.DrawingUtils.GetTerrainHeight({
+                                                pos3d: pos3d,
+                                                viewer: viewer
+                                            })];
+                                        case 2:
+                                            terrData = _a.sent();
+                                            baseHeight = terrData === null || terrData === void 0 ? void 0 : terrData.height;
+                                            terrainSamples += 1;
+                                            _a.label = 3;
+                                        case 3:
+                                            if (baseHeight != undefined && !isNaN(baseHeight)) {
+                                                height = baseHeight + minimumAlt;
+                                                if (height > carto.height) {
+                                                    carto.height = height;
+                                                }
+                                                return [2 /*return*/, Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + paddingAlt)];
+                                            }
+                                            _a.label = 4;
+                                        case 4: return [3 /*break*/, 6];
+                                        case 5:
+                                            if (paddingAlt) {
+                                                carto = Cesium.Cartographic.fromCartesian(pos3d);
+                                                if (carto === null || carto === void 0 ? void 0 : carto.latitude) {
+                                                    return [2 /*return*/, Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height + paddingAlt)];
+                                                }
+                                            }
+                                            _a.label = 6;
+                                        case 6: return [2 /*return*/, pos3d];
+                                    }
+                                });
+                            }); };
+                            ensureHeightRefs = function (posses, sample) { return __awaiter(_this, void 0, void 0, function () {
+                                var heightRef, returnHeightRef, i, _a, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            if (!(posses === null || posses === void 0 ? void 0 : posses.length)) return [3 /*break*/, 4];
+                                            heightRef = sample.heightRef;
+                                            returnHeightRef = sample.returnHeightRef;
+                                            i = 0;
+                                            _c.label = 1;
+                                        case 1:
+                                            if (!(i < posses.length)) return [3 /*break*/, 4];
+                                            if (heightRef != null && returnHeightRef != null && heightRef != returnHeightRef) {
+                                                posses[i] = exports.DrawingUtils.EnsurePosHeight({
+                                                    desiredHeightRef: returnHeightRef,
+                                                    heightRef: heightRef,
+                                                    pos3d: posses[i],
+                                                    viewer: viewer
+                                                });
+                                            }
+                                            _a = posses;
+                                            _b = i;
+                                            return [4 /*yield*/, processPosHeight(posses[i], returnHeightRef)];
+                                        case 2:
+                                            _a[_b] = _c.sent();
+                                            _c.label = 3;
+                                        case 3:
+                                            i++;
+                                            return [3 /*break*/, 1];
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            }); };
+                            getEntityPositions = function (sample) { return __awaiter(_this, void 0, void 0, function () {
+                                var entityId, entity, tileset, tilesetId, lat, lon, e_1, e_2, evaluateRendered, evaluateRecord, renderedPosses, recordPosses, tSettings, pos3d, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
+                                var _this = this;
+                                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                                return __generator(this, function (_o) {
+                                    switch (_o.label) {
+                                        case 0:
+                                            entityId = sample.entityId, entity = sample.entity, tileset = sample.tileset, tilesetId = sample.tilesetId;
+                                            if (!!entity) return [3 /*break*/, 9];
+                                            lat = 0;
+                                            lon = 0;
+                                            if (!(apiCalls < MAX_API_CALLS)) return [3 /*break*/, 9];
+                                            // Counting this whole area as a single call because it has a single purpose.
+                                            apiCalls += 1;
+                                            _o.label = 1;
+                                        case 1:
+                                            _o.trys.push([1, 3, , 4]);
+                                            return [4 /*yield*/, bruceModels.Entity.Get({
+                                                    api: api,
+                                                    entityId: entityId,
+                                                    expandLocation: false
+                                                })];
+                                        case 2:
+                                            entity = (_o.sent()).entity;
+                                            lat = +((_a = entity === null || entity === void 0 ? void 0 : entity.location) === null || _a === void 0 ? void 0 : _a.latitude);
+                                            lon = +((_b = entity === null || entity === void 0 ? void 0 : entity.location) === null || _b === void 0 ? void 0 : _b.longitude);
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            e_1 = _o.sent();
+                                            console.error(e_1);
+                                            return [3 /*break*/, 4];
+                                        case 4:
+                                            if (!(entity && (isNaN(lat) || isNaN(lon) || (lat == 0 && lon == 0)))) return [3 /*break*/, 9];
+                                            _o.label = 5;
+                                        case 5:
+                                            _o.trys.push([5, 7, , 9]);
+                                            return [4 /*yield*/, bruceModels.Entity.Get({
+                                                    api: api,
+                                                    entityId: entityId,
+                                                    expandLocation: true
+                                                })];
+                                        case 6:
+                                            entity = (_o.sent()).entity;
+                                            return [3 /*break*/, 9];
+                                        case 7:
+                                            e_2 = _o.sent();
+                                            console.warn(e_2);
+                                            return [4 /*yield*/, bruceModels.Entity.Get({
+                                                    api: api,
+                                                    entityId: entityId,
+                                                    expandLocation: false
+                                                })];
+                                        case 8:
+                                            entity = (_o.sent()).entity;
+                                            return [3 /*break*/, 9];
+                                        case 9:
+                                            if (!entity) {
+                                                return [2 /*return*/, []];
+                                            }
+                                            if (!tilesetId) {
+                                                tilesetId = ((_c = entity.tilesetID) === null || _c === void 0 ? void 0 : _c.length) ? entity.tilesetID[0] : tilesetId;
+                                            }
+                                            evaluateRendered = function () { return __awaiter(_this, void 0, void 0, function () {
+                                                var rego, posses, visual, visualHeightRef, hierarchy, hPosses, hPossesSample, step, i, pPosses, pPossesSample, step, i, pPosses, pPossesSample, step, i, pos3d_1;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            rego = visualRegister ? visualRegister.GetRego({
+                                                                entityId: entity.Bruce.ID,
+                                                            }) : null;
+                                                            posses = [];
+                                                            if (!((rego === null || rego === void 0 ? void 0 : rego.visual) instanceof Cesium.Entity)) return [3 /*break*/, 14];
+                                                            visual = rego.visual;
+                                                            visualHeightRef = Cesium.HeightReference.RELATIVE_TO_GROUND;
+                                                            if (!visual.model) return [3 /*break*/, 1];
+                                                            visualHeightRef = GetValue(viewer, visual.model.heightReference);
+                                                            return [3 /*break*/, 12];
+                                                        case 1:
+                                                            if (!visual.polygon) return [3 /*break*/, 4];
+                                                            visualHeightRef = GetValue(viewer, visual.polygon.heightReference);
+                                                            hierarchy = GetValue(viewer, visual.polygon.hierarchy);
+                                                            if (!(hierarchy === null || hierarchy === void 0 ? void 0 : hierarchy.positions)) return [3 /*break*/, 3];
+                                                            hPosses = hierarchy.positions.map(function (x) { return x.clone ? x.clone() : x; });
+                                                            hPossesSample = [];
+                                                            step = Math.floor(hPosses.length / 5);
+                                                            for (i = 0; i < hPosses.length; i += step) {
+                                                                hPossesSample.push(hPosses[i]);
+                                                            }
+                                                            return [4 /*yield*/, ensureHeightRefs(hPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                        case 2:
+                                                            _a.sent();
+                                                            posses = posses.concat(hPossesSample);
+                                                            _a.label = 3;
+                                                        case 3: return [3 /*break*/, 12];
+                                                        case 4:
+                                                            if (!visual.polyline) return [3 /*break*/, 7];
+                                                            visualHeightRef = GetValue(viewer, visual.polyline.clampToGround) ?
+                                                                Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE;
+                                                            pPosses = GetValue(viewer, visual.polyline.positions);
+                                                            if (!(pPosses === null || pPosses === void 0 ? void 0 : pPosses.length)) return [3 /*break*/, 6];
+                                                            // Grab 5 positions from the polyline at varied indexes.
+                                                            pPosses = pPosses.map(function (x) { return x.clone ? x.clone() : x; });
+                                                            pPossesSample = [];
+                                                            step = Math.floor(pPosses.length / 5);
+                                                            for (i = 0; i < pPosses.length; i += step) {
+                                                                pPossesSample.push(pPosses[i]);
+                                                            }
+                                                            return [4 /*yield*/, ensureHeightRefs(pPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                        case 5:
+                                                            _a.sent();
+                                                            posses = posses.concat(pPossesSample);
+                                                            _a.label = 6;
+                                                        case 6: return [3 /*break*/, 12];
+                                                        case 7:
+                                                            if (!visual.billboard) return [3 /*break*/, 8];
+                                                            visualHeightRef = GetValue(viewer, visual.billboard.heightReference);
+                                                            return [3 /*break*/, 12];
+                                                        case 8:
+                                                            if (!visual.corridor) return [3 /*break*/, 11];
+                                                            visualHeightRef = GetValue(viewer, visual.corridor.heightReference);
+                                                            pPosses = GetValue(viewer, visual.corridor.positions);
+                                                            if (!(pPosses === null || pPosses === void 0 ? void 0 : pPosses.length)) return [3 /*break*/, 10];
+                                                            // Grab 5 positions from the corridor at varied indexes.
+                                                            pPosses = pPosses.map(function (x) { return x.clone ? x.clone() : x; });
+                                                            pPossesSample = [];
+                                                            step = Math.floor(pPosses.length / 5);
+                                                            for (i = 0; i < pPosses.length; i += step) {
+                                                                pPossesSample.push(pPosses[i]);
+                                                            }
+                                                            return [4 /*yield*/, ensureHeightRefs(pPossesSample, __assign(__assign({}, sample), { heightRef: visualHeightRef }))];
+                                                        case 9:
+                                                            _a.sent();
+                                                            posses = posses.concat(pPossesSample);
+                                                            _a.label = 10;
+                                                        case 10: return [3 /*break*/, 12];
+                                                        case 11:
+                                                            if (visual.ellipse) {
+                                                                visualHeightRef = GetValue(viewer, visual.ellipse.heightReference);
+                                                            }
+                                                            else if (visual.point) {
+                                                                visualHeightRef = GetValue(viewer, visual.point.heightReference);
+                                                            }
+                                                            _a.label = 12;
+                                                        case 12:
+                                                            pos3d_1 = GetValue(viewer, visual.position);
+                                                            if (!(pos3d_1 === null || pos3d_1 === void 0 ? void 0 : pos3d_1.x)) return [3 /*break*/, 14];
+                                                            pos3d_1 = exports.DrawingUtils.EnsurePosHeight({
+                                                                desiredHeightRef: sample.returnHeightRef,
+                                                                heightRef: visualHeightRef,
+                                                                pos3d: pos3d_1,
+                                                                viewer: viewer
+                                                            });
+                                                            return [4 /*yield*/, processPosHeight(pos3d_1, sample.returnHeightRef)];
+                                                        case 13:
+                                                            pos3d_1 = _a.sent();
+                                                            posses.push(pos3d_1);
+                                                            _a.label = 14;
+                                                        case 14: return [2 /*return*/, posses];
+                                                    }
+                                                });
+                                            }); };
+                                            evaluateRecord = function () { return __awaiter(_this, void 0, void 0, function () {
+                                                var posses, location_1, latitude, longitude, pos3d_2, pointStr, points, point, pos3d_3, lineStr, points, pPosses, pRings, boundary, points, pPosses, point, bPosses;
+                                                return __generator(this, function (_a) {
+                                                    switch (_a.label) {
+                                                        case 0:
+                                                            posses = [];
+                                                            if (entity.location && bruceModels.Carto.ValidateCarto(entity.location)) {
+                                                                location_1 = entity.location;
+                                                                latitude = EnsureNumber(location_1.latitude);
+                                                                longitude = EnsureNumber(location_1.longitude);
+                                                                // Disallowing exact 0.
+                                                                if (latitude || longitude) {
+                                                                    pos3d_2 = Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_1.altitude));
+                                                                    posses.push(pos3d_2);
+                                                                }
+                                                            }
+                                                            if (!(entity.geometry && typeof entity.geometry == "object")) return [3 /*break*/, 4];
+                                                            pointStr = entity.geometry.Point;
+                                                            if (pointStr && typeof pointStr == "string") {
+                                                                points = bruceModels.Geometry.ParsePoints(pointStr);
+                                                                point = points.length > 0 ? points[0] : null;
+                                                                if (point && bruceModels.Carto.ValidateCarto(point)) {
+                                                                    pos3d_3 = Cesium.Cartesian3.fromDegrees(EnsureNumber(point.longitude), EnsureNumber(point.latitude), EnsureNumber(point.altitude));
+                                                                    posses.push(pos3d_3);
+                                                                }
+                                                            }
+                                                            lineStr = entity.geometry.LineString;
+                                                            if (!(lineStr && typeof lineStr == "string")) return [3 /*break*/, 2];
+                                                            points = bruceModels.Geometry.ParsePoints(lineStr);
+                                                            if (!(points.length > 0)) return [3 /*break*/, 2];
+                                                            pPosses = points.map(function (x) { return Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)); });
+                                                            return [4 /*yield*/, ensureHeightRefs(pPosses, sample)];
+                                                        case 1:
+                                                            _a.sent();
+                                                            posses = posses.concat(pPosses);
+                                                            _a.label = 2;
+                                                        case 2:
+                                                            pRings = entity.geometry.Polygon;
+                                                            if (!(pRings && typeof pRings == "object")) return [3 /*break*/, 4];
+                                                            boundary = pRings.find(function (x) { return x.Facing == bruceModels.Geometry.EPolygonRingType.Boundaries; });
+                                                            if (!(boundary === null || boundary === void 0 ? void 0 : boundary.LinearRing)) return [3 /*break*/, 4];
+                                                            points = bruceModels.Geometry.ParsePoints(boundary.LinearRing);
+                                                            pPosses = points.map(function (x) { return Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(x.altitude)); });
+                                                            return [4 /*yield*/, ensureHeightRefs(pPosses, sample)];
+                                                        case 3:
+                                                            _a.sent();
+                                                            posses = posses.concat(pPosses);
+                                                            _a.label = 4;
+                                                        case 4:
+                                                            if (!entity.boundaries) return [3 /*break*/, 6];
+                                                            point = {
+                                                                latitude: (EnsureNumber(entity.boundaries.minLatitude) + EnsureNumber(entity.boundaries.maxLatitude)) / 2,
+                                                                longitude: (EnsureNumber(entity.boundaries.minLongitude) + EnsureNumber(entity.boundaries.maxLongitude)) / 2,
+                                                                altitude: 0
+                                                            };
+                                                            if (!(point.latitude || point.longitude)) return [3 /*break*/, 6];
+                                                            bPosses = [
+                                                                Cesium.Cartesian3.fromDegrees(EnsureNumber(entity.boundaries.minLongitude), EnsureNumber(entity.boundaries.minLatitude), EnsureNumber(entity.boundaries.minAltitude)),
+                                                                Cesium.Cartesian3.fromDegrees(EnsureNumber(entity.boundaries.maxLongitude), EnsureNumber(entity.boundaries.maxLatitude), EnsureNumber(entity.boundaries.maxAltitude))
+                                                            ];
+                                                            return [4 /*yield*/, ensureHeightRefs(bPosses, sample)];
+                                                        case 5:
+                                                            _a.sent();
+                                                            posses = posses.concat(bPosses);
+                                                            _a.label = 6;
+                                                        case 6: return [2 /*return*/, posses];
+                                                    }
+                                                });
+                                            }); };
+                                            return [4 /*yield*/, evaluateRendered()];
+                                        case 10:
+                                            renderedPosses = _o.sent();
+                                            if (renderedPosses === null || renderedPosses === void 0 ? void 0 : renderedPosses.length) {
+                                                return [2 /*return*/, renderedPosses];
+                                            }
+                                            return [4 /*yield*/, evaluateRecord()];
+                                        case 11:
+                                            recordPosses = _o.sent();
+                                            if (recordPosses === null || recordPosses === void 0 ? void 0 : recordPosses.length) {
+                                                return [2 /*return*/, recordPosses];
+                                            }
+                                            if (!!tileset) return [3 /*break*/, 13];
+                                            if (!(tilesetId && apiCalls < MAX_API_CALLS)) return [3 /*break*/, 13];
+                                            apiCalls += 1;
+                                            return [4 /*yield*/, bruceModels.Tileset.Get({
+                                                    api: api,
+                                                    tilesetId: tilesetId
+                                                })];
+                                        case 12:
+                                            tileset = (_o.sent()).tileset;
+                                            _o.label = 13;
+                                        case 13:
+                                            tSettings = tileset === null || tileset === void 0 ? void 0 : tileset.settings;
+                                            pos3d = null;
+                                            if (!(((_d = entity.location) === null || _d === void 0 ? void 0 : _d.longitude) || ((_e = tSettings === null || tSettings === void 0 ? void 0 : tSettings.location) === null || _e === void 0 ? void 0 : _e.longitude))) return [3 /*break*/, 15];
+                                            if ((_f = entity === null || entity === void 0 ? void 0 : entity.location) === null || _f === void 0 ? void 0 : _f.longitude) {
+                                                alt = +entity.location.altitude;
+                                                if (isNaN(alt)) {
+                                                    alt = 0;
+                                                }
+                                                pos3d = Cesium.Cartesian3.fromDegrees(+entity.location.longitude, +entity.location.latitude, alt);
+                                            }
+                                            else {
+                                                alt = +tSettings.location.altitude;
+                                                if (isNaN(alt)) {
+                                                    alt = 0;
+                                                }
+                                                pos3d = Cesium.Cartesian3.fromDegrees(+tSettings.location.longitude, +tSettings.location.latitude, alt);
+                                            }
+                                            if (!(entity === null || entity === void 0 ? void 0 : entity.worldPosition)) return [3 /*break*/, 15];
+                                            heading = 0;
+                                            pitch = 0;
+                                            roll = 0;
+                                            if ((_g = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _g === void 0 ? void 0 : _g.heading) {
+                                                heading = entity.transform.heading;
+                                            }
+                                            else if ((_h = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _h === void 0 ? void 0 : _h.heading) {
+                                                heading = tSettings.transform.heading;
+                                            }
+                                            if ((_j = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _j === void 0 ? void 0 : _j.pitch) {
+                                                pitch = entity.transform.pitch;
+                                            }
+                                            else if ((_k = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _k === void 0 ? void 0 : _k.pitch) {
+                                                pitch = tSettings.transform.pitch;
+                                            }
+                                            if ((_l = entity === null || entity === void 0 ? void 0 : entity.transform) === null || _l === void 0 ? void 0 : _l.roll) {
+                                                roll = entity.transform.roll;
+                                            }
+                                            else if ((_m = tSettings === null || tSettings === void 0 ? void 0 : tSettings.transform) === null || _m === void 0 ? void 0 : _m.roll) {
+                                                roll = tSettings.transform.roll;
+                                            }
+                                            heading = +heading;
+                                            if (isNaN(heading)) {
+                                                heading = 0;
+                                            }
+                                            pitch = +pitch;
+                                            if (isNaN(pitch)) {
+                                                pitch = 0;
+                                            }
+                                            roll = +roll;
+                                            if (isNaN(roll)) {
+                                                roll = 0;
+                                            }
+                                            matrix4 = entity.worldPosition;
+                                            offset = new Cesium.Cartesian3(+matrix4[0][3], +matrix4[1][3], +matrix4[2][3]);
+                                            if (entity.worldPivot) //the position from worldMatrix + center of geometry offset
+                                             {
+                                                offset = new Cesium.Cartesian3(entity.worldPivot[0], entity.worldPivot[1], entity.worldPivot[2]);
+                                            }
+                                            m1 = Cesium.Transforms.eastNorthUpToFixedFrame(pos3d);
+                                            hpr = Cesium.HeadingPitchRoll.fromDegrees(heading, pitch, roll, new Cesium.HeadingPitchRoll());
+                                            transform = Cesium.Matrix3.fromHeadingPitchRoll(hpr);
+                                            transformedOffset = Cesium.Matrix3.multiplyByVector(transform, offset, new Cesium.Cartesian3());
+                                            pos3d = Cesium.Matrix4.multiplyByPoint(m1, transformedOffset, new Cesium.Cartesian3());
+                                            if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) return [3 /*break*/, 15];
+                                            return [4 /*yield*/, processPosHeight(pos3d, Cesium.HeightReference.NONE)];
+                                        case 14:
+                                            pos3d = _o.sent();
+                                            _o.label = 15;
+                                        case 15:
+                                            if (pos3d) {
+                                                return [2 /*return*/, [pos3d]];
+                                            }
+                                            return [2 /*return*/, []];
+                                    }
+                                });
+                            }); };
+                            allPosses = [];
+                            i = 0;
+                            _b.label = 1;
+                        case 1:
+                            if (!(i < samples.length)) return [3 /*break*/, 4];
+                            sample = samples[i];
+                            return [4 /*yield*/, getEntityPositions(sample)];
+                        case 2:
+                            samplePosses = _b.sent();
+                            if (samplePosses === null || samplePosses === void 0 ? void 0 : samplePosses.length) {
+                                valid = !(allPosses === null || allPosses === void 0 ? void 0 : allPosses.length);
+                                if (!valid) {
+                                    for (j = 0; j < samplePosses.length; j++) {
+                                        samplePos = samplePosses[j];
+                                        for (k = 0; k < allPosses.length; k++) {
+                                            allPos = allPosses[k];
+                                            distance = Cesium.Cartesian3.distance(samplePos, allPos);
+                                            if (distance < MAX_DISTANCE_BETWEEN_SAMPLES) {
+                                                valid = true;
+                                                break;
+                                            }
+                                        }
+                                        if (valid) {
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (valid) {
+                                    allPosses = allPosses.concat(samplePosses);
+                                    validSamples += 1;
+                                    if (validSamples >= MAX_VALID_SAMPLES) {
+                                        return [3 /*break*/, 4];
+                                    }
+                                }
+                            }
+                            _b.label = 3;
+                        case 3:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 4:
+                            if (allPosses.length > 1) {
+                                rect = allPosses.length == 1 ? null : Cesium.Rectangle.fromCartesianArray(allPosses);
+                                factor = 0.1;
+                                marginX = rect.width * factor / 2;
+                                marginY = rect.height * factor / 2;
+                                rect.east += marginX;
+                                rect.west -= marginX;
+                                rect.north += marginY;
+                                rect.south -= marginY;
+                                diagonalLen = Cesium.Cartesian3.distance(Cesium.Cartesian3.fromRadians(rect.west, rect.north), Cesium.Cartesian3.fromRadians(rect.east, rect.south));
+                                terrData = exports.ViewUtils.GatherTerrainTile({
+                                    viewer: viewer
+                                });
+                                if (((_a = terrData === null || terrData === void 0 ? void 0 : terrData.terrain) === null || _a === void 0 ? void 0 : _a.tilesetId) == bruceModels.ProjectViewTile.EDefaultTerrain.FlatTerrain) {
+                                    MIN_RECT_DIAGONAL_LENGTH = 0;
+                                }
+                                posCarto = Cesium.Cartographic.fromCartesian(allPosses[0]);
+                                height = posCarto.height + (diagonalLen * 1.5);
+                                data.pos3d = Cesium.Cartesian3.fromRadians(posCarto.longitude, posCarto.latitude, height);
+                                MIN_POSSES_LEN = 10;
+                                if (diagonalLen >= MIN_RECT_DIAGONAL_LENGTH && allPosses.length >= MIN_POSSES_LEN) {
+                                    data.rectangle = rect;
+                                }
+                            }
+                            else if (allPosses.length == 1) {
+                                data.pos3d = allPosses[0];
+                            }
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        }
+        EntityUtils.GetLocation = GetLocation;
         /**
          * Returns an entity's position.
          * This will attempt to calculate it from multiple sources of data.
          * @param params
+         * @deprecated use GetLocation instead.
          * @returns
          */
         function GetPos(params) {
@@ -905,9 +1623,9 @@
                 if ((rego === null || rego === void 0 ? void 0 : rego.visual) instanceof Cesium.Entity) {
                     var visual = rego.visual;
                     if (visual.position) {
-                        var pos3d_1 = GetValue(viewer, visual.position);
+                        var pos3d_4 = GetValue(viewer, visual.position);
                         // Fix height reference.
-                        if (pos3d_1 === null || pos3d_1 === void 0 ? void 0 : pos3d_1.x) {
+                        if (pos3d_4 === null || pos3d_4 === void 0 ? void 0 : pos3d_4.x) {
                             var visualHeightRef = Cesium.HeightReference.RELATIVE_TO_GROUND;
                             if (visual.model) {
                                 visualHeightRef = GetValue(viewer, visual.model.heightReference);
@@ -934,7 +1652,7 @@
                             return exports.DrawingUtils.EnsurePosHeight({
                                 desiredHeightRef: params.returnHeightRef,
                                 heightRef: visualHeightRef,
-                                pos3d: pos3d_1,
+                                pos3d: pos3d_4,
                                 viewer: viewer
                             });
                         }
@@ -944,12 +1662,12 @@
             }
             function evaluateRecord() {
                 if (entity.location && bruceModels.Carto.ValidateCarto(entity.location)) {
-                    var location_1 = entity.location;
-                    var latitude = EnsureNumber(location_1.latitude);
-                    var longitude = EnsureNumber(location_1.longitude);
+                    var location_2 = entity.location;
+                    var latitude = EnsureNumber(location_2.latitude);
+                    var longitude = EnsureNumber(location_2.longitude);
                     // Disallowing exact 0.
                     if (latitude || longitude) {
-                        return Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_1.altitude));
+                        return Cesium.Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_2.altitude));
                     }
                 }
                 if (entity.geometry && typeof entity.geometry == "object") {
@@ -1027,12 +1745,13 @@
          * Returns the position of the entity.
          * This is an async variant that checks for related tilesets.
          * @param params
+         * @deprecated use GetLocation instead.
          * @returns
          */
         function GetPosAsync(params) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
             return __awaiter(this, void 0, void 0, function () {
-                var viewer, entityId, entity, tileset, tilesetId, visualRegister, returnHeightRef, recordHeightRef, api, lat, lon, e_1, e_2, pos3d, tSettings, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
+                var viewer, entityId, entity, tileset, tilesetId, visualRegister, returnHeightRef, recordHeightRef, api, lat, lon, e_3, e_4, pos3d, tSettings, alt, alt, heading, pitch, roll, matrix4, offset, m1, hpr, transform, transformedOffset;
                 return __generator(this, function (_o) {
                     switch (_o.label) {
                         case 0:
@@ -1054,8 +1773,8 @@
                             lon = +((_b = entity === null || entity === void 0 ? void 0 : entity.location) === null || _b === void 0 ? void 0 : _b.longitude);
                             return [3 /*break*/, 4];
                         case 3:
-                            e_1 = _o.sent();
-                            console.error(e_1);
+                            e_3 = _o.sent();
+                            console.error(e_3);
                             return [3 /*break*/, 4];
                         case 4:
                             if (!(entity && (isNaN(lat) || isNaN(lon) || (lat == 0 && lon == 0)))) return [3 /*break*/, 9];
@@ -1071,8 +1790,8 @@
                             entity = (_o.sent()).entity;
                             return [3 /*break*/, 9];
                         case 7:
-                            e_2 = _o.sent();
-                            console.warn(e_2);
+                            e_4 = _o.sent();
+                            console.warn(e_4);
                             return [4 /*yield*/, bruceModels.Entity.Get({
                                     api: api,
                                     entityId: entityId,
@@ -1189,105 +1908,122 @@
          */
         function GatherEntity(params) {
             var entity = params.entity;
-            if (entity instanceof Cesium.Entity) {
-                var cEntity = entity;
-                var items = [];
-                traverseEntity(cEntity, items, false);
-                return items;
-            }
-            return [entity];
-        }
-        EntityUtils.GatherEntity = GatherEntity;
-        /**
-         * Looks at given entities with least amount of movement.
-         * @param viewer
-         * @param entities
-         */
-        function LookAtEntities(params) {
-            var viewer = params.viewer, entities = params.entities;
-            // Removing cesium tileset features for now as it's not accurate.
-            entities = [].concat(entities).filter(function (x) { return !(x instanceof Cesium.Cesium3DTileFeature); });
-            if (!entities.length) {
-                return;
-            }
-            var _a = [Cesium.Rectangle, Cesium.Cartographic, Cesium.Cartesian3, Cesium.Matrix3, Cesium.Matrix4, Cesium.EasingFunction], C3 = _a[2], M4 = _a[4];
-            var cutoffDistance = 2000;
-            var hoverHeight = 2000;
-            var duration = 0.5;
-            var centers = function (p) {
-                var PM = p.modelMatrix;
-                var instances = (function (i) { return (i instanceof Cesium.GeometryInstance ? [i] : i); })(p.geometryInstances);
-                return instances.map(function (g) {
-                    var _M = M4.multiply(PM, g.modelMatrix, new M4);
-                    var G = g.geometry;
-                    var _p = G.attributes.position;
-                    var b = G.boundingSphere;
-                    return [b.center, b.radius];
-                });
-            };
-            var currentTime = Cesium.JulianDate.now();
-            var target = entities.flatMap(function (e) {
-                var _a;
-                if (e instanceof Cesium.Cartesian3) {
-                    return [[e, 0]];
-                }
-                if (e instanceof Cesium.Entity) {
-                    return [[(_a = e.position) === null || _a === void 0 ? void 0 : _a.getValue(currentTime), 0]];
-                }
-                if (e instanceof Cesium.Primitive) {
-                    return centers(e);
-                }
-                if (e instanceof Cesium.Cesium3DTileFeature) {
-                    var s = e.tileset.boundingSphere;
-                    return [[s.center, s.radius]];
-                }
-            });
-            var bounds = function (list) {
-                var min = list[0][0];
-                var max = min;
-                for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
-                    var _a = list_1[_i], p_1 = _a[0], r = _a[1];
-                    var pMin = C3.subtract(p_1, new C3(r), new C3);
-                    var pMax = C3.add(p_1, new C3(r), new C3);
-                    min = C3.minimumByComponent(pMin, min, new C3);
-                    max = C3.maximumByComponent(pMax, max, new C3);
-                }
-                var c = C3.multiplyByScalar(C3.add(max, min, new C3), 0.5, new C3);
-                return c;
-            };
-            var center = bounds(target);
-            var orient = function (p) {
-                var d = C3.subtract(center, p, new C3);
-                var dir = C3.normalize(d, new C3);
-                var up = viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(center);
-                return [p, dir, up];
-            };
-            var shorten = function (v, l) {
-                var c = l / C3.magnitude(v);
-                return C3.multiplyByScalar(v, c, new C3);
-            };
-            var camera = viewer.camera;
-            var _b = orient(camera.position), p = _b[0], direction = _b[1], up = _b[2];
-            var orientation = { direction: direction, up: up };
-            camera.flyTo({
-                destination: p,
-                orientation: orientation,
-                duration: duration,
-                complete: function () {
-                    if (C3.distance(p, center) > cutoffDistance) {
-                        var d = C3.subtract(p, center, new C3);
-                        d = shorten(d, cutoffDistance);
-                        var h = C3.multiplyByScalar(C3.normalize(up, new C3), hoverHeight, new C3);
-                        d = C3.add(d, h, new C3);
-                        d = shorten(d, cutoffDistance);
-                        d = C3.add(d, center, new C3);
-                        var _a = orient(d), direction_1 = _a[1], u = _a[2];
-                        camera.flyTo({
-                            destination: d,
-                            orientation: { direction: direction_1, up: u }
-                        });
+            if (entity instanceof Cesium.Entity) {
+                var cEntity = entity;
+                var items = [];
+                traverseEntity(cEntity, items, false);
+                return items;
+            }
+            return [entity];
+        }
+        EntityUtils.GatherEntity = GatherEntity;
+        /**
+         * Looks at given entities with least amount of movement.
+         * @param viewer
+         * @param entities
+         */
+        function LookAtEntities(params) {
+            return __awaiter(this, void 0, void 0, function () {
+                var viewer, entities, _a, R, CT, C3, M3, M4, E, duration, centers, currentTime, target, bounds, center, orient, camera, _b, p, direction, up, orientation, terrData, MIN_HEIGHT, carto;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            viewer = params.viewer, entities = params.entities;
+                            // Removing cesium tileset features for now as it's not accurate.
+                            entities = [].concat(entities).filter(function (x) { return !(x instanceof Cesium.Cesium3DTileFeature); });
+                            if (!entities.length) {
+                                return [2 /*return*/];
+                            }
+                            _a = [Cesium.Rectangle, Cesium.Cartographic, Cesium.Cartesian3, Cesium.Matrix3, Cesium.Matrix4, Cesium.EasingFunction], R = _a[0], CT = _a[1], C3 = _a[2], M3 = _a[3], M4 = _a[4], E = _a[5];
+                            duration = 0.5;
+                            centers = function (p) {
+                                var PM = p.modelMatrix;
+                                var instances = (function (i) { return (i instanceof Cesium.GeometryInstance ? [i] : i); })(p.geometryInstances);
+                                return instances.map(function (g) {
+                                    var _M = M4.multiply(PM, g.modelMatrix, new M4);
+                                    var G = g.geometry;
+                                    var _p = G.attributes.position;
+                                    var b = G.boundingSphere;
+                                    return [b.center, b.radius];
+                                });
+                            };
+                            currentTime = Cesium.JulianDate.now();
+                            target = entities.flatMap(function (e) {
+                                var _a;
+                                if (e instanceof Cesium.Cartesian3) {
+                                    return [[e, 0]];
+                                }
+                                if (e instanceof Cesium.Entity) {
+                                    return [[(_a = e.position) === null || _a === void 0 ? void 0 : _a.getValue(currentTime), 0]];
+                                }
+                                if (e instanceof Cesium.Primitive) {
+                                    return centers(e);
+                                }
+                                if (e instanceof Cesium.Cesium3DTileFeature) {
+                                    var s = e.tileset.boundingSphere;
+                                    return [[s.center, s.radius]];
+                                }
+                            });
+                            bounds = function (list) {
+                                var min = list[0][0];
+                                var max = min;
+                                for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
+                                    var _a = list_1[_i], p_1 = _a[0], r = _a[1];
+                                    var pMin = C3.subtract(p_1, new C3(r), new C3);
+                                    var pMax = C3.add(p_1, new C3(r), new C3);
+                                    min = C3.minimumByComponent(pMin, min, new C3);
+                                    max = C3.maximumByComponent(pMax, max, new C3);
+                                }
+                                var c = C3.multiplyByScalar(C3.add(max, min, new C3), 0.5, new C3);
+                                return c;
+                            };
+                            center = bounds(target);
+                            orient = function (p) {
+                                var d = C3.subtract(center, p, new C3);
+                                var dir = C3.normalize(d, new C3);
+                                var up = viewer.scene.globe.ellipsoid.geodeticSurfaceNormal(center);
+                                return [p, dir, up];
+                            };
+                            camera = viewer.camera;
+                            _b = orient(camera.position), p = _b[0], direction = _b[1], up = _b[2];
+                            orientation = { direction: direction, up: up };
+                            if (!(p === null || p === void 0 ? void 0 : p.x)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, exports.DrawingUtils.GetTerrainHeight({
+                                    pos3d: p,
+                                    viewer: viewer
+                                })];
+                        case 1:
+                            terrData = _c.sent();
+                            MIN_HEIGHT = terrData.height + 300;
+                            carto = Cesium.Cartographic.fromCartesian(p);
+                            if (carto.height < MIN_HEIGHT) {
+                                carto.height = MIN_HEIGHT;
+                                p = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, carto.height);
+                            }
+                            camera.flyTo({
+                                destination: p,
+                                orientation: orientation,
+                                duration: duration,
+                                complete: function () {
+                                    // if (C3.distance(p, center) > cutoffDistance) {
+                                    //     let d = C3.subtract(p, center, new C3);
+                                    //     d = shorten(d, cutoffDistance);
+                                    //     const h = C3.multiplyByScalar(C3.normalize(up, new C3), hoverHeight, new C3);
+                                    //     d = C3.add(d, h, new C3);
+                                    //     d = shorten(d, cutoffDistance);
+                                    //     d = C3.add(d, center, new C3);
+                                    //     const [ _p, direction, u ] = orient(d);
+                                    //     camera.flyTo({
+                                    //         destination: d,
+                                    //         orientation: { direction, up: u }
+                                    //     });
+                                    // }
+                                }
+                            });
+                            _c.label = 2;
+                        case 2: return [2 /*return*/];
                     }
-                }
+                });
             });
         }
         EntityUtils.LookAtEntities = LookAtEntities;
@@ -1965,6 +2701,24 @@
         _billboardCache.Set(key, data);
         return data;
     };
+    /**
+     * Removes duplicate points in a row and returns a new array.
+     * Passed array is not mutated.
+     * @param posses
+     */
+    function cullDuplicatePoints(posses) {
+        var newPosses = [];
+        var lastPos = null;
+        for (var i = 0; i < posses.length; i++) {
+            var pos = posses[i];
+            // Avoiding 'Cesium.Cartesian3.equals' because passed data might be just a json blob in certain cases.
+            if (pos && (!lastPos || (pos.x != lastPos.x || pos.y != lastPos.y || pos.z != lastPos.z))) {
+                newPosses.push(pos);
+                lastPos = pos;
+            }
+        }
+        return newPosses;
+    }
     (function (EntityRenderEngine) {
         function Render(params) {
             var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -2095,10 +2849,13 @@
                                                 }
                                             });
                                             rendered = rendered.concat(Object.values(cLines));
+                                            if (!!rendered.length) return [3 /*break*/, 4];
                                             return [4 /*yield*/, Point.RenderGroup(pParams)];
                                         case 3:
                                             cPoints = _k.sent();
                                             rendered = rendered.concat(Object.values(cPoints));
+                                            _k.label = 4;
+                                        case 4:
                                             rendered = rendered.filter(function (x) { return x != null; });
                                             if (rendered.length) {
                                                 rootEntity_1 = new Cesium.Entity({});
@@ -2549,6 +3306,7 @@
                     flattenPoints = true;
                 }
                 var posses = points.map(function (x) { return Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(flattenPoints ? 0 : x.altitude)); });
+                posses = cullDuplicatePoints(posses);
                 // 5 points should be enough to tell most bad data.
                 var CHECK_POINTS = 5;
                 var MIN_LEN = 0.001;
@@ -2727,6 +3485,10 @@
                 bruceModels.Cartes.CloseRing3(posses);
                 var extrusion = getPolygonExtrusion(entity, params.tags, outerRing, posses, heightRef, style);
                 posses = extrusion.posses;
+                posses = cullDuplicatePoints(posses);
+                if (posses.length < 4) {
+                    return null;
+                }
                 var flattenPoints = false;
                 if (heightRef == Cesium.HeightReference.CLAMP_TO_GROUND && shouldApplyFlatFix((_b = params.viewer) === null || _b === void 0 ? void 0 : _b.terrainProvider)) {
                     heightRef = Cesium.HeightReference.NONE;
@@ -2735,8 +3497,10 @@
                 var holeRings = pRings.filter(function (x) { return x.Facing == bruceModels.Geometry.EPolygonRingType.Hole; });
                 var holePosses = holeRings.map(function (x) {
                     var points = bruceModels.Geometry.ParsePoints(x.LinearRing);
-                    return points.map(function (x) { return Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(flattenPoints ? 0 : x.altitude)); });
-                });
+                    var holePosses = points.map(function (x) { return Cesium.Cartesian3.fromDegrees(EnsureNumber(x.longitude), EnsureNumber(x.latitude), EnsureNumber(flattenPoints ? 0 : x.altitude)); });
+                    holePosses = cullDuplicatePoints(holePosses);
+                    return holePosses;
+                }).filter(function (x) { return x.length >= 4; });
                 var zIndex = getZIndex(style, entity, params.tags);
                 var size = getSizeOfPolygonEntity(entity);
                 var classification = Cesium.ClassificationType.TERRAIN;
@@ -12696,212 +13460,6 @@
         })(Terrain = TileRenderEngine.Terrain || (TileRenderEngine.Terrain = {}));
     })(exports.TileRenderEngine || (exports.TileRenderEngine = {}));
 
-    var CESIUM_INSPECTOR_KEY = "_nextspace_inspector";
-    (function (ViewUtils) {
-        function GatherLegacyMapTiles(params) {
-            var viewer = params.viewer;
-            var collection = viewer.imageryLayers;
-            var tiles = [];
-            for (var i = 0; i < collection.length; i++) {
-                var layer = collection.get(i);
-                if (layer._bName) {
-                    tiles.push({
-                        alpha: layer.alpha,
-                        brightness: layer.brightness,
-                        contrast: layer.contrast,
-                        hue: layer.hue,
-                        saturation: layer.saturation,
-                        gamma: layer.gamma,
-                        title: layer._bName,
-                    });
-                }
-            }
-            return {
-                imagery: tiles.reverse()
-            };
-        }
-        ViewUtils.GatherLegacyMapTiles = GatherLegacyMapTiles;
-        function GatherLegacyTerrainTile(params) {
-            var viewer = params.viewer;
-            var enabled = viewer.terrainProvider;
-            if (enabled === null || enabled === void 0 ? void 0 : enabled._bName) {
-                return {
-                    terrain: enabled._bName
-                };
-            }
-            return {
-                terrain: "flatterrain"
-            };
-        }
-        ViewUtils.GatherLegacyTerrainTile = GatherLegacyTerrainTile;
-        function GatherMapTiles(params) {
-            var viewer = params.viewer;
-            var imagery = viewer.imageryLayers;
-            var tiles = [];
-            var _loop_1 = function (i) {
-                var provider = imagery.get(i);
-                if (provider._bMeta) {
-                    var idCombo_1 = provider._bMeta.accountId + provider._bMeta.tilesetId;
-                    if (!tiles.find(function (x) { return x.accountId + x.tilesetId === idCombo_1; })) {
-                        tiles.push({
-                            accountId: provider._bMeta.accountId,
-                            tilesetId: provider._bMeta.tilesetId,
-                            alpha: provider.alpha,
-                            brightness: provider.brightness,
-                            contrast: provider.contrast,
-                            hue: provider.hue,
-                            saturation: provider.saturation,
-                            gamma: provider.gamma
-                        });
-                    }
-                }
-            };
-            for (var i = 0; i < imagery.length; i++) {
-                _loop_1(i);
-            }
-            return {
-                imagery: tiles
-            };
-        }
-        ViewUtils.GatherMapTiles = GatherMapTiles;
-        function GatherTerrainTile(params) {
-            var viewer = params.viewer;
-            var provider = viewer.terrainProvider;
-            if (provider._bMeta) {
-                return {
-                    terrain: {
-                        accountId: provider._bMeta.accountId,
-                        tilesetId: provider._bMeta.tilesetId,
-                    }
-                };
-            }
-            else if (provider instanceof Cesium.EllipsoidTerrainProvider) {
-                return {
-                    terrain: {
-                        tilesetId: bruceModels.ProjectViewTile.EDefaultTerrain.FlatTerrain,
-                        accountId: null
-                    }
-                };
-            }
-            return null;
-        }
-        ViewUtils.GatherTerrainTile = GatherTerrainTile;
-        function SetTerrainWireframeStatus(params) {
-            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-                var InspectorClass = Cesium.CesiumInspector;
-                if (InspectorClass) {
-                    var inspector = new InspectorClass(document.createElement("div"), params.viewer.scene);
-                    inspector.container.style.display = "none";
-                    params.viewer[CESIUM_INSPECTOR_KEY] = inspector;
-                    params.viewer.scene.requestRender();
-                }
-            }
-            if (params.viewer[CESIUM_INSPECTOR_KEY]) {
-                params.viewer[CESIUM_INSPECTOR_KEY].viewModel.wireframe = params.status;
-            }
-        }
-        ViewUtils.SetTerrainWireframeStatus = SetTerrainWireframeStatus;
-        function GetTerrainWireframeStatus(params) {
-            var _a, _b;
-            if (!params.viewer[CESIUM_INSPECTOR_KEY]) {
-                return false;
-            }
-            return (_b = (_a = params.viewer[CESIUM_INSPECTOR_KEY]) === null || _a === void 0 ? void 0 : _a.viewModel) === null || _b === void 0 ? void 0 : _b.wireframe;
-        }
-        ViewUtils.GetTerrainWireframeStatus = GetTerrainWireframeStatus;
-        /**
-         * Changes between perspective and orthographic view.
-         * When Cesium stops being bad at picking positions in 2d mode we'll use the flat earth mode instead.
-         * @param params
-         */
-        function Set2dStatus(params) {
-            var viewer = params.viewer, is2d = params.status, moveCamera = params.moveCamera;
-            var curLens2d = viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
-            if (curLens2d && !is2d) {
-                viewer.camera.switchToPerspectiveFrustum();
-                viewer.scene.screenSpaceCameraController.enableTilt = true;
-                viewer.scene.requestRender();
-            }
-            else if (!curLens2d && is2d) {
-                viewer.camera.switchToOrthographicFrustum();
-                viewer.scene.screenSpaceCameraController.enableTilt = false;
-                if (moveCamera != false) {
-                    try {
-                        // Face camera downwards to make it look 2d.
-                        // We want to try make it look at the center-point of the current view.
-                        // If center cannot be calculated then we'll simply raise the camera and face it downwards.
-                        var scene = viewer.scene;
-                        var windowPosition = new Cesium.Cartesian2(scene.canvas.clientWidth / 2, scene.canvas.clientHeight / 2);
-                        var ray = viewer.camera.getPickRay(windowPosition);
-                        var intersection = scene.globe.pick(ray, scene);
-                        var center = void 0;
-                        if (Cesium.defined(intersection)) {
-                            center = Cesium.Cartographic.fromCartesian(intersection);
-                        }
-                        // Use current camera position if we can't calculate the center.
-                        else {
-                            center = Cesium.Cartographic.fromCartesian(viewer.camera.position);
-                            center.height = 0;
-                        }
-                        center.height = viewer.camera.positionCartographic.height + 100;
-                        viewer.camera.setView({
-                            destination: Cesium.Cartographic.toCartesian(center),
-                            orientation: {
-                                heading: 0.0,
-                                pitch: Cesium.Math.toRadians(-90.0),
-                                roll: 0.0
-                            }
-                        });
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
-                }
-                viewer.scene.requestRender();
-            }
-        }
-        ViewUtils.Set2dStatus = Set2dStatus;
-        function Get2dStatus(params) {
-            var viewer = params.viewer;
-            return viewer.camera.frustum instanceof Cesium.OrthographicFrustum;
-        }
-        ViewUtils.Get2dStatus = Get2dStatus;
-        function SetLockedCameraStatus(params) {
-            var viewer = params.viewer, status = params.status;
-            var scene = viewer === null || viewer === void 0 ? void 0 : viewer.scene;
-            if (!scene) {
-                return;
-            }
-            if (status) {
-                scene.screenSpaceCameraController.enableInputs = false;
-                scene.screenSpaceCameraController.enableTranslate = false;
-                scene.screenSpaceCameraController.enableZoom = false;
-                scene.screenSpaceCameraController.enableRotate = false;
-                scene.screenSpaceCameraController.enableTilt = false;
-            }
-            else {
-                scene.screenSpaceCameraController.enableInputs = true;
-                scene.screenSpaceCameraController.enableTranslate = true;
-                scene.screenSpaceCameraController.enableZoom = true;
-                scene.screenSpaceCameraController.enableRotate = true;
-                if (!ViewUtils.Get2dStatus({ viewer: viewer })) {
-                    scene.screenSpaceCameraController.enableTilt = true;
-                }
-            }
-            viewer.scene.requestRender();
-        }
-        ViewUtils.SetLockedCameraStatus = SetLockedCameraStatus;
-        function GetLockedCameraStatus(params) {
-            var _a;
-            var scene = (_a = params.viewer) === null || _a === void 0 ? void 0 : _a.scene;
-            if (!scene) {
-                return false;
-            }
-            return !scene.screenSpaceCameraController.enableTranslate;
-        }
-        ViewUtils.GetLockedCameraStatus = GetLockedCameraStatus;
-    })(exports.ViewUtils || (exports.ViewUtils = {}));
-
     var VIEWER_BOOKMARKS_WIDGET_KEY = "_viewerBookmarksWidget";
     var WidgetBookmarks = /** @class */ (function (_super) {
         __extends(WidgetBookmarks, _super);
@@ -16653,7 +17211,7 @@
         ViewerUtils.CreateWidgets = CreateWidgets;
     })(exports.ViewerUtils || (exports.ViewerUtils = {}));
 
-    var VERSION$1 = "2.9.4";
+    var VERSION$1 = "2.9.6";
 
     exports.VERSION = VERSION$1;
     exports.CesiumViewMonitor = CesiumViewMonitor;