bruce-cesium 5.7.9 → 5.8.1

package/dist/lib/rendering/render-managers/entities/entities-render-manager.js

@@ -0,0 +1,999 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitiesRenderManager = void 0;
+const bruce_models_1 = require("bruce-models");
+const Cesium = require("cesium");
+const entity_render_engine_1 = require("../../entity-render-engine");
+const visuals_register_1 = require("../../visuals-register");
+const render_manager_1 = require("../render-manager");
+const point_clustering_1 = require("../common/point-clustering");
+const js_utils_1 = require("../../../internal/js-utils");
+const simplify_geometry_1 = require("../../../utils/simplify-geometry");
+const BATCH_SIZE = 500;
+const CHECK_BATCH_SIZE = 250;
+function getValue(viewer, obj) {
+    if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
+        let date = viewer.scene.lastRenderTime;
+        if (!date) {
+            date = viewer.clock.currentTime;
+        }
+        return obj.getValue(date);
+    }
+    return obj;
+}
+function colorToCColor(color) {
+    return new Cesium.Color(color.red ? color.red / 255 : 0, color.green ? color.green / 255 : 0, color.blue ? color.blue / 255 : 0, color.alpha);
+}
+function getShowDebugBounds() {
+    if (!window) {
+        return false;
+    }
+    let showBounds = window === null || window === void 0 ? void 0 : window.ENTITIES_RENDER_MANAGER_SHOW_BOUNDS;
+    if (showBounds) {
+        return true;
+    }
+    if (window.location.search) {
+        const params = new URLSearchParams(window.location.search);
+        showBounds = params.get("debugScanBounds");
+    }
+    return showBounds == "true" || showBounds == "1" || showBounds == "yes";
+}
+/**
+ * Manager for rendering Bruce entities.
+ * This will request entities based on setup menu item filter.
+ */
+var EntitiesRenderManager;
+(function (EntitiesRenderManager) {
+    class Manager {
+        get Disposed() {
+            return this.disposed;
+        }
+        constructor(params) {
+            this.getter = null;
+            this.getterSub = null;
+            this.disposed = false;
+            this.renderedEntities = {};
+            this.entityCheckQueue = null;
+            this.entityCheckQueueIds = [];
+            this.entityCheckRemoval = null;
+            this.isRunningCheck = false;
+            this.viewMonitorRemoval = null;
+            this.renderQueue = [];
+            this.renderQueueInterval = null;
+            this.sources = [];
+            // Highly experimental flag to try improve rendering large sets of polygons and polylines.
+            // Many things are not supported when this is enabled.
+            this.useGeojson = false;
+            // Zoom control to reference.
+            this.zoomControl = [];
+            // Scenario for retrieving Entities.
+            this.scenario = null;
+            // Type IDs that we'll allow to be rendered when receiving Entities.
+            // This might be exactly the Menu Item Type ID because of local data sources.
+            this.allowedTypeIDs = [];
+            const { viewer, apiGetter, monitor, item, register: visualsManager, sharedGetters } = params;
+            this.viewer = viewer;
+            this.sharedGetters = sharedGetters;
+            this.monitor = monitor;
+            this.apiGetter = apiGetter;
+            this.item = item;
+            this.visualsManager = visualsManager;
+            this.useGeojson = item.renderAsGeojson == true;
+            if (item.enableClustering) {
+                this.clustering = new point_clustering_1.PointClustering(this.visualsManager, this.item.id);
+            }
+        }
+        Init(params) {
+            if (this.disposed) {
+                throw (new Error("This item is disposed."));
+            }
+            if (params === null || params === void 0 ? void 0 : params.item) {
+                this.item = params.item;
+            }
+            (async () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                if (this.disposed) {
+                    return;
+                }
+                try {
+                    // Reset allowed list if there's change.
+                    if (((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a["EntityType.ID"]) && !this.allowedTypeIDs.includes((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b["EntityType.ID"])) {
+                        this.allowedTypeIDs = [];
+                        if ((_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c["EntityType.ID"]) {
+                            this.allowedTypeIDs.push((_d = this.item.BruceEntity) === null || _d === void 0 ? void 0 : _d["EntityType.ID"]);
+                        }
+                    }
+                    if (this.disposed) {
+                        return;
+                    }
+                    this.zoomControl = this.item.CameraZoomSettings;
+                    if (!((_e = this.zoomControl) === null || _e === void 0 ? void 0 : _e.length)) {
+                        this.zoomControl = [
+                            {
+                                MinZoom: 0,
+                                MaxZoom: 200000,
+                                DisplayType: bruce_models_1.ZoomControl.EDisplayType.Model3D,
+                                LODCategoryID: "glb",
+                                LODLevel: 0,
+                                StyleID: 0
+                            }
+                        ];
+                    }
+                    this.renderPriority = this.item.renderPriority;
+                    if (this.renderPriority == null) {
+                        this.renderPriority = 1;
+                    }
+                    if (this.useGeojson && this.zoomControl.length > 1) {
+                        console.warn("Geojson rendering does not support multiple zoom controls. Only the first one will be used.");
+                        this.zoomControl = [this.zoomControl[0]];
+                    }
+                    this.scenario = (_f = this.item.BruceEntity) === null || _f === void 0 ? void 0 : _f.Scenario;
+                    const isTagItem = Boolean(this.item.BruceEntity.ExpandLayers);
+                    let tagsToRender = isTagItem ? this.item.BruceEntity.SelectedExpandLayers : null;
+                    if (!tagsToRender) {
+                        tagsToRender = [];
+                    }
+                    tagsToRender = [].concat(tagsToRender);
+                    const shouldRender = !isTagItem || tagsToRender.length > 0;
+                    this.unsetGetter();
+                    (_g = this.viewMonitorRemoval) === null || _g === void 0 ? void 0 : _g.call(this);
+                    this.viewMonitorRemoval = null;
+                    (_h = this.entityCheckQueue) === null || _h === void 0 ? void 0 : _h.Dispose();
+                    this.entityCheckQueue = null;
+                    clearInterval(this.renderQueueInterval);
+                    this.renderQueueInterval = null;
+                    this.renderQueue = [];
+                    // Remove just the ones that shouldn't be rendered.
+                    // Eg: for a tag menu item we can see what tags are selected and only render those.
+                    if (shouldRender) {
+                        this.visualsManager.RemoveRegos({
+                            menuItemId: this.item.id,
+                            retainTagIds: tagsToRender
+                        });
+                        (_j = this.clustering) === null || _j === void 0 ? void 0 : _j.Dispose();
+                    }
+                    else {
+                        this.visualsManager.RemoveRegos({
+                            menuItemId: this.item.id
+                        });
+                        (_k = this.clustering) === null || _k === void 0 ? void 0 : _k.Dispose();
+                        return;
+                    }
+                    if (this.item.enableClustering) {
+                        this.clustering = new point_clustering_1.PointClustering(this.visualsManager, this.item.id, (_l = this.item) === null || _l === void 0 ? void 0 : _l.clustering);
+                    }
+                    this.setGetter();
+                    this.viewMonitorRemoval = this.monitor.Updated().Subscribe(() => {
+                        this.entityCheckQueue.Call();
+                    });
+                    this.entityCheckQueue = new bruce_models_1.DelayQueue(() => {
+                        // Don't bother checking for zoom control changes if we only have 1 item.
+                        // We'll let Cesium handle hide/show at max zoom range. 
+                        const shouldCheck = this.zoomControl && this.zoomControl.length > 1;
+                        if (shouldCheck) {
+                            this.doEntityCheck(Object.keys(this.renderedEntities));
+                        }
+                    }, 3000);
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            })();
+        }
+        /**
+         * Updates allowedTypeIDs values based in incoming data.
+         * We might request 'x' Entity Type, but get 'y' Entities due to local Data Sources.
+         * So we'll dynamically construct allowed type IDs to help filter out unwanted Entities from further ReRender calls.
+         * @param typeSources
+         * @param entities
+         */
+        updateAllowedTypeIDs(typeSources, entities) {
+            var _a, _b;
+            const sourceLookup = new Map();
+            if (typeSources) {
+                for (const source of typeSources) {
+                    sourceLookup.set(source.ID, source);
+                }
+            }
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const typeId = (_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"];
+                if (!typeId || this.allowedTypeIDs.includes(typeId)) {
+                    continue;
+                }
+                // If an Entity is not from the allowed Entity Type, but has a source matching it, then it's allowed.
+                // Therefor we will add it to the allowedTypeIDs list.
+                if (!((_b = entity.Bruce["Outline"]) === null || _b === void 0 ? void 0 : _b.length)) {
+                    continue;
+                }
+                const outlineItems = entity.Bruce["Outline"];
+                for (const item of outlineItems) {
+                    if (!item["EntityType.Source.ID"]) {
+                        continue;
+                    }
+                    const sRecord = sourceLookup.get(item["EntityType.Source.ID"]);
+                    if (!sRecord) {
+                        continue;
+                    }
+                    if (sRecord["EntityType.ID"] && this.allowedTypeIDs.includes(sRecord["EntityType.ID"])) {
+                        const toAddTypeId = sRecord["Source.EntityType.ID"];
+                        if (toAddTypeId && !this.allowedTypeIDs.includes(toAddTypeId)) {
+                            this.allowedTypeIDs.push(toAddTypeId);
+                        }
+                    }
+                }
+            }
+        }
+        setGetter() {
+            var _a, _b, _c;
+            this.unsetGetter();
+            const isTagItem = Boolean(this.item.BruceEntity.ExpandLayers);
+            let tagsToRender = isTagItem ? this.item.BruceEntity.SelectedExpandLayers : null;
+            if (!tagsToRender) {
+                tagsToRender = [];
+            }
+            tagsToRender = [].concat(tagsToRender);
+            this.getter = this.sharedGetters.GetOrCreateFilterGetter({
+                api: this.apiGetter.getApi(),
+                attrFilter: (_a = this.item.BruceEntity.Filter) !== null && _a !== void 0 ? _a : {},
+                batchSize: BATCH_SIZE,
+                typeId: this.item.BruceEntity["EntityType.ID"],
+                monitor: this.monitor,
+                viewer: this.viewer,
+                // Unfortunately this searches as an "AND" rather than "OR" which does not meet our needs here.
+                // So for multiple tags we'll manually sort on UI end...
+                tagIds: (tagsToRender === null || tagsToRender === void 0 ? void 0 : tagsToRender.length) ? tagsToRender : [],
+                debugShowBounds: getShowDebugBounds(),
+                cdn: this.item.cdnEnabled,
+                historic: (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historic,
+                historicAttrKey: this.item.BruceEntity.historicAttrKey,
+                historicInterpolation: this.item.historicInterpolation,
+                schemaId: (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.schemaId,
+                scenario: this.scenario
+            });
+            const minMax = render_manager_1.RenderManager.GetZoomMinMax({
+                zoomControl: this.zoomControl
+            });
+            this.getter.IncludeMenuItem(this.item.id, this.item.BruceEntity["EntityType.ID"], (tagsToRender === null || tagsToRender === void 0 ? void 0 : tagsToRender.length) ? tagsToRender : [], minMax[0], minMax[1]);
+            this.getterSub = this.getter.OnUpdate.Subscribe((data) => {
+                var _a;
+                if (!((_a = data === null || data === void 0 ? void 0 : data.entities) === null || _a === void 0 ? void 0 : _a.length)) {
+                    return;
+                }
+                this.updateAllowedTypeIDs(data.entityTypeSources, data.entities);
+                if (isTagItem) {
+                    this.distributeForRender(data.entities.filter((entity) => {
+                        let entityTags = entity.Bruce["Layer.ID"];
+                        if (!entityTags) {
+                            entityTags = [];
+                        }
+                        return entityTags.some((tag) => {
+                            return tagsToRender.indexOf(tag) !== -1;
+                        });
+                    }));
+                }
+                else {
+                    this.distributeForRender(data.entities);
+                }
+            });
+        }
+        unsetGetter() {
+            var _a, _b;
+            (_a = this.getter) === null || _a === void 0 ? void 0 : _a.ExcludeMenuItem(this.item.id);
+            this.getter = null;
+            (_b = this.getterSub) === null || _b === void 0 ? void 0 : _b.call(this);
+            this.getterSub = null;
+        }
+        Dispose() {
+            if (this.disposed) {
+                return;
+            }
+            this.doDispose();
+        }
+        doDispose() {
+            var _a, _b, _c;
+            this.unsetGetter();
+            this.disposed = true;
+            this.visualsManager.RemoveRegos({
+                menuItemId: this.item.id
+            });
+            (_a = this.entityCheckRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.viewMonitorRemoval) === null || _b === void 0 ? void 0 : _b.call(this);
+            clearInterval(this.renderQueueInterval);
+            this.renderQueue = [];
+            (_c = this.clustering) === null || _c === void 0 ? void 0 : _c.Dispose();
+            this.clustering = null;
+            for (let i = 0; i < this.sources.length; i++) {
+                const source = this.sources[i];
+                this.viewer.dataSources.remove(source);
+            }
+            this.sources = [];
+        }
+        async ReRender(params) {
+            var _a, _b;
+            let { entityIds, force, entities } = params;
+            if (entities && !entityIds) {
+                entityIds = entities.map(x => { var _a; return (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID; });
+            }
+            if (entityIds == null) {
+                entityIds = Object.keys(this.renderedEntities);
+            }
+            this.visualsManager.MarkStale({
+                entityIds: entityIds,
+                menuItemIds: [this.item.id]
+            });
+            if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                entities = [].concat(entities).filter(x => { var _a; return entityIds.includes((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID); });
+            }
+            // Forcing to skip queue and to render immediately.
+            if (force) {
+                if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                    this.renderEntities(entities, true);
+                }
+                else {
+                    try {
+                        const data = await bruce_models_1.Entity.GetListByIds({
+                            api: this.apiGetter.getApi(),
+                            entityIds,
+                            historicKey: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey,
+                            historicPoint: this.viewer.clock.currentTime.toString(),
+                            schemaId: (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.schemaId,
+                            migrated: true
+                        });
+                        this.renderEntities(data.entities, true);
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+            }
+            else {
+                if (entities === null || entities === void 0 ? void 0 : entities.length) {
+                    this.distributeForRender(entities);
+                }
+                else {
+                    await this.doEntityCheck(entityIds);
+                }
+            }
+        }
+        UpdateSettings(params) {
+            const { zoomControl: CameraZoomSettings, queueRerender, scenario } = params;
+            if (this.disposed) {
+                return;
+            }
+            let changed = false;
+            if (CameraZoomSettings === null || CameraZoomSettings === void 0 ? void 0 : CameraZoomSettings.length) {
+                this.zoomControl = CameraZoomSettings;
+                if (this.renderAsGeojson && this.zoomControl.length > 1) {
+                    console.warn("Geojson rendering does not support multiple zoom controls. Only the first one will be used.");
+                    this.zoomControl = [this.zoomControl[0]];
+                }
+                changed = true;
+            }
+            if (scenario != null) {
+                this.scenario = scenario;
+                changed = true;
+            }
+            if (changed) {
+                this.setGetter();
+            }
+            if (queueRerender != false) {
+                const entityIds = Object.keys(this.renderedEntities);
+                this.visualsManager.MarkStale({
+                    entityIds: entityIds,
+                    menuItemIds: [this.item.id]
+                });
+                this.doEntityCheck(entityIds);
+            }
+        }
+        async doEntityCheck(ids) {
+            if (this.isRunningCheck) {
+                this.entityCheckQueueIds = this.entityCheckQueueIds.concat(ids);
+                this.entityCheckQueue.Call();
+                return;
+            }
+            ids.concat(this.entityCheckQueueIds);
+            this.entityCheckQueueIds = [];
+            ids = ids.filter((id, index) => {
+                return ids.indexOf(id) === index;
+            });
+            this.isRunningCheck = true;
+            const api = this.apiGetter.getApi();
+            try {
+                if (this.disposed) {
+                    return;
+                }
+                if (ids.length > 0) {
+                    const checkBatch = async () => {
+                        var _a, _b;
+                        const entityIds = ids.splice(0, CHECK_BATCH_SIZE);
+                        const { entities } = await bruce_models_1.Entity.GetListByIds({
+                            api,
+                            entityIds,
+                            historicKey: (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historicAttrKey,
+                            historicPoint: this.viewer.clock.currentTime.toString(),
+                            schemaId: (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.schemaId,
+                            migrated: true
+                        });
+                        if (this.disposed) {
+                            return;
+                        }
+                        this.distributeForRender(entities);
+                    };
+                    while (ids.length > 0) {
+                        await checkBatch();
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            this.isRunningCheck = false;
+        }
+        distributeForRender(entities) {
+            this.renderQueue = this.renderQueue.concat(entities);
+            if (!this.renderQueueInterval && this.renderQueue.length) {
+                this.renderQueueInterval = setInterval(() => {
+                    const batch = this.renderQueue.splice(0, BATCH_SIZE);
+                    this.renderEntities(batch);
+                    if (this.renderQueue.length <= 0) {
+                        clearInterval(this.renderQueueInterval);
+                        this.renderQueueInterval = null;
+                    }
+                }, 50);
+            }
+        }
+        async renderEntities(entities, force = false) {
+            var _a;
+            try {
+                if (this.disposed || this.viewer.isDestroyed() || !(entities === null || entities === void 0 ? void 0 : entities.length)) {
+                    return;
+                }
+                // Ensuring a re-render call with improper entity ids doesn't cause them to render here.
+                if (this.allowedTypeIDs) {
+                    const typeId = (_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a["EntityType.ID"];
+                    if (typeId) {
+                        entities = entities.filter(x => { var _a; return this.allowedTypeIDs.includes((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"]); });
+                    }
+                }
+                if (this.useGeojson) {
+                    const zoomItem = this.zoomControl[0];
+                    if (zoomItem.DisplayType == bruce_models_1.ZoomControl.EDisplayType.Point) {
+                        // We'll just render these as individuals since we don't support point geojson.
+                        await this.renderAsIndividuals(entities, force);
+                    }
+                    else {
+                        await this.renderAsGeojson(entities, force);
+                    }
+                }
+                else {
+                    await this.renderAsIndividuals(entities, force);
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        /**
+         * Our optimized and more stable path.
+         * We construct a geojson that we draw in one go.
+         * @param entities
+         * @param force TODO: This should re-render entities that are already rendered.
+         */
+        async renderAsGeojson(entities, force) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            entities = entities.filter((entity) => {
+                var _a;
+                return !this.renderedEntities[(_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID];
+            });
+            // Mark these as rendered.
+            entities.forEach((entity) => {
+                var _a;
+                this.renderedEntities[(_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID] = true;
+            });
+            // This process only supports a single zoom control item.
+            const zoomItem = this.zoomControl[0];
+            // If we're after 3d models then we'll check if there are LODs and render those as individuals.
+            if (zoomItem.DisplayType == bruce_models_1.ZoomControl.EDisplayType.Model3D && entities.length) {
+                const { lods } = await bruce_models_1.EntityLod.GetLods({
+                    api: this.apiGetter.getApi(),
+                    filter: {
+                        externalSources: false,
+                        Items: entities.map(x => {
+                            var _a, _b;
+                            return {
+                                entityId: (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID,
+                                categoryId: (_b = zoomItem.LODCategoryID) !== null && _b !== void 0 ? _b : "GLB",
+                                group: "DEFAULT",
+                                level: Number(zoomItem.LODLevel)
+                            };
+                        }),
+                        strict: false
+                    }
+                });
+                if (this.disposed) {
+                    this.doDispose();
+                    return;
+                }
+                const withLods = lods.filter(x => x.entityId && !!x.clientFileId).map(x => x.entityId);
+                const individuals = entities.filter((entity) => {
+                    var _a;
+                    return withLods.includes((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID);
+                });
+                if (individuals.length) {
+                    this.renderAsIndividuals(individuals, force);
+                }
+                // Now we proceed with what is left.
+                entities = entities.filter((entity) => {
+                    var _a;
+                    return !withLods.includes((_a = entity.Bruce) === null || _a === void 0 ? void 0 : _a.ID);
+                });
+            }
+            if (!entities.length) {
+                return;
+            }
+            let style = null;
+            if ((zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID) && zoomItem.StyleID != -1) {
+                try {
+                    style = (_a = (await bruce_models_1.Style.Get({
+                        api: this.apiGetter.getApi(),
+                        styleId: zoomItem === null || zoomItem === void 0 ? void 0 : zoomItem.StyleID
+                    })).style) === null || _a === void 0 ? void 0 : _a.Settings;
+                }
+                // Probably deleted.
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            let entityTypeId = (_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b["EntityType.ID"];
+            if (!entityTypeId) {
+                entityTypeId = (_d = (_c = entities.find(x => { var _a; return !!((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a["EntityType.ID"]); })) === null || _c === void 0 ? void 0 : _c.Bruce) === null || _d === void 0 ? void 0 : _d["EntityType.ID"];
+            }
+            // Getting type regardless cause it's needed for name calculations.
+            let entityType;
+            if (entityTypeId) {
+                // Try using the Entity Type default if one is specified in the menu item.
+                try {
+                    entityType = (_e = (await bruce_models_1.EntityType.Get({
+                        entityTypeId: entityTypeId,
+                        api: this.apiGetter.getApi()
+                    }))) === null || _e === void 0 ? void 0 : _e.entityType;
+                    if (!style && entityType) {
+                        if (entityType["DisplaySetting.ID"] && entityType["DisplaySetting.ID"] > 0) {
+                            style = (_f = (await bruce_models_1.Style.Get({
+                                api: this.apiGetter.getApi(),
+                                styleId: entityType["DisplaySetting.ID"]
+                            })).style) === null || _f === void 0 ? void 0 : _f.Settings;
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }
+            const pStyle = (_g = style === null || style === void 0 ? void 0 : style.polygonStyle) !== null && _g !== void 0 ? _g : {};
+            const lStyle = (_h = style === null || style === void 0 ? void 0 : style.polylineStyle) !== null && _h !== void 0 ? _h : {};
+            const polygonsClamped = ((_j = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _j === void 0 ? void 0 : _j.id) == null ? true : ((_k = pStyle === null || pStyle === void 0 ? void 0 : pStyle.altitudeOption) === null || _k === void 0 ? void 0 : _k.id) == 0;
+            const bFillColor = bruce_models_1.Calculator.GetColor(pStyle.fillColor, {}, []);
+            const cFillColor = bFillColor ? colorToCColor(bFillColor) : Cesium.Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
+            const bLineColor = bruce_models_1.Calculator.GetColor(pStyle.lineColor, {}, []);
+            const cLineColor = bLineColor ? colorToCColor(bLineColor) : Cesium.Color.fromCssColorString("rgba(80, 80, 80, 0.8)");
+            let lineWidthPx = pStyle.lineWidth ? bruce_models_1.Calculator.GetNumber(pStyle.lineWidth, {}, []) : null;
+            if (lineWidthPx == null) {
+                lineWidthPx = 1;
+            }
+            lineWidthPx = (0, js_utils_1.EnsureNumber)(lineWidthPx);
+            if (lineWidthPx < 0.01) {
+                lineWidthPx = 0;
+            }
+            lineWidthPx = Math.round(lineWidthPx);
+            // If we are flagged to optimize then we'll run through and simplify each entity's geometry.
+            if (this.item.optimizeGeometry) {
+                for (let i = 0; i < entities.length; i++) {
+                    let entity = entities[i];
+                    let geometry = bruce_models_1.Entity.GetValue({
+                        entity: entity,
+                        path: ["Bruce", "VectorGeometry"]
+                    });
+                    if (geometry) {
+                        if (this.item.optimizeMinPoints == null) {
+                            this.item.optimizeMinPoints = 500;
+                        }
+                        if (simplify_geometry_1.SimplifyGeometry.CountPoints(geometry, this.item.optimizeMinPoints) >= this.item.optimizeMinPoints) {
+                            if (this.item.optimizeTolerance == null) {
+                                this.item.optimizeTolerance = 0.00001;
+                            }
+                            const optimized = simplify_geometry_1.SimplifyGeometry.Simplify(entity.Bruce.ID, geometry, this.item.optimizeTolerance);
+                            if (optimized) {
+                                // Dereference the Entity object now that we have done a destructive operation.
+                                entity = Object.assign({}, entity);
+                                entity.Bruce = Object.assign({}, entity.Bruce);
+                                entities[i] = entity;
+                                // Continue on with the rendering using the optimized geometry.
+                                geometry = optimized;
+                            }
+                        }
+                    }
+                    // We are using the new path.
+                    // This ensures we don't have a duplicate.
+                    entity.geometry = null;
+                    entity.Bruce.VectorGeometry = geometry;
+                }
+            }
+            const collection = {
+                features: [],
+                type: "FeatureCollection"
+            };
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const feature = bruce_models_1.Geometry.ToGeoJsonFeature({
+                    geometry: entity.Bruce.VectorGeometry,
+                    noAltitude: polygonsClamped && lineWidthPx <= 0,
+                    altitude: lineWidthPx > 0 && polygonsClamped ? 1 : null,
+                    properties: {
+                        ...entity,
+                        Bruce: {
+                            ...entity.Bruce,
+                            // Exclude as we just converted it to geojson.
+                            VectorGeometry: null
+                        }
+                    }
+                });
+                if (feature) {
+                    collection.features.push(feature);
+                }
+            }
+            // Anything that failed to turn into geojson or points we'll render as individuals.
+            const individuals = entities.filter((entity) => {
+                const feature = collection.features.find(x => { var _a, _b; return ((_b = (_a = x.properties) === null || _a === void 0 ? void 0 : _a.Bruce) === null || _b === void 0 ? void 0 : _b.ID) == entity.Bruce.ID; });
+                if (!feature) {
+                    return true;
+                }
+                if (feature.geometry.type == "Point") {
+                    return true;
+                }
+                return false;
+            });
+            if (individuals.length) {
+                this.renderAsIndividuals(individuals, force);
+            }
+            // Filter out points (the ones we just rendered as individuals).
+            collection.features = collection.features.filter(x => x.geometry.type != "Point");
+            // If there is nothing to render now, return.
+            if (!collection.features.length) {
+                return;
+            }
+            const source = await Cesium.GeoJsonDataSource.load(collection, {
+                stroke: cLineColor,
+                fill: cFillColor,
+                strokeWidth: lineWidthPx,
+                clampToGround: lineWidthPx <= 0 && polygonsClamped
+            });
+            this.viewer.dataSources.add(source);
+            this.sources.push(source);
+            if (this.disposed) {
+                this.doDispose();
+                return;
+            }
+            const groups = [];
+            /**
+             * Applies individual styling to a rendered entity.
+             * This will exclude tag styling for now since it's harder to load that on the fly.
+             * @param thing
+             * @param entityId
+             * @param data
+             * @returns
+             */
+            const applyStyle = (thing, entityId, data) => {
+                if (thing.polygon) {
+                    const bFillColor = bruce_models_1.Calculator.GetColor(pStyle.fillColor, data, []);
+                    const cFillColor = bFillColor ? colorToCColor(bFillColor) : Cesium.Color.fromCssColorString("rgba(139, 195, 74, 0.8)");
+                    const bLineColor = bruce_models_1.Calculator.GetColor(pStyle.lineColor, data, []);
+                    const cLineColor = bLineColor ? colorToCColor(bLineColor) : Cesium.Color.fromCssColorString("rgba(80, 80, 80, 0.8)");
+                    let width = pStyle.lineWidth ? bruce_models_1.Calculator.GetNumber(pStyle.lineWidth, data, []) : null;
+                    if (width == null) {
+                        width = 1;
+                    }
+                    width = (0, js_utils_1.EnsureNumber)(width);
+                    if (width < 0.01) {
+                        width = 0;
+                    }
+                    let curFillColor = getValue(this.viewer, thing.polygon.material);
+                    if (curFillColor && curFillColor instanceof Cesium.ColorMaterialProperty) {
+                        curFillColor = curFillColor.color;
+                    }
+                    let curLineColor = getValue(this.viewer, thing.polygon.outlineColor);
+                    if (curLineColor && curLineColor instanceof Cesium.ColorMaterialProperty) {
+                        curLineColor = curLineColor.color;
+                    }
+                    const curWidth = getValue(this.viewer, thing.polygon.outlineWidth);
+                    if ((curFillColor instanceof Cesium.Color && curFillColor.equals(cFillColor)) &&
+                        (curLineColor instanceof Cesium.Color && curLineColor.equals(cLineColor)) &&
+                        curWidth == width) {
+                        return;
+                    }
+                    thing.polygon.material = new Cesium.ColorMaterialProperty(cFillColor);
+                    thing.polygon.outlineColor = new Cesium.ConstantProperty(cLineColor);
+                    thing.polygon.outlineWidth = new Cesium.ConstantProperty(width);
+                }
+                else if (thing.polyline) {
+                    const bColor = lStyle.lineColor ? bruce_models_1.Calculator.GetColor(lStyle.lineColor, data, []) : null;
+                    const cColor = bColor ? colorToCColor(bColor) : Cesium.Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
+                    let width = lStyle.lineWidth ? bruce_models_1.Calculator.GetNumber(lStyle.lineWidth, data, []) : null;
+                    if (width == null) {
+                        width = 2;
+                    }
+                    width = (0, js_utils_1.EnsureNumber)(width);
+                    if (width < 0.01) {
+                        width = 0;
+                    }
+                    let curColor = getValue(this.viewer, thing.polyline.material);
+                    if (curColor && curColor instanceof Cesium.ColorMaterialProperty) {
+                        curColor = curColor.color;
+                    }
+                    const curWidth = getValue(this.viewer, thing.polyline.width);
+                    if ((curColor instanceof Cesium.Color && curColor.equals(cColor)) &&
+                        curWidth == width) {
+                        return;
+                    }
+                    thing.polyline.material = new Cesium.ColorMaterialProperty(cColor);
+                    thing.polyline.width = new Cesium.ConstantProperty(width);
+                }
+            };
+            let toForceUpdate = [];
+            /**
+             * Registers a given cesium entity produced from rendering geojson.
+             * Since one nextspace entity can have multiple cesium entities, there is special logic to group them together.
+             * @param thing
+             * @returns
+             */
+            const register = (thing) => {
+                var _a, _b, _c, _d, _e, _f;
+                // See if the cesium entity already exists in a group.
+                let group = groups.find((x) => { var _a; return ((_a = x.visual) === null || _a === void 0 ? void 0 : _a.id) == thing.id || x.siblings.find(x => (x === null || x === void 0 ? void 0 : x.id) == thing.id); });
+                if (group) {
+                    return;
+                }
+                const metadata = getValue(this.viewer, thing === null || thing === void 0 ? void 0 : thing.properties);
+                const entityId = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.Bruce) === null || _a === void 0 ? void 0 : _a.ID;
+                if (!entityId) {
+                    return;
+                }
+                // Find group for the nextspace entity ID.
+                group = groups.find((x) => x.entityId == entityId);
+                // No group yet. We can designate this as the primary entity and create a new group for it.
+                if (!group) {
+                    group = {
+                        entityId: entityId,
+                        visual: thing,
+                        tagIds: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.Bruce) === null || _b === void 0 ? void 0 : _b["Layer.ID"],
+                        entityTypeId: (_c = metadata === null || metadata === void 0 ? void 0 : metadata.Bruce) === null || _c === void 0 ? void 0 : _c["EntityType.ID"],
+                        siblings: [],
+                        data: entities.find(x => { var _a; return ((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.ID) == entityId; }),
+                        rego: null
+                    };
+                    groups.push(group);
+                    applyStyle(thing, entityId, group.data);
+                    const rego = {
+                        canEdit: true,
+                        entityId: entityId,
+                        menuItemId: this.item.id,
+                        menuItemType: this.item.Type,
+                        visual: thing,
+                        priority: this.renderPriority,
+                        entityTypeId: group.entityTypeId,
+                        accountId: this.apiGetter.accountId,
+                        tagIds: group.tagIds ? [].concat(group.tagIds) : [],
+                        name: entityType ? (_d = bruce_models_1.Entity.CalculateName({
+                            entity: group.data,
+                            type: entityType,
+                            defaultToId: false
+                        })) !== null && _d !== void 0 ? _d : "Unnamed Entity" : "Unnamed Entity",
+                        cdn: this.item.cdnEnabled,
+                        collection: source.entities,
+                        outline: (_f = (_e = group.data) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.Outline,
+                    };
+                    group.rego = rego;
+                    this.visualsManager.AddRego({
+                        rego,
+                        requestRender: false
+                    });
+                }
+                // Found a group. We flag this as a sibling entity of the primary.
+                else {
+                    applyStyle(thing, entityId, group.data);
+                    group.siblings.push(thing);
+                    group.visual._siblingGraphics = group.siblings;
+                    thing._parentEntity = group.visual;
+                    if (group.rego) {
+                        this.visualsManager.RefreshMark({
+                            rego: group.rego
+                        });
+                        if (!toForceUpdate.includes(entityId)) {
+                            toForceUpdate.push(entityId);
+                        }
+                    }
+                }
+            };
+            const sEntities = source.entities.values;
+            for (let i = 0; i < sEntities.length; i++) {
+                const cEntity = sEntities[i];
+                register(cEntity);
+            }
+            if (toForceUpdate.length) {
+                this.visualsManager.ForceUpdate({
+                    entityIds: toForceUpdate,
+                    refreshColors: true,
+                    requestRender: false
+                });
+            }
+            this.viewer.scene.requestRender();
+        }
+        /**
+         * Our default path.
+         * We render each entity individually.
+         * @param entities
+         * @param force
+         * @returns
+         */
+        async renderAsIndividuals(entities, force = false) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            // Entity ID -> historic records array.
+            // We load this as extra information when rendering historic records.
+            // This way we know what to animate towards as time changes.
+            let entitiesHistoric = {};
+            if ((((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || ((_b = this.item.BruceEntity) === null || _b === void 0 ? void 0 : _b.historicAttrKey)) && entities.length) {
+                // Interpolating.
+                // We will allow non-historic Entities as long as they have historic data in the range.
+                if (this.item.historicInterpolation) {
+                    // We'll add/remove 1 second to ensure we cover all records.
+                    const startTmp = Cesium.JulianDate.toDate(this.viewer.clock.startTime);
+                    const stopTmp = Cesium.JulianDate.toDate(this.viewer.clock.stopTime);
+                    const startStr = new Date(startTmp.getTime() - 1000).toISOString();
+                    const stopStr = new Date(stopTmp.getTime() + 1000).toISOString();
+                    const historicData = await bruce_models_1.EntityHistoricData.GetList({
+                        attrKey: this.item.BruceEntity.historicAttrKey,
+                        dateTimeFrom: startStr,
+                        dateTimeTo: stopStr,
+                        entityIds: entities.map(x => x.Bruce.ID),
+                        api: this.apiGetter.getApi()
+                    });
+                    entitiesHistoric = historicData.recordsByIds;
+                    // Remove ones with no historicAttrKey and no historic data.
+                    const toRemoveIds = entities.filter(x => { var _a, _b; return !((_b = (_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.Outline) === null || _b === void 0 ? void 0 : _b.length) && !entitiesHistoric[x.Bruce.ID]; }).map(x => x.Bruce.ID);
+                    for (let i = 0; i < toRemoveIds.length; i++) {
+                        const removeId = toRemoveIds[i];
+                        this.visualsManager.RemoveRegos({
+                            entityId: removeId,
+                            menuItemId: this.item.id,
+                            requestRender: false
+                        });
+                        (_c = this.clustering) === null || _c === void 0 ? void 0 : _c.RemoveEntity(removeId, false);
+                    }
+                    entities = entities.filter(x => !toRemoveIds.includes(x.Bruce.ID));
+                }
+                // Not interpolating.
+                // So we'll see if the Entities have a historic key or not.
+                else {
+                    const toRemoveIds = entities.filter(x => { var _a; return !((_a = x.Bruce) === null || _a === void 0 ? void 0 : _a.Outline); }).map(x => x.Bruce.ID);
+                    for (let i = 0; i < toRemoveIds.length; i++) {
+                        const removeId = toRemoveIds[i];
+                        this.visualsManager.RemoveRegos({
+                            entityId: removeId,
+                            menuItemId: this.item.id,
+                            requestRender: false
+                        });
+                        (_d = this.clustering) === null || _d === void 0 ? void 0 : _d.RemoveEntity(removeId, false);
+                    }
+                    entities = entities.filter(x => !toRemoveIds.includes(x.Bruce.ID));
+                }
+            }
+            if (this.disposed) {
+                this.doDispose();
+                return;
+            }
+            const { updated, entities: cEntities } = await entity_render_engine_1.EntityRenderEngine.Render({
+                viewer: this.viewer,
+                apiGetter: this.apiGetter,
+                entities: entities,
+                menuItemId: this.item.id,
+                visualRegister: this.visualsManager,
+                zoomControl: this.zoomControl,
+                entitiesHistoric: entitiesHistoric,
+                entityHistoricDrawTrack: this.item.historicDrawTrack,
+                force,
+                optimizeGeometry: this.item.optimizeGeometry,
+                optimizeMinPoints: this.item.optimizeMinPoints,
+                optimizeTolerance: this.item.optimizeTolerance,
+            });
+            if (this.disposed) {
+                this.doDispose();
+                return;
+            }
+            for (let i = 0; i < entities.length; i++) {
+                const entity = entities[i];
+                const id = entity.Bruce.ID;
+                const cEntity = cEntities.get(id);
+                this.renderedEntities[id] = !!cEntity;
+                if (cEntity) {
+                    const rego = this.visualsManager.GetRego({
+                        entityId: id,
+                        menuItemId: this.item.id
+                    });
+                    // The baseline data source must be editable.
+                    const canEdit = !((_e = entity.Bruce.Outline) === null || _e === void 0 ? void 0 : _e.find(x => x.Baseline && !x.Editable));
+                    const visual = rego === null || rego === void 0 ? void 0 : rego.visual;
+                    if (!visual || visual != cEntity) {
+                        const wasClustered = this.clustering ? this.clustering.AddEntity(id, cEntity, false) : false;
+                        const tagIds = entity.Bruce["Layer.ID"];
+                        const rego = {
+                            canEdit: canEdit,
+                            entityId: id,
+                            schema: entity.Bruce.Schema,
+                            menuItemId: this.item.id,
+                            menuItemType: this.item.Type,
+                            visual: cEntity,
+                            priority: this.renderPriority,
+                            entityTypeId: entity.Bruce["EntityType.ID"],
+                            accountId: this.apiGetter.accountId,
+                            tagIds: tagIds ? [].concat(tagIds) : [],
+                            overrideShow: wasClustered ? false : null,
+                            name: cEntity.name,
+                            cdn: this.item.cdnEnabled,
+                            outline: entity.Bruce.Outline
+                        };
+                        this.visualsManager.AddRego({
+                            rego,
+                            requestRender: false
+                        });
+                    }
+                    else if (updated.get(id) && rego) {
+                        rego.name = cEntity.name;
+                        rego.visual = cEntity;
+                        rego.entityTypeId = entity.Bruce["EntityType.ID"];
+                        rego.tagIds = entity.Bruce["Layer.ID"] ? [].concat(entity.Bruce["Layer.ID"]) : [];
+                        rego.outline = (_f = entity.Bruce) === null || _f === void 0 ? void 0 : _f.Outline;
+                        rego.cdn = this.item.cdnEnabled;
+                        rego.schema = (_g = entity.Bruce) === null || _g === void 0 ? void 0 : _g.Schema;
+                        rego.canEdit = canEdit;
+                        // Marked as stale meaning some change was performed that requires a refresh.
+                        // This usually means a new sibling was added that we need to update.
+                        if (rego.stale) {
+                            // Ensure graphic + siblings are associated with register.
+                            this.visualsManager.RefreshMark({
+                                rego
+                            });
+                            // Refresh visuals.
+                            // This ensures newly created siblings are added to the scene.
+                            this.visualsManager.ForceUpdate({
+                                entityIds: [id],
+                                refreshColors: true,
+                                requestRender: false
+                            });
+                        }
+                        // We manually trigger an update event since the graphic was updated but not recreated.
+                        this.visualsManager.OnUpdate.Trigger({
+                            type: visuals_register_1.VisualsRegister.EVisualUpdateType.Update,
+                            entityId: id,
+                            rego: rego
+                        });
+                    }
+                }
+                else {
+                    this.visualsManager.RemoveRegos({
+                        entityId: id,
+                        menuItemId: this.item.id,
+                        requestRender: false
+                    });
+                    (_h = this.clustering) === null || _h === void 0 ? void 0 : _h.RemoveEntity(id, false);
+                }
+            }
+            this.viewer.scene.requestRender();
+            if (this.clustering && entities.length) {
+                this.clustering.Update();
+            }
+        }
+    }
+    EntitiesRenderManager.Manager = Manager;
+})(EntitiesRenderManager = exports.EntitiesRenderManager || (exports.EntitiesRenderManager = {}));
+//# sourceMappingURL=entities-render-manager.js.map