bruce-cesium 0.3.0 → 0.3.1

package/dist/bruce-cesium.umd.js

@@ -2866,6 +2866,286 @@
         SharedGetters.Cache = Cache;
     })(exports.SharedGetters || (exports.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 = Cesium.createOsmBuildings();
+                        this.cTileset.show = true;
+                        if (this.sourceId) {
+                            if (menuItem.ghostLoading == true) {
+                                this.cTileset.style = new Cesium.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 Cesium.Rectangle(Cesium.Math.toRadians(bounds.west), Cesium.Math.toRadians(bounds.south), Cesium.Math.toRadians(bounds.east), Cesium.Math.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 = Cesium.Cartographic.fromDegrees(featureLon, featureLat, 0);
+                                var isIn = Cesium.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 = Cesium.Cartesian3.fromDegrees(featureLon, featureLat, 0);
+                    var camPoint = this.monitor.GetTarget();
+                    var camPos = (camPoint === null || camPoint === void 0 ? void 0 : camPoint.latitude) ? Cesium.Cartesian3.fromDegrees(camPoint.longitude, camPoint.latitude, camPoint.altitude) : null;
+                    if (camPos && bruceModels.Cartes.ValidateCartes3(camPos) && bruceModels.Cartes.ValidateCartes3(pos)) {
+                        var distance = Cesium.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*/, bruceModels.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 = bruceModels.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 = {}));
+
     (function (MenuItemManager) {
         var Manager = /** @class */ (function () {
             function Manager(viewer, visualsRegister) {
@@ -2943,6 +3223,7 @@
                                         rItem.renderManager = new exports.TilesetCadRenderManager.Manager(this.viewer, this.visualsRegister, params.apiGetter, params.item);
                                         break;
                                     case bruceModels.MenuItem.EType.Osm:
+                                        rItem.renderManager = new TilesetOsmRenderManager.Manager(this.viewer, this.visualsRegister, params.apiGetter, this.sharedMonitor, params.item);
                                         // TODO;
                                         break;
                                     case bruceModels.MenuItem.EType.PointCloud: