bruce-cesium 0.3.0 → 0.3.1

package/dist/bruce-cesium.es5.js

@@ -1,5 +1,5 @@
-import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, BatchedDataGetter, ObjectUtils, Tileset, EntityFilterGetter, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewTileSource, Camera, MathUtils } from 'bruce-models';
-import { Cartesian2, Cartographic, Math as Math$1, Viewer, ArcGisMapServerImageryProvider, ScreenSpaceEventType, Color, HeightReference, Cartesian3, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Primitive, Cesium3DTileFeature, OrthographicFrustum, HeadingPitchRange, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, createWorldTerrain, CesiumTerrainProvider, EllipsoidTerrainProvider, Matrix4, Cesium3DTileset, EllipsoidGeodesic } from 'cesium';
+import { BruceEvent, Cartes, Carto, Geometry, ZoomControl, Style, EntityTag, Calculator, EntityLod, EntityType, ClientFile, DelayQueue, Entity as Entity$1, BatchedDataGetter, ObjectUtils, Tileset, EntityFilterGetter, EntitySource, MenuItem, ProjectView, ProjectViewBookmark, ProjectViewTileSource, Camera, MathUtils } from 'bruce-models';
+import { Color, HeightReference, Cartographic, Cartesian3, Entity, HorizontalOrigin, VerticalOrigin, ClassificationType, ArcType, PolygonHierarchy, ShadowMode, PolylineGraphics, HeadingPitchRoll, Transforms, ColorBlendMode, Cartesian2, Math as Math$1, Primitive, Cesium3DTileFeature, Viewer, ArcGisMapServerImageryProvider, ScreenSpaceEventType, OrthographicFrustum, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, OpenStreetMapImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, UrlTemplateImageryProvider, TileMapServiceImageryProvider, createWorldTerrain, CesiumTerrainProvider, EllipsoidTerrainProvider, HeadingPitchRange, createOsmBuildings, Cesium3DTileStyle, Rectangle, Matrix4, Cesium3DTileset, EllipsoidGeodesic } from 'cesium';
 
 var TIME_LAG = 300;
 var POSITION_CHECK_TIMER = 950;
@@ -2897,6 +2897,286 @@ var SharedGetters;
     SharedGetters.Cache = Cache;
 })(SharedGetters || (SharedGetters = {}));
 
+var MAX_BATCHES = 2;
+var BATCH_SIZE = 30;
+var BATCH_DELAY = 200;
+var MAX_RANGE = 3000;
+var TilesetOsmRenderManager;
+(function (TilesetOsmRenderManager) {
+    var Manager = /** @class */ (function () {
+        function Manager(viewer, visualsManager, apiGetter, monitor, item) {
+            this.disposed = false;
+            this.cTileset = null;
+            this.counter = 0;
+            this._loadedCesiumEntities = {};
+            this.totalLoaded = 0;
+            this.featureQueue = [];
+            this.sourceId = null;
+            this.entityTypeId = null;
+            this.queueCheckInterval = null;
+            this.processingQueue = 0;
+            this.viewer = viewer;
+            this.apiGetter = apiGetter;
+            this.item = item;
+            this.visualsManager = visualsManager;
+            this.monitor = monitor;
+        }
+        Object.defineProperty(Manager.prototype, "Disposed", {
+            get: function () {
+                return this.disposed;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(Manager.prototype, "count", {
+            get: function () {
+                return ++this.counter;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Manager.prototype.Dispose = function () {
+            if (this.disposed) {
+                return;
+            }
+            clearInterval(this.queueCheckInterval);
+            if (this.cTileset) {
+                this.cTileset.show = false;
+            }
+            this.visualsManager.RemoveByMenuItemId(this.item.id);
+            this.featureQueue = [];
+        };
+        Manager.prototype.Init = function () {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var menuItem;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    menuItem = this.item;
+                    this.sourceId = (_a = menuItem.BruceEntity) === null || _a === void 0 ? void 0 : _a.SourceId;
+                    this.entityTypeId = (_b = menuItem.BruceEntity) === null || _b === void 0 ? void 0 : _b["EntityType.ID"];
+                    this.cTileset = createOsmBuildings();
+                    this.cTileset.show = true;
+                    if (this.sourceId) {
+                        if (menuItem.ghostLoading == true) {
+                            this.cTileset.style = new Cesium3DTileStyle({
+                                color: "rgba(255, 255, 250, 0.98)"
+                            });
+                        }
+                        this.viewer.scene.primitives.add(this.cTileset);
+                        this.cTileset.tileLoad.addEventListener(function (tile) {
+                            _this.mapCTile(tile);
+                        });
+                        this.queueCheckInterval = setInterval(function () {
+                            if (_this.featureQueue.length > 0) {
+                                _this.processQueue();
+                            }
+                        }, 5000);
+                    }
+                    else {
+                        this.viewer.scene.primitives.add(this.cTileset);
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.mapCTile = function (tile) {
+            return __awaiter(this, void 0, void 0, function () {
+                var content, i, feature;
+                return __generator(this, function (_a) {
+                    if (this.sourceId) {
+                        content = tile.content;
+                        for (i = 0; i < content.featuresLength; i++) {
+                            feature = content.getFeature(i);
+                            if (feature._counter == null) {
+                                feature._counter = this.count;
+                            }
+                            if (feature._orgColor == null) {
+                                feature._orgColor = feature.color;
+                            }
+                            this.featureQueue.push(feature);
+                        }
+                        this.processQueue();
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        Manager.prototype.processQueue = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var batch, rerun, e_1;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.processingQueue >= MAX_BATCHES) {
+                                return [2 /*return*/];
+                            }
+                            else if (this.Disposed) {
+                                return [2 /*return*/];
+                            }
+                            this.processingQueue += 1;
+                            batch = [];
+                            rerun = false;
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 4, 5, 6]);
+                            batch = this.getVisualsForBatch();
+                            if (!(batch.length > 0)) return [3 /*break*/, 3];
+                            return [4 /*yield*/, this.mapTileBatch(batch)];
+                        case 2:
+                            _a.sent();
+                            _a.label = 3;
+                        case 3:
+                            if (this.totalLoaded > 8000) {
+                                rerun = this.removeFarAwayBatch();
+                            }
+                            else {
+                                rerun = this.featureQueue.length > 0 && batch.length > 0;
+                            }
+                            return [3 /*break*/, 6];
+                        case 4:
+                            e_1 = _a.sent();
+                            console.error(e_1);
+                            return [3 /*break*/, 6];
+                        case 5:
+                            setTimeout(function () {
+                                _this.processingQueue -= 1;
+                                if (rerun) {
+                                    _this.processQueue();
+                                }
+                            }, BATCH_DELAY);
+                            return [7 /*endfinally*/];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Manager.prototype.getVisualsForBatch = function () {
+            var batch = [];
+            var features = this.featureQueue;
+            var bounds = this.monitor.GetBounds();
+            var rect = (bounds === null || bounds === void 0 ? void 0 : bounds.east) ? new Rectangle(Math$1.toRadians(bounds.west), Math$1.toRadians(bounds.south), Math$1.toRadians(bounds.east), Math$1.toRadians(bounds.north)) : null;
+            if (rect) {
+                for (var i = 0; i < features.length; i++) {
+                    var feature = features[i];
+                    if (feature) {
+                        var featureLon = feature.getProperty("cesium#longitude");
+                        var featureLat = feature.getProperty("cesium#latitude");
+                        if (featureLon && featureLat) {
+                            var carto = Cartographic.fromDegrees(featureLon, featureLat, 0);
+                            var isIn = Rectangle.contains(rect, carto);
+                            if (isIn) {
+                                var isClose = this.getIsVisualWithinRange(feature, MAX_RANGE);
+                                if (isClose) {
+                                    batch.push(feature);
+                                    if (batch.length >= BATCH_SIZE) {
+                                        return batch;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return batch;
+        };
+        Manager.prototype.getIsVisualWithinRange = function (visual, range) {
+            var featureLon = visual.getProperty("cesium#longitude");
+            var featureLat = visual.getProperty("cesium#latitude");
+            if (featureLon && featureLat) {
+                var pos = Cartesian3.fromDegrees(featureLon, featureLat, 0);
+                var camPoint = this.monitor.GetTarget();
+                var camPos = (camPoint === null || camPoint === void 0 ? void 0 : camPoint.latitude) ? Cartesian3.fromDegrees(camPoint.longitude, camPoint.latitude, camPoint.altitude) : null;
+                if (camPos && Cartes.ValidateCartes3(camPos) && Cartes.ValidateCartes3(pos)) {
+                    var distance = Cartesian3.distance(pos, camPos);
+                    if (distance != null && distance <= range) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        };
+        Manager.prototype.mapTileBatch = function (features) {
+            return __awaiter(this, void 0, void 0, function () {
+                var featureIds, featureMap, _loop_1, this_1, i, api, bIds, i, id, bId, feature, rego;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            featureIds = [];
+                            featureMap = [];
+                            _loop_1 = function (i) {
+                                var feature = features[i];
+                                var featureId = feature.getProperty("elementId");
+                                if (featureId) {
+                                    featureMap.push(feature);
+                                    featureIds.push(featureId + "");
+                                }
+                                var index = this_1.featureQueue.findIndex(function (x) { return x._counter == feature._counter; });
+                                if (index > -1) {
+                                    this_1.featureQueue.splice(index, 1);
+                                }
+                            };
+                            this_1 = this;
+                            for (i = 0; i < features.length; i++) {
+                                _loop_1(i);
+                            }
+                            api = this.apiGetter.getApi(this.apiGetter.accountId, this.apiGetter.env);
+                            return [4 /*yield*/, EntitySource.GetEntityIdsBySourceKeys(api, this.sourceId, featureIds)];
+                        case 1:
+                            bIds = _a.sent();
+                            for (i = 0; i < featureIds.length; i++) {
+                                id = featureIds[i];
+                                bId = bIds[id];
+                                if (!bId) {
+                                    bId = ObjectUtils.UId();
+                                }
+                                feature = featureMap[i];
+                                if (this.item.ghostLoading == true) {
+                                    feature.color = feature._orgColor;
+                                }
+                                rego = {
+                                    entityId: bId,
+                                    menuItemId: this.item.id,
+                                    priority: 0,
+                                    visual: feature,
+                                    entityTypeId: this.entityTypeId,
+                                    sourceId: this.sourceId
+                                };
+                                this.visualsManager.Add(rego);
+                                this._loadedCesiumEntities[bId] = rego;
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        Manager.prototype.removeFarAwayBatch = function () {
+            var removed = 0;
+            var keys = Object.keys(this._loadedCesiumEntities);
+            for (var i = 0; i < keys.length; i++) {
+                var key = keys[i];
+                var rego = this._loadedCesiumEntities[key];
+                if (rego) {
+                    if (!this.getIsVisualWithinRange(rego.visual, MAX_RANGE)) {
+                        this.visualsManager.Remove(rego.entityId, this.item.id);
+                        this._loadedCesiumEntities[key] = null;
+                        delete this._loadedCesiumEntities[key];
+                        this.totalLoaded -= 1;
+                        removed += 1;
+                        if (removed >= BATCH_SIZE) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return removed > 0;
+        };
+        return Manager;
+    }());
+    TilesetOsmRenderManager.Manager = Manager;
+})(TilesetOsmRenderManager || (TilesetOsmRenderManager = {}));
+
 /**
  * Utility to keep track of enabled menu items within a Cesium viewer.
  */
@@ -2978,6 +3258,7 @@ var MenuItemManager;
                                     rItem.renderManager = new TilesetCadRenderManager.Manager(this.viewer, this.visualsRegister, params.apiGetter, params.item);
                                     break;
                                 case MenuItem.EType.Osm:
+                                    rItem.renderManager = new TilesetOsmRenderManager.Manager(this.viewer, this.visualsRegister, params.apiGetter, this.sharedMonitor, params.item);
                                     // TODO;
                                     break;
                                 case MenuItem.EType.PointCloud: