bruce-cesium 1.6.3 → 1.6.5

package/dist/bruce-cesium.es5.js

@@ -1,5 +1,5 @@
-import { BruceEvent, Cartes, Carto, Entity as Entity$1, Geometry, Tileset, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, DelayQueue, BatchedDataGetter, EntityRelationType, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, EntityRelation, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera } from 'bruce-models';
-import { Cartesian2, Cartographic, Math as Math$1, Color, HeightReference, Cartesian3, EllipsoidTerrainProvider, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, SceneMode, createOsmBuildings, Cesium3DTileStyle, Rectangle, Cesium3DTileColorBlendMode, HeadingPitchRange, KmlDataSource, CallbackProperty, OrthographicFrustum, JulianDate, createWorldTerrain, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, Cesium3DTileset, Matrix4, IonResource, EllipsoidGeodesic, sampleTerrainMostDetailed, ColorMaterialProperty, Matrix3, EasingFunction, GeometryInstance, PolygonPipeline } from 'cesium';
+import { BruceEvent, Cartes, Carto, Entity as Entity$1, Geometry, Tileset, MathUtils, LRUCache, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, ObjectUtils, DelayQueue, BatchedDataGetter, EntityRelationType, EntityCoords, EntityFilterGetter, EntitySource, MenuItem, EntityRelation, ProjectView, ProjectViewBookmark, ProjectViewTile, ProjectViewLegacyTile, ProgramKey, Camera } from 'bruce-models';
+import { Cartesian2, Cartographic, Math as Math$1, Entity, Primitive, Cesium3DTileFeature, Color, HeightReference, Cartesian3, EllipsoidTerrainProvider, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, SceneMode, HeadingPitchRange, createOsmBuildings, Cesium3DTileStyle, Rectangle, Cesium3DTileColorBlendMode, KmlDataSource, CallbackProperty, OrthographicFrustum, JulianDate, EllipsoidGeodesic, sampleTerrainMostDetailed, createWorldTerrain, CesiumTerrainProvider, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, IonImageryProvider, PolygonPipeline, Cesium3DTileset, Matrix4, IonResource, ColorMaterialProperty, Matrix3, EasingFunction, GeometryInstance } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -766,7 +766,12 @@ var EntityUtils;
         function evaluateRecord() {
             if (entity.location && Carto.ValidateCarto(entity.location)) {
                 var location_1 = entity.location;
-                return Cartesian3.fromDegrees(EnsureNumber(location_1.longitude), EnsureNumber(location_1.latitude), EnsureNumber(location_1.altitude));
+                var latitude = EnsureNumber(location_1.latitude);
+                var longitude = EnsureNumber(location_1.longitude);
+                // Disallowing exact 0.
+                if (latitude || longitude) {
+                    return Cartesian3.fromDegrees(longitude, latitude, EnsureNumber(location_1.altitude));
+                }
             }
             if (entity.geometry && typeof entity.geometry == "object") {
                 var pointStr = entity.geometry.Point;
@@ -818,8 +823,11 @@ var EntityUtils;
                     longitude: (EnsureNumber(entity.boundaries.minLongitude) + EnsureNumber(entity.boundaries.maxLongitude)) / 2,
                     altitude: 0
                 };
-                if (point && Carto.ValidateCarto(point)) {
-                    return Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                // Disallowing exact 0.
+                if (point.latitude || point.longitude) {
+                    if (Carto.ValidateCarto(point)) {
+                        return Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+                    }
                 }
             }
         }
@@ -1093,6 +1101,177 @@ var EntityUtils;
     EntityUtils.GetOpacity = GetOpacity;
 })(EntityUtils || (EntityUtils = {}));
 
+function distanceToSegment(fromPoint, toPoint1, toPoint2) {
+    var ab = Cartesian3.subtract(toPoint2, toPoint1, new Cartesian3());
+    var ap = Cartesian3.subtract(fromPoint, toPoint1, new Cartesian3());
+    var e = Cartesian3.dot(ap, ab);
+    if (e <= 0) {
+        return Cartesian3.distance(fromPoint, toPoint1);
+    }
+    var f = Cartesian3.dot(ab, ab);
+    if (e >= f) {
+        return Cartesian3.distance(fromPoint, toPoint2);
+    }
+    var proj = Cartesian3.multiplyByScalar(ab, e / f, new Cartesian3());
+    var projECEF = Cartesian3.add(toPoint1, proj, new Cartesian3());
+    return Cartesian3.distance(fromPoint, projECEF);
+}
+function pointInsidePolygon(point, polygon) {
+    var inside = false;
+    var x = point.latitude;
+    var y = point.longitude;
+    for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        var xi = +polygon[i].latitude;
+        var yi = +polygon[i].longitude;
+        var xj = +polygon[j].latitude;
+        var yj = +polygon[j].longitude;
+        if (isNaN(xi) || isNaN(yi) || isNaN(xj) || isNaN(yj)) {
+            continue;
+        }
+        var intersect = (yi > y) !== (yj > y) && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+        if (intersect) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function distanceToPolygon(point, polygon) {
+    if (pointInsidePolygon(point, polygon)) {
+        var avgAltitude = polygon.reduce(function (sum, vertex) { return sum + vertex.altitude; }, 0) / polygon.length;
+        return Math.abs(point.altitude - avgAltitude);
+    }
+    var pointECEF = Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+    var minDistance = Infinity;
+    for (var i = 0; i < polygon.length; i++) {
+        var point1 = polygon[i];
+        var point1Latitude = EnsureNumber(point1.latitude);
+        var point1Longitude = EnsureNumber(point1.longitude);
+        if (!point1Latitude && !point1Longitude) {
+            continue;
+        }
+        var point2 = polygon[(i + 1) % polygon.length];
+        var point2Latitude = EnsureNumber(point2.latitude);
+        var point2Longitude = EnsureNumber(point2.longitude);
+        if (!point2Latitude && !point2Longitude) {
+            continue;
+        }
+        var coord1ECEF = Cartesian3.fromDegrees(point1Longitude, point1Latitude, EnsureNumber(point1.altitude));
+        var coord2ECEF = Cartesian3.fromDegrees(point2Longitude, point2Latitude, EnsureNumber(point2.altitude));
+        var distance = distanceToSegment(pointECEF, coord1ECEF, coord2ECEF);
+        minDistance = Math.min(minDistance, distance);
+    }
+    return minDistance;
+}
+// Cache for distance calculations.
+// It will keep only the most recent 3000 entries.
+var distanceCache = new LRUCache(3000);
+function createCacheKey(point, entity) {
+    try {
+        var pointData = {
+            latitude: MathUtils.Round(+point.latitude, 5),
+            longitude: MathUtils.Round(+point.longitude, 5),
+            altitude: MathUtils.Round(+point.altitude, 4)
+        };
+        var entityData = __assign(__assign(__assign({}, entity.location), entity.geometry), entity.boundaries);
+        return JSON.stringify(pointData) + '|' + JSON.stringify(entityData);
+    }
+    catch (e) {
+        console.error(e);
+        return null;
+    }
+}
+/**
+ * Calculates distance while accounting for polylines and polygons.
+ * It does not account for multi-geometry.
+ * @param point
+ * @param entity
+ * @returns
+ */
+function calculateDistance(point, entity) {
+    var cacheKey = createCacheKey(point, entity);
+    var cachedResult = cacheKey ? distanceCache.Get(cacheKey) : null;
+    if (cachedResult || cachedResult == 0) {
+        return cachedResult;
+    }
+    var minDistance = Infinity;
+    var pointPos = Cartesian3.fromDegrees(point.longitude, point.latitude, point.altitude);
+    // We'll start by using the entity location if it's available.
+    var entityPos3d = null;
+    if (entity.location && entity.location.latitude) {
+        var latitude = EnsureNumber(entity.location.latitude);
+        var longitude = EnsureNumber(entity.location.longitude);
+        // Disallowing exact 0.
+        if (latitude || longitude) {
+            var altitude = EnsureNumber(entity.location.altitude);
+            entityPos3d = Cartesian3.fromDegrees(longitude, latitude, altitude);
+        }
+    }
+    if (!isNaN(entityPos3d.x)) {
+        minDistance = Cartesian3.distance(pointPos, entityPos3d);
+    }
+    // Check geometry if it's available.
+    if (entity.geometry) {
+        var passedGeometry = false;
+        if (entity.geometry.Polygon) {
+            var polygonRings = entity.geometry.Polygon;
+            var polygon = typeof polygonRings == "string" ? String(polygonRings) : polygonRings.length ? polygonRings[0].LinearRing : "";
+            var points = polygon ? Geometry.ParsePoints(polygon) : [];
+            if (points.length > 2) {
+                var distance = distanceToPolygon(point, points);
+                if (!isNaN(distance)) {
+                    minDistance = Math.min(minDistance, distance);
+                    passedGeometry = true;
+                }
+            }
+        }
+        if (!passedGeometry && entity.geometry.LineString) {
+            var points = Geometry.ParsePoints(entity.geometry.LineString);
+            if (points.length > 1) {
+                var pointsLen = points.length;
+                for (var i = 0; i < pointsLen; i++) {
+                    var point1 = points[i];
+                    var point1Latitude = EnsureNumber(point1.latitude);
+                    var point1Longitude = EnsureNumber(point1.longitude);
+                    if (!point1Latitude && !point1Longitude) {
+                        continue;
+                    }
+                    var point2 = points[(i + 1) % pointsLen];
+                    var point2Latitude = EnsureNumber(point2.latitude);
+                    var point2Longitude = EnsureNumber(point2.longitude);
+                    if (!point2Latitude && !point2Longitude) {
+                        continue;
+                    }
+                    var coord1ECEF = Cartesian3.fromDegrees(point1Longitude, point1Latitude, EnsureNumber(point1.altitude));
+                    var coord2ECEF = Cartesian3.fromDegrees(point2Longitude, point2Latitude, EnsureNumber(point2.altitude));
+                    var distance = distanceToSegment(pointPos, coord1ECEF, coord2ECEF);
+                    if (!isNaN(distance)) {
+                        minDistance = Math.min(minDistance, distance);
+                        passedGeometry = true;
+                    }
+                }
+            }
+        }
+    }
+    // Backup is using boundaries.
+    if (minDistance === Infinity && entity.boundaries) {
+        var point_1 = {
+            latitude: (EnsureNumber(entity.boundaries.minLatitude) + EnsureNumber(entity.boundaries.maxLatitude)) / 2,
+            longitude: (EnsureNumber(entity.boundaries.minLongitude) + EnsureNumber(entity.boundaries.maxLongitude)) / 2,
+            altitude: 0
+        };
+        // Disallowing exact 0.
+        if (point_1.latitude || point_1.longitude) {
+            if (Carto.ValidateCarto(point_1)) {
+                var boundsPoint = Cartesian3.fromDegrees(point_1.longitude, point_1.latitude, point_1.altitude);
+                minDistance = Cartesian3.distance(pointPos, boundsPoint);
+            }
+        }
+    }
+    if (cacheKey) {
+        distanceCache.Set(cacheKey, minDistance);
+    }
+    return minDistance;
+}
 var RenderManager;
 (function (RenderManager) {
     function DetermineZoomItem(params) {
@@ -1105,11 +1284,15 @@ var RenderManager;
             return null;
         }
         var is2d = viewer.scene.mode === SceneMode.SCENE2D;
-        var cameraPos = viewer.camera.position;
-        if (!Cartes.ValidateCartes3(cameraPos)) {
+        var cameraPos = viewer.camera.positionCartographic;
+        if (!cameraPos || !cameraPos.latitude) {
             return null;
         }
-        var distance = Cartesian3.distance(pos, cameraPos);
+        var distance = calculateDistance({
+            altitude: cameraPos.height,
+            latitude: Math$1.toDegrees(cameraPos.latitude),
+            longitude: Math$1.toDegrees(cameraPos.longitude)
+        }, entity);
         var zoomItem = (!distance && distance != 0) ? null : GetZoomControlFromDistance({
             zoomControl: zoomControl,
             distance: distance
@@ -2303,6 +2486,8 @@ var EntityRenderEngine;
     })(Model3d = EntityRenderEngine.Model3d || (EntityRenderEngine.Model3d = {}));
 })(EntityRenderEngine || (EntityRenderEngine = {}));
 
+var BATCH_SIZE = 500;
+var CHECK_BATCH_SIZE = 250;
 /**
  * Manager for rendering Bruce entities.
  * This will request entities based on setup menu item filter.
@@ -2377,7 +2562,7 @@ var EntitiesRenderManager;
                     this.getter = this.sharedGetters.GetOrCreateFilterGetter({
                         api: api,
                         attrFilter: (_e = this.item.BruceEntity.Filter) !== null && _e !== void 0 ? _e : {},
-                        batchSize: 500,
+                        batchSize: BATCH_SIZE,
                         typeId: this.item.BruceEntity["EntityType.ID"],
                         monitor: this.monitor,
                         viewer: this.viewer,
@@ -2455,7 +2640,7 @@ var EntitiesRenderManager;
         };
         Manager.prototype.doEntityCheck = function (ids) {
             return __awaiter(this, void 0, void 0, function () {
-                var api, CHECK_BATCH_SIZE_1, checkBatch, e_1;
+                var api, checkBatch, e_1;
                 var _this = this;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -2479,13 +2664,12 @@ var EntitiesRenderManager;
                                 return [2 /*return*/];
                             }
                             if (!(ids.length > 0)) return [3 /*break*/, 4];
-                            CHECK_BATCH_SIZE_1 = 150;
                             checkBatch = function () { return __awaiter(_this, void 0, void 0, function () {
                                 var entityIds, entities;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
-                                            entityIds = ids.splice(0, CHECK_BATCH_SIZE_1);
+                                            entityIds = ids.splice(0, CHECK_BATCH_SIZE);
                                             return [4 /*yield*/, Entity$1.GetListByIds({
                                                     api: api,
                                                     entityIds: entityIds
@@ -2521,7 +2705,6 @@ var EntitiesRenderManager;
         };
         Manager.prototype.distributeForRender = function (entities) {
             var _this = this;
-            var BATCH_SIZE = 300;
             this.renderQueue = this.renderQueue.concat(entities);
             if (!this.renderQueueInterval && this.renderQueue.length) {
                 this.renderQueueInterval = setInterval(function () {
@@ -2606,6 +2789,8 @@ var EntitiesRenderManager;
     EntitiesRenderManager.Manager = Manager;
 })(EntitiesRenderManager || (EntitiesRenderManager = {}));
 
+var BATCH_SIZE$1 = 500;
+var CHECK_BATCH_SIZE$1 = 250;
 /**
  * Render manager for a group of pre-loaded entities.
  * The entities may or may not have records.
@@ -2640,7 +2825,7 @@ var EntitiesLoadedRenderManager;
                     if (this.disposed) {
                         throw (new Error("This item is disposed."));
                     }
-                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.Entities, this.monitor, 500);
+                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.Entities, this.monitor, BATCH_SIZE$1);
                     this.getterSub = this.getter.OnUpdate.Subscribe(function (entities) {
                         _this.onGetterUpdate(entities);
                     });
@@ -2686,7 +2871,7 @@ var EntitiesLoadedRenderManager;
         };
         Manager.prototype.doEntityCheck = function (ids) {
             return __awaiter(this, void 0, void 0, function () {
-                var api, CHECK_BATCH_SIZE_1, checkBatch, e_1;
+                var api, checkBatch, e_1;
                 var _this = this;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -2699,13 +2884,12 @@ var EntitiesLoadedRenderManager;
                                 return [2 /*return*/];
                             }
                             if (!(ids.length > 0)) return [3 /*break*/, 4];
-                            CHECK_BATCH_SIZE_1 = 150;
                             checkBatch = function () { return __awaiter(_this, void 0, void 0, function () {
                                 var entityIds, entities;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
-                                            entityIds = ids.splice(0, CHECK_BATCH_SIZE_1);
+                                            entityIds = ids.splice(0, CHECK_BATCH_SIZE$1);
                                             return [4 /*yield*/, Entity$1.GetListByIds({
                                                     api: api,
                                                     entityIds: entityIds
@@ -4099,6 +4283,7 @@ var VisualsRegister;
     VisualsRegister.Register = Register;
 })(VisualsRegister || (VisualsRegister = {}));
 
+var BATCH_SIZE$2 = 500;
 /**
  * Render manager for rendering an array of entity ids.
  * This will render them in batches to avoid overloading the viewer.
@@ -4132,7 +4317,7 @@ var EntitiesIdsRenderManager;
                     if (this.disposed) {
                         throw (new Error("This item is disposed."));
                     }
-                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.EntityIds, this.monitor, 500);
+                    this.getter = new BatchedDataGetter.Getter(this.item.BruceEntity.EntityIds, this.monitor, BATCH_SIZE$2);
                     this.getterSub = this.getter.OnUpdate.Subscribe(function (ids) {
                         _this.onGetterUpdate(ids);
                     });
@@ -5496,7 +5681,7 @@ var SharedGetters;
 })(SharedGetters || (SharedGetters = {}));
 
 var MAX_BATCHES = 2;
-var BATCH_SIZE = 30;
+var BATCH_SIZE$3 = 30;
 var BATCH_DELAY = 200;
 var MAX_RANGE = 3000;
 var TilesetOsmRenderManager;
@@ -5691,7 +5876,7 @@ var TilesetOsmRenderManager;
                                 var isClose = this.getIsVisualWithinRange(feature, MAX_RANGE);
                                 if (isClose) {
                                     batch.push(feature);
-                                    if (batch.length >= BATCH_SIZE) {
+                                    if (batch.length >= BATCH_SIZE$3) {
                                         return batch;
                                     }
                                 }
@@ -5796,7 +5981,7 @@ var TilesetOsmRenderManager;
                         delete this._loadedCesiumEntities[key];
                         this.totalLoaded -= 1;
                         removed += 1;
-                        if (removed >= BATCH_SIZE) {
+                        if (removed >= BATCH_SIZE$3) {
                             return true;
                         }
                     }