bruce-cesium 7.3.8 → 7.4.0

package/dist/lib/rendering/render-managers/common/point-clustering.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PointClustering = void 0;
+exports.PointClustering = exports.PointClusterSize = exports.ClusterItems = void 0;
 const bruce_models_1 = require("bruce-models");
 const Cesium = require("cesium");
 const visuals_register_1 = require("../../visuals-register");
+const point_clustering_core_1 = require("./point-clustering-core");
+const drawing_utils_1 = require("../../../utils/drawing-utils");
+const cesium_entity_styler_1 = require("../../../utils/cesium-entity-styler");
+var point_clustering_core_2 = require("./point-clustering-core");
+Object.defineProperty(exports, "ClusterItems", { enumerable: true, get: function () { return point_clustering_core_2.ClusterItems; } });
 function GetValue(viewer, obj) {
     if (obj === null || obj === void 0 ? void 0 : obj.getValue) {
         let date = viewer.scene.lastRenderTime;
@@ -16,6 +21,8 @@ function GetValue(viewer, obj) {
 }
 class Point {
     constructor(lon, lat, id) {
+        this.radius = 0;
+        this.minDistance = 0;
         this.lon = lon;
         this.lat = lat;
         this.id = id;
@@ -33,8 +40,8 @@ class Circle {
         let xDist = Math.abs(range.x - this.x);
         let yDist = Math.abs(range.y - this.y);
         let r = this.radius;
-        let w = range.width;
-        let h = range.height;
+        let w = range.width / 2;
+        let h = range.height / 2;
         if (xDist > (w + r) || yDist > (h + r)) {
             return false;
         }
@@ -48,8 +55,7 @@ class Circle {
     Contains(point) {
         const dx = this.x - point.lon;
         const dy = this.y - point.lat;
-        const distance = Math.sqrt(dx * dx + dy * dy);
-        return distance <= this.radius;
+        return dx * dx + dy * dy <= this.radius * this.radius;
     }
 }
 class Rectangle {
@@ -86,13 +92,13 @@ class Quad {
         let y = this.boundary.y;
         let w = this.boundary.w / 2;
         let h = this.boundary.h / 2;
-        let ne = new Rectangle(x + w / 2, y - h / 2, w, h);
+        let ne = new Rectangle(x + w, y - h, w, h);
         this.northeast = new Quad(ne, this.capacity);
-        let nw = new Rectangle(x - w / 2, y - h / 2, w, h);
+        let nw = new Rectangle(x - w, y - h, w, h);
         this.northwest = new Quad(nw, this.capacity);
-        let se = new Rectangle(x + w / 2, y + h / 2, w, h);
+        let se = new Rectangle(x + w, y + h, w, h);
         this.southeast = new Quad(se, this.capacity);
-        let sw = new Rectangle(x - w / 2, y + h / 2, w, h);
+        let sw = new Rectangle(x - w, y + h, w, h);
         this.southwest = new Quad(sw, this.capacity);
         this.divided = true;
     }
@@ -100,7 +106,8 @@ class Quad {
         if (!this.boundary.Contains(point)) {
             return false;
         }
-        if (this.points.length < this.capacity) {
+        // Coincident points must terminate in a bucket rather than subdividing indefinitely.
+        if (this.points.length < this.capacity || this.boundary.w < 1e-10) {
             this.points.push(point);
             return true;
         }
@@ -330,496 +337,636 @@ function getClusterImage(params) {
     }
     return null;
 }
-const FORCE_UPDATE_BATCH_SIZE = 1000;
-const FORCE_UPDATE_BATCH_DELAY = 100;
-class PointClustering {
-    constructor(register, menuItemId, settings) {
-        this.minDistance = 5000;
-        this.minTotalCount = 0;
-        this.disposed = false;
-        this.registeredEntityIds = new Set();
-        // Queue to force update entities.
-        this.updateEntityQueue = [];
-        this.register = register;
-        this.viewer = register.Viewer;
-        this.menuItemId = menuItemId;
-        let boundary = new Rectangle(0, 0, 360, 180);
-        this.quadTree = new Quad(boundary, 30);
-        this.prevClusteredEntities = new Set();
-        this.currClusteredEntities = new Set();
-        this.clusterEntities = new Map();
-        this.updateQueue = new bruce_models_1.DelayQueue(() => {
-            this.doUpdate();
-        }, 1000);
-        this.listenCamera();
-        this.listenSelection();
-        if (settings) {
-            if (!isNaN(+settings.minDistance)) {
-                this.minDistance = +settings.minDistance;
-            }
-            if (!isNaN(+settings.minTotalCount)) {
-                this.minTotalCount = +settings.minTotalCount;
+const clusterPickers = new WeakMap();
+/*
+ * One capture listener set per viewer prevents host canvas picking from undoing cluster selection.
+ */
+function getClusterPicker(viewer) {
+    let picker = clusterPickers.get(viewer);
+    if (picker) {
+        return picker;
+    }
+    const canvas = viewer.canvas;
+    picker = {
+        owners: new Set(),
+        targets: new Map(),
+        remove: () => { }
+    };
+    let gesture;
+    let released;
+    const handler = (event) => {
+        if (viewer.isDestroyed())
+            return;
+        const stop = () => { event.preventDefault(); event.stopImmediatePropagation(); };
+        if (event.type === "pointermove") {
+            if (gesture && Math.hypot(event.clientX - gesture.x, event.clientY - gesture.y) > 6) {
+                gesture.moved = true;
             }
+            return;
         }
-    }
-    Update() {
-        this.updateQueue.Call();
-    }
-    queueForceUpdate(entityIds) {
-        for (let i = 0; i < entityIds.length; i++) {
-            if (this.updateEntityQueue.includes(entityIds[i])) {
-                continue;
+        if (event.type === "pointercancel") {
+            if (gesture) {
+                released = { ...gesture, moved: true };
+                gesture = null;
+                if (released.target) {
+                    stop();
+                }
             }
-            this.updateEntityQueue.push(entityIds[i]);
-        }
-        this.runForceUpdateQueue();
-    }
-    runForceUpdateQueue() {
-        if (!this.updateEntityQueue.length) {
             return;
         }
-        if (this.queueInterval) {
+        if (event.button !== 0) {
             return;
         }
-        this.queueInterval = setInterval(() => {
-            if (this.disposed) {
-                clearInterval(this.queueInterval);
-                this.queueInterval = null;
+        if (event.type === "pointerup" || event.type === "mouseup") {
+            // Only consume releases whose press we owned, even if the cursor left the billboard.
+            if (!gesture) {
                 return;
             }
-            const ids = this.updateEntityQueue.splice(0, FORCE_UPDATE_BATCH_SIZE);
-            this.register.ForceUpdate({
-                entityIds: ids
-            });
-            if (!this.updateEntityQueue.length) {
-                clearInterval(this.queueInterval);
-                this.queueInterval = null;
+            gesture.moved || (gesture.moved = Math.hypot(event.clientX - gesture.x, event.clientY - gesture.y) > 6);
+            released = gesture;
+            gesture = null;
+            if (released.target) {
+                stop();
             }
-        }, FORCE_UPDATE_BATCH_DELAY);
-    }
-    /**
-     * Starts listening to camera changes.
-     * This will trigger the clustering update whenever camera is moved.
-     */
-    listenCamera() {
-        const viewer = this.viewer;
-        let lastPos3d;
-        const hasMoved = () => {
-            var _a;
-            const cameraPos = (_a = viewer === null || viewer === void 0 ? void 0 : viewer.camera) === null || _a === void 0 ? void 0 : _a.positionCartographic;
-            if (!cameraPos) {
-                return false;
-            }
-            const pos3d = Cesium.Cartographic.toCartesian(cameraPos);
-            if (!lastPos3d) {
-                lastPos3d = pos3d;
-                return false;
-            }
-            const distance = Cesium.Cartesian3.distance(pos3d, lastPos3d);
-            lastPos3d = pos3d;
-            // 50 meter movement at least.
-            return distance > 50;
-        };
-        this.listenCameraRemoval = viewer.scene.camera.changed.addEventListener(() => {
-            if (hasMoved()) {
-                this.updateQueue.Call();
+            return;
+        }
+        const rect = canvas.getBoundingClientRect();
+        const picked = viewer.scene.pick(new Cesium.Cartesian2(event.clientX - rect.left, event.clientY - rect.top));
+        const select = picker.targets.get(picked === null || picked === void 0 ? void 0 : picked.id);
+        if (event.type === "pointerdown" || event.type === "mousedown") {
+            released = null;
+            gesture = { target: select ? picked.id : null, x: event.clientX, y: event.clientY, moved: false };
+            if (gesture.target) {
+                stop();
             }
-        });
-    }
-    /**
-     * Stops listening to camera changes.
-     */
-    unlistenCamera() {
-        if (this.listenCameraRemoval) {
-            this.listenCameraRemoval();
-            this.listenCameraRemoval = null;
+            return;
         }
+        if (released) {
+            const owned = !!released.target;
+            const invalid = released.moved || released.target !== (picked === null || picked === void 0 ? void 0 : picked.id);
+            released = null;
+            if (!owned) {
+                return;
+            }
+            if (invalid) {
+                stop();
+                return;
+            }
+        }
+        if (!select) {
+            return;
+        }
+        stop();
+        if (event.type === "click") {
+            select();
+        }
+    };
+    const types = ["pointerdown", "pointermove", "pointerup", "pointercancel", "mousedown", "mouseup", "click", "dblclick"];
+    if (canvas === null || canvas === void 0 ? void 0 : canvas.addEventListener) {
+        for (const type of types) {
+            canvas.addEventListener(type, handler, true);
+        }
+        picker.remove = () => {
+            for (const type of types) {
+                canvas.removeEventListener(type, handler, true);
+            }
+        };
     }
-    /**
-     * Starts listening to entity selection changes.
-     * Selected entities are not clustered.
-     */
-    listenSelection() {
-        this.listenUpdateRemoval = this.register.OnUpdate.Subscribe((data) => {
-            if (data.type == visuals_register_1.VisualsRegister.EVisualUpdateType.DeselectAll) {
-                this.updateQueue.Call();
+    clusterPickers.set(viewer, picker);
+    return picker;
+}
+/*
+ * Count tiers are bounded so large clusters do not cover the scene with enormous billboards.
+ */
+function PointClusterSize(count) {
+    return count >= 10000 ? 140 : count >= 1000 ? 120 : count >= 100 ? 90 : count >= 10 ? 80 : 70;
+}
+exports.PointClusterSize = PointClusterSize;
+class PointClustering {
+    constructor(register, menuItemId, settings = {}) {
+        this.register = register;
+        this.menuItemId = menuItemId;
+        this.settings = settings;
+        this.minDistance = 5000;
+        this.minTotalCount = 0;
+        this.currClusteredEntities = new Set();
+        this.clusterEntities = new Map();
+        this.clusterViews = new Map();
+        this.registeredEntityIds = new Set();
+        this.records = new Map();
+        this.disposed = false;
+        this.removals = [];
+        this.selectionQueued = false;
+        this.viewer = register.Viewer;
+        this.settings = settings = settings || {};
+        if (Number.isFinite(+settings.minDistance)) {
+            this.minDistance = Math.max(0, +settings.minDistance);
+        }
+        if (Number.isFinite(+settings.minTotalCount)) {
+            this.minTotalCount = Math.max(0, +settings.minTotalCount);
+        }
+        this.quadTree = new Quad(new Rectangle(0, 0, 360, 180), 30);
+        this.updateQueue = new bruce_models_1.DelayQueue(() => this.doUpdate(), 1000);
+        this.picker = getClusterPicker(this.viewer);
+        this.picker.owners.add(this);
+        this.removals.push(this.viewer.scene.camera.changed.addEventListener(() => this.Update()));
+        this.removals.push(this.viewer.scene.terrainProviderChanged.addEventListener(() => this.Update()));
+        this.removals.push(register.OnUpdate.Subscribe(data => {
+            if (data.type === visuals_register_1.VisualsRegister.EVisualUpdateType.DeselectAll ||
+                (data.entityId && this.registeredEntityIds.has(data.entityId) && data.selected != null)) {
+                if (!this.selectionQueued) {
+                    this.selectionQueued = true;
+                    Promise.resolve().then(() => {
+                        this.selectionQueued = false;
+                        if (!this.disposed)
+                            this.refreshSelection();
+                    });
+                }
             }
-            else if (data.entityId &&
-                data.selected != null &&
-                data.type == visuals_register_1.VisualsRegister.EVisualUpdateType.Update &&
-                this.registeredEntityIds.has(data.entityId)) {
-                this.updateQueue.Call();
+            if ("isolated" in data || (data.entityId && this.registeredEntityIds.has(data.entityId) && "hidden" in data)) {
+                this.Update();
             }
-        });
+        }));
     }
-    unlistenSelection() {
-        if (this.listenUpdateRemoval) {
-            this.listenUpdateRemoval();
-            this.listenUpdateRemoval = null;
+    Update() {
+        if (!this.disposed) {
+            this.updateQueue.Call();
         }
     }
-    /**
-     * Removes all clusters and updates entities to no longer be suppressed.
-     * @returns
-     */
+    GetClusters() {
+        return Array.from(this.clusterViews.values(), view => ({ ...view, entityIds: [...view.entityIds] }));
+    }
     Dispose() {
         if (this.disposed) {
             return;
         }
-        for (let [, entity] of Array.from(this.clusterEntities)) {
-            this.viewer.entities.remove(entity);
-        }
-        this.clusterEntities.clear();
-        this.unlistenCamera();
-        this.unlistenSelection();
         this.disposed = true;
-        this.updateEntityQueue = [];
-        // Restore entities.
-        const toUpdateIds = [];
-        for (let id of Array.from(this.registeredEntityIds)) {
-            const rego = this.register.GetRego({
-                entityId: id,
-                menuItemId: this.menuItemId
-            });
-            if (rego && rego.overrideShow) {
+        this.updateQueue.Dispose();
+        for (const remove of this.removals) {
+            remove();
+        }
+        for (const id of this.clusterEntities.keys()) {
+            this.removeClusterEntity(id);
+        }
+        this.picker.owners.delete(this);
+        if (!this.picker.owners.size) {
+            this.picker.remove();
+            clusterPickers.delete(this.viewer);
+        }
+        const restore = [];
+        for (const id of this.registeredEntityIds) {
+            const rego = this.register.GetRego({ entityId: id, menuItemId: this.menuItemId });
+            if ((rego === null || rego === void 0 ? void 0 : rego.overrideShow) === false) {
                 rego.overrideShow = null;
-                toUpdateIds.push(id);
+                restore.push(id);
             }
         }
-        if (toUpdateIds.length) {
-            this.register.ForceUpdate({
-                entityIds: toUpdateIds,
-            });
+        this.records.clear();
+        this.registeredEntityIds.clear();
+        this.currClusteredEntities.clear();
+        if (restore.length) {
+            this.register.ForceUpdate({ entityIds: restore });
         }
     }
-    /**
-     * Calculates center of given points.
-     * @param points
-     * @returns
-     */
-    calculateCentroid(points) {
-        let lonSum = 0;
-        let latSum = 0;
-        for (let point of points) {
-            lonSum += point.lon;
-            latSum += point.lat;
+    refreshSelection() {
+        for (const view of this.clusterViews.values()) {
+            const selected = view.entityIds.length > 0 && view.entityIds.every(entityId => this.register.GetIsSelected({ entityId, menuItemId: this.menuItemId }));
+            if (selected === view.selected)
+                continue;
+            view.selected = selected;
+            if (selected)
+                cesium_entity_styler_1.CesiumEntityStyler.Select({ viewer: this.viewer, entity: view.entity, requestRender: false });
+            else
+                cesium_entity_styler_1.CesiumEntityStyler.Deselect({ viewer: this.viewer, entity: view.entity, requestRender: false });
         }
-        const lonAvg = lonSum / points.length;
-        const latAvg = latSum / points.length;
-        return new Point(lonAvg, latAvg, "");
+        this.viewer.scene.requestRender();
     }
-    /**
-     * Gathers current clusters and renders them.
-     * @returns
-     */
-    doUpdate() {
-        if (this.disposed) {
+    selectCluster(clusterId) {
+        const view = this.clusterViews.get(clusterId);
+        if (this.disposed || !view)
             return;
+        this.register.ClearSelected({ requestRender: false });
+        this.register.SetSelected({ entityIds: view.entityIds, selected: true });
+        this.refreshSelection();
+    }
+    resolveGeometry(visual, seen = new Set()) {
+        var _a, _b, _c;
+        if (!visual || seen.has(visual)) {
+            return null;
+        }
+        seen.add(visual);
+        const value = (property) => GetValue(this.viewer, property);
+        const valid = (p) => p && [p.x, p.y, p.z].every(Number.isFinite) && Cesium.Cartesian3.magnitudeSquared(p) > 0;
+        const kind = visual.model || visual.box || visual.cylinder || visual.ellipsoid ? "model" :
+            visual.polygon || visual.rectangle || visual.ellipse ? "polygon" :
+                visual.polyline || visual.corridor || visual.wall || visual.polylineVolume ? "polyline" :
+                    visual.point || visual.billboard || visual.label ? "point" : "other";
+        const configured = (_a = this.settings.minDistanceByType) === null || _a === void 0 ? void 0 : _a[kind];
+        let minDistance = Number.isFinite(configured) ? Math.max(0, configured) : this.minDistance * (kind === "point" || kind === "other" ? 1 : 2);
+        const graphic = (visual.model || visual.polygon || visual.rectangle || visual.ellipse || visual.polyline ||
+            visual.corridor || visual.wall || visual.polylineVolume || visual.billboard || visual.point || visual.label || visual.box || visual.cylinder || visual.ellipsoid);
+        let heightRef = (_b = value(graphic === null || graphic === void 0 ? void 0 : graphic.heightReference)) !== null && _b !== void 0 ? _b : Cesium.HeightReference.NONE;
+        if (visual.polyline) {
+            heightRef = value(visual.polyline.clampToGround) ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE;
+        }
+        let positions;
+        let height;
+        if (visual.polygon) {
+            const hierarchy = value(visual.polygon.hierarchy);
+            positions = hierarchy === null || hierarchy === void 0 ? void 0 : hierarchy.positions;
+            if (!value(visual.polygon.perPositionHeight)) {
+                height = value(visual.polygon.height);
+                if (height == null && value(visual.polygon.extrudedHeight) == null) {
+                    heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
+                }
+                height !== null && height !== void 0 ? height : (height = 0);
+            }
+        }
+        else if (visual.rectangle) {
+            const rectangle = value(visual.rectangle.coordinates);
+            if (rectangle) {
+                positions = [Cesium.Rectangle.northwest(rectangle), Cesium.Rectangle.northeast(rectangle),
+                    Cesium.Rectangle.southwest(rectangle), Cesium.Rectangle.southeast(rectangle)].map(c => Cesium.Cartographic.toCartesian(c));
+            }
+            height = value(visual.rectangle.height);
+            if (height == null && value(visual.rectangle.extrudedHeight) == null) {
+                heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
+            }
+            height !== null && height !== void 0 ? height : (height = 0);
+        }
+        else if (visual.polyline || visual.corridor || visual.wall || visual.polylineVolume) {
+            positions = value(graphic.positions);
+            if (visual.wall && positions) {
+                const minimum = value(visual.wall.minimumHeights);
+                const maximum = value(visual.wall.maximumHeights);
+                positions = positions.flatMap((position, index) => {
+                    var _a, _b;
+                    if (!valid(position)) {
+                        return [];
+                    }
+                    const carto = Cesium.Cartographic.fromCartesian(position);
+                    if (!carto) {
+                        return [];
+                    }
+                    return ([(_a = minimum === null || minimum === void 0 ? void 0 : minimum[index]) !== null && _a !== void 0 ? _a : 0, (_b = maximum === null || maximum === void 0 ? void 0 : maximum[index]) !== null && _b !== void 0 ? _b : carto.height]
+                        .filter(Number.isFinite).map(height => Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, height)));
+                });
+            }
         }
-        // 1: Update precision.
-        // This defines how far apart these clusters can be.
-        const cameraHeight = this.viewer.camera.positionCartographic.height;
-        this.getClusterSpacing(cameraHeight);
-        // 2: Get clusters.
-        const { clusters, noLongerClustered } = this.getClusters();
-        const entitiesToUpdate = [];
-        // 3: Remove all cesium cluster entities that are no longer clustered.
-        for (let id of Array.from(noLongerClustered)) {
-            this.removeClusterEntity(id);
+        if (visual.corridor || visual.ellipse) {
+            height = value(graphic.height);
+            if (height == null && value(graphic.extrudedHeight) == null)
+                heightRef = Cesium.HeightReference.CLAMP_TO_GROUND;
+            height !== null && height !== void 0 ? height : (height = 0);
         }
-        // 4: Stop hiding entities that are no longer clustered.
-        const previousEntityIds = new Set(this.registeredEntityIds);
-        for (let id of Array.from(previousEntityIds)) {
-            if (!this.currClusteredEntities.has(id)) {
-                const rego = this.register.GetRego({
-                    entityId: id,
-                    menuItemId: this.menuItemId
+        if (!(positions === null || positions === void 0 ? void 0 : positions.length)) {
+            const position = value(visual.position);
+            if (valid(position)) {
+                positions = [position];
+            }
+        }
+        const children = visual._siblingGraphics || [];
+        // Container entities often copy their first child's position; don't count that anchor twice.
+        if (!graphic && children.length) {
+            positions = [];
+            minDistance = 0;
+        }
+        const resolved = [];
+        for (const position of positions || []) {
+            if (!valid(position))
+                continue;
+            let source = position;
+            if (height != null) {
+                const carto = Cesium.Cartographic.fromCartesian(position);
+                if (!carto)
+                    continue;
+                source = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+            }
+            const actual = drawing_utils_1.DrawingUtils.EnsurePosHeight({
+                viewer: this.viewer,
+                pos3d: source,
+                desiredHeightRef: Cesium.HeightReference.NONE,
+                heightRef
+            });
+            if (valid(actual)) {
+                resolved.push(actual);
+            }
+        }
+        const extrudedHeight = value(graphic === null || graphic === void 0 ? void 0 : graphic.extrudedHeight);
+        if (Number.isFinite(extrudedHeight)) {
+            const reference = (_c = value(graphic.extrudedHeightReference)) !== null && _c !== void 0 ? _c : Cesium.HeightReference.NONE;
+            for (const position of positions || []) {
+                if (!valid(position)) {
+                    continue;
+                }
+                const carto = Cesium.Cartographic.fromCartesian(position);
+                if (!carto) {
+                    continue;
+                }
+                const actual = drawing_utils_1.DrawingUtils.EnsurePosHeight({
+                    viewer: this.viewer,
+                    pos3d: Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, extrudedHeight),
+                    desiredHeightRef: Cesium.HeightReference.NONE, heightRef: reference
                 });
-                if (rego && rego.overrideShow != null) {
-                    rego.overrideShow = null;
-                    entitiesToUpdate.push(id);
+                if (valid(actual)) {
+                    resolved.push(actual);
                 }
             }
         }
-        const getScale = (count) => {
-            // const MIN_SCALE = 15;
-            // const MAX_SCALE = 80;
-            // const SCALE_PER_POINT = 1.01;
-            // let scale = MIN_SCALE + (count * SCALE_PER_POINT);
-            // scale = Math.min(scale, MAX_SCALE);
-            // return scale;
-            if (count >= 10000) {
-                return 140;
+        const spheres = [];
+        const anchors = [];
+        if (resolved.length) {
+            const sphere = Cesium.BoundingSphere.fromPoints(resolved);
+            // A chord midpoint can lie underground. Preserve the average rendered vertex altitude.
+            const center = Cesium.Cartographic.fromCartesian(sphere.center);
+            if (center) {
+                const altitude = resolved.reduce((sum, p) => sum + Cesium.Cartographic.fromCartesian(p).height, 0) / resolved.length;
+                const position = Cesium.Cartesian3.fromRadians(center.longitude, center.latitude, altitude);
+                sphere.radius += Cesium.Cartesian3.distance(position, sphere.center);
+                sphere.center = position;
             }
-            if (count >= 1000) {
-                return 120;
+            if (visual.ellipse) {
+                sphere.radius = Math.max(sphere.radius, value(visual.ellipse.semiMajorAxis) || 0, value(visual.ellipse.semiMinorAxis) || 0);
             }
-            if (count >= 100) {
-                return 90;
+            if (visual.box) {
+                sphere.radius = Math.max(sphere.radius, Cesium.Cartesian3.magnitude(value(visual.box.dimensions) || Cesium.Cartesian3.ZERO) / 2);
             }
-            if (count >= 10) {
-                return 80;
+            if (visual.ellipsoid) {
+                sphere.radius = Math.max(sphere.radius, Cesium.Cartesian3.maximumComponent(value(visual.ellipsoid.radii) || Cesium.Cartesian3.ZERO));
             }
-            return 70;
+            if (visual.cylinder) {
+                sphere.radius = Math.max(sphere.radius, Math.hypot((value(visual.cylinder.length) || 0) / 2, Math.max(value(visual.cylinder.topRadius) || 0, value(visual.cylinder.bottomRadius) || 0)));
+            }
+            if (visual.corridor) {
+                sphere.radius += (value(visual.corridor.width) || 0) / 2;
+            }
+            if (visual.polylineVolume) {
+                const shape = value(visual.polylineVolume.shape) || [];
+                sphere.radius += shape.reduce((radius, p) => Math.max(radius, Math.hypot(p.x, p.y)), 0);
+            }
+            spheres.push(sphere);
+            anchors.push(sphere.center);
+        }
+        for (const child of children) {
+            const result = this.resolveGeometry(child, seen);
+            if (!result) {
+                continue;
+            }
+            spheres.push(new Cesium.BoundingSphere(result.position, result.radius));
+            anchors.push(result.position);
+            minDistance = Math.max(minDistance, result.minDistance);
+        }
+        if (!spheres.length) {
+            return null;
+        }
+        const sphere = spheres.length === 1 ? spheres[0] : Cesium.BoundingSphere.fromBoundingSpheres(spheres);
+        if (!valid(sphere.center) || !Number.isFinite(sphere.radius)) {
+            return null;
+        }
+        if (spheres.length > 1) {
+            const carto = Cesium.Cartographic.fromCartesian(sphere.center);
+            if (!carto) {
+                return null;
+            }
+            const height = anchors.reduce((sum, p) => sum + Cesium.Cartographic.fromCartesian(p).height, 0) / anchors.length;
+            const position = Cesium.Cartesian3.fromRadians(carto.longitude, carto.latitude, height);
+            sphere.radius += Cesium.Cartesian3.distance(position, sphere.center);
+            sphere.center = position;
+        }
+        return { position: sphere.center, radius: sphere.radius, minDistance };
+    }
+    appearance(id) {
+        var _a, _b, _c, _d, _e, _f;
+        const { visual, metadata } = this.records.get(id);
+        const data = metadata.entity || { Bruce: { ID: id } };
+        let priority;
+        let status;
+        try {
+            priority = Array.isArray(this.settings.iconPriority) ? bruce_models_1.Calculator.GetNumber(this.settings.iconPriority, data) : this.settings.iconPriority;
+            status = Array.isArray(this.settings.iconStatus) ? bruce_models_1.Calculator.GetString(this.settings.iconStatus, data) : this.settings.iconStatus;
+        }
+        catch {
+            priority = undefined;
+            status = undefined;
+        }
+        const rawImage = GetValue(this.viewer, (_a = visual.billboard) === null || _a === void 0 ? void 0 : _a.image);
+        const imageKey = (_b = visual.billboard) === null || _b === void 0 ? void 0 : _b._billboardImgKey;
+        const iconUrl = (_c = metadata.iconUrl) !== null && _c !== void 0 ? _c : (typeof rawImage === "string" ? rawImage : undefined);
+        // Original URLs retain status tokens after the point renderer converts an image into a data URI.
+        const inferenceUrl = (_e = (_d = metadata.iconUrl) !== null && _d !== void 0 ? _d : imageKey) !== null && _e !== void 0 ? _e : iconUrl;
+        const colorGraphic = visual.point || visual.polygon || visual.polyline || visual.corridor || visual.ellipse || visual.model;
+        const color = colorGraphic ? cesium_entity_styler_1.CesiumEntityStyler.GetDefaultColor(this.viewer, colorGraphic) : null;
+        let colorStatus;
+        if (color && color.alpha > 0 && color.red > 0.5 && color.blue < 0.4) {
+            colorStatus = color.green > 0.4 ? "warning" : "red";
+        }
+        const bgColor = color === null || color === void 0 ? void 0 : color.toCssColorString();
+        return {
+            priority: (0, point_clustering_core_1.GetClusterIconPriority)({
+                iconPriority: Number.isFinite(priority) ? priority : metadata.iconPriority,
+                iconStatus: (_f = status !== null && status !== void 0 ? status : metadata.iconStatus) !== null && _f !== void 0 ? _f : colorStatus, icon: metadata.icon, iconUrl: inferenceUrl
+            }),
+            iconUrl, bgColor,
+            txtColor: color && color.red * 0.299 + color.green * 0.587 + color.blue * 0.114 > 0.5 ? "black" : "white"
         };
-        /**
-         * Generate circle with label in center.
-         * @param count
-         * @returns
-         */
-        const getCanvas = (count) => {
+    }
+    doUpdate() {
+        var _a;
+        if (this.disposed) {
+            return;
+        }
+        const previous = new Set(this.currClusteredEntities);
+        const { clusters } = this.getClusters();
+        const live = new Set(clusters.map(cluster => cluster.center.id));
+        for (const id of this.clusterEntities.keys()) {
+            if (!live.has(id)) {
+                this.removeClusterEntity(id);
+            }
+        }
+        const changed = new Set();
+        for (const id of new Set([...previous, ...this.registeredEntityIds])) {
+            if (this.currClusteredEntities.has(id)) {
+                continue;
+            }
+            const rego = this.register.GetRego({ entityId: id, menuItemId: this.menuItemId });
+            if ((rego === null || rego === void 0 ? void 0 : rego.overrideShow) === false) {
+                rego.overrideShow = null;
+                changed.add(id);
+            }
+        }
+        for (const cluster of clusters) {
+            const clusterId = cluster.center.id;
+            let representative = cluster.center;
+            let appearance = this.appearance(representative.id);
+            if (this.settings.representative !== "nearest") {
+                for (const point of cluster.points) {
+                    const candidate = this.appearance(point.id);
+                    const distance = Cesium.Cartesian3.distanceSquared(point.position, this.viewer.camera.positionWC || this.viewer.camera.position);
+                    const representativeDistance = Cesium.Cartesian3.distanceSquared(representative.position, this.viewer.camera.positionWC || this.viewer.camera.position);
+                    if (candidate.priority > appearance.priority || (candidate.priority === appearance.priority &&
+                        (distance < representativeDistance || (distance === representativeDistance &&
+                            point.id.localeCompare(representative.id) < 0)))) {
+                        representative = point;
+                        appearance = candidate;
+                    }
+                }
+            }
+            const position = new Cesium.Cartesian3();
+            for (const point of cluster.points) {
+                Cesium.Cartesian3.add(position, point.position, position);
+            }
+            Cesium.Cartesian3.divideByScalar(position, cluster.points.length, position);
+            const count = cluster.points.length;
             const params = {
-                size: getScale(count),
-                txtColor: this.pointColorTxt,
-                bgColor: this.pointColorBg,
+                size: PointClusterSize(count),
                 text: String(count),
-                iconUrl: this.iconUrl
+                iconUrl: appearance.iconUrl,
+                bgColor: appearance.bgColor,
+                txtColor: appearance.txtColor
             };
-            return getClusterImage(params);
-        };
-        // 5: iterate over clusters and add/update them as Cesium entities.
-        for (let cluster of clusters) {
-            const clusterId = cluster.center.id;
-            let clusterEntity = this.clusterEntities.get(clusterId);
-            const centroid = this.calculateCentroid(cluster.points);
-            const count = cluster.points.length;
-            if (clusterEntity) {
-                clusterEntity.position = new Cesium.ConstantPositionProperty(Cesium.Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150));
-                clusterEntity.billboard.image = new Cesium.CallbackProperty(() => {
-                    return getCanvas(count);
-                }, false),
-                    clusterEntity.billboard.width = new Cesium.ConstantProperty(getScale(cluster.points.length));
-                clusterEntity.billboard.height = new Cesium.ConstantProperty(getScale(cluster.points.length));
-            }
-            else {
-                clusterEntity = this.viewer.entities.add({
-                    position: Cesium.Cartesian3.fromDegrees(centroid.lon, centroid.lat, 150),
+            const image = new Cesium.CallbackProperty(() => getClusterImage(params), false);
+            let entity = this.clusterEntities.get(clusterId);
+            if (!entity) {
+                entity = this.viewer.entities.add({
+                    position,
                     billboard: {
+                        image,
+                        color: Cesium.Color.WHITE,
+                        width: params.size,
+                        height: params.size,
                         heightReference: Cesium.HeightReference.NONE,
-                        image: new Cesium.CallbackProperty(() => {
-                            return getCanvas(count);
-                        }, false),
-                        width: getScale(count),
-                        height: getScale(count),
                         verticalOrigin: Cesium.VerticalOrigin.CENTER,
                         horizontalOrigin: Cesium.HorizontalOrigin.CENTER,
-                        disableDepthTestDistance: Number.POSITIVE_INFINITY,
-                        scaleByDistance: new Cesium.NearFarScalar(1.5e2, 0.5, 3.0e7, 0.1),
+                        disableDepthTestDistance: Infinity,
+                        scaleByDistance: new Cesium.NearFarScalar(1.5e2, 0.5, 3.0e7, 0.1)
                     }
                 });
-                this.clusterEntities.set(clusterId, clusterEntity);
+                this.clusterEntities.set(clusterId, entity);
+                if (this.settings.selectOnClick !== false)
+                    this.picker.targets.set(entity, () => this.selectCluster(clusterId));
             }
-            for (let i = 0; i < cluster.points.length; i++) {
-                const entityId = cluster.points[i].id;
+            else {
+                entity.position = new Cesium.ConstantPositionProperty(position);
+                entity.billboard.image = image;
+                entity.billboard.width = new Cesium.ConstantProperty(params.size);
+                entity.billboard.height = new Cesium.ConstantProperty(params.size);
+            }
+            const old = this.clusterViews.get(clusterId);
+            this.clusterViews.set(clusterId, {
+                entity,
+                entityIds: cluster.points.map(point => point.id),
+                representativeId: representative.id,
+                selected: (_a = old === null || old === void 0 ? void 0 : old.selected) !== null && _a !== void 0 ? _a : false
+            });
+            _loadClusterImage(params).then(() => {
+                if (!this.disposed && !this.viewer.isDestroyed()) {
+                    this.viewer.scene.requestRender();
+                }
+            });
+            for (const point of cluster.points) {
                 const rego = this.register.GetRego({
-                    entityId: entityId,
+                    entityId: point.id,
                     menuItemId: this.menuItemId
                 });
-                if (rego && rego.overrideShow != false) {
+                if (rego && rego.overrideShow !== false) {
                     rego.overrideShow = false;
-                    entitiesToUpdate.push(entityId);
+                    changed.add(point.id);
                 }
             }
         }
-        this.queueForceUpdate(entitiesToUpdate);
-        // 6: Iterate over existing cluster entities and remove those that are no longer clustered.
-        for (let [clusterId, clusterEntity] of Array.from(this.clusterEntities)) {
-            if (!clusters.find(x => x.center.id == clusterId)) {
-                this.viewer.entities.remove(clusterEntity);
-                this.clusterEntities.delete(clusterId);
-            }
+        if (changed.size) {
+            this.register.ForceUpdate({ entityIds: Array.from(changed) });
         }
-        this.viewer.scene.requestRender();
+        this.refreshSelection();
     }
-    getClusterSpacing(distanceFromCluster) {
-        // Distance thresholds in meters from the cluster.
-        const distanceThresholds = [3000, 4000, 5300, 6000, 7000];
-        // Distance increments in degrees.
-        const distanceIncrements = [0.001, 0.002, 0.01, 0.03, 0.09];
-        let index = 0;
-        if (distanceFromCluster) {
-            for (let i = 0; i < distanceThresholds.length; i++) {
-                if (distanceFromCluster > distanceThresholds[i]) {
-                    index = i;
-                }
-            }
-        }
-        return distanceIncrements[index];
+    getClusterSpacing(distance) {
+        return distance > 7000 ? 0.09 : distance > 6000 ? 0.03 : distance > 5300 ? 0.01 : distance > 4000 ? 0.002 : 0.001;
     }
     getClusters() {
+        const previous = new Set(this.currClusteredEntities);
         this.currClusteredEntities.clear();
-        let clusters = [];
-        let processedPoints = new Set();
-        const cameraPosition = this.viewer.camera.position;
-        // We won't cluster selected entities.
-        const selectedIds = this.register.GetSelected();
-        // Only cluster if total registered points exceeds minTotalCount.
-        let validClusters = [];
-        if (this.registeredEntityIds.size >= this.minTotalCount) {
-            const MIN_CAMERA_DISTANCE = this.minDistance;
-            const processQuad = (quad) => {
-                // Distance to quad.
-                // TODO: Needs improvement.
-                const distanceToQuad = quad.GetDistanceToQuad(cameraPosition);
-                // Skip quads that are too close.
-                if (distanceToQuad >= MIN_CAMERA_DISTANCE) {
-                    for (let point of quad.points) {
-                        // Skip points already processed in previous clusters.
-                        if (selectedIds.includes(point.id) || processedPoints.has(point.id)) {
-                            continue;
-                        }
-                        // Skip points closer than MIN_CAMERA_DISTANCE meters to the camera.
-                        const cartesian3 = Cesium.Cartesian3.fromDegrees(point.lon, point.lat);
-                        const distanceFromCluster = Cesium.Cartesian3.distance(cartesian3, cameraPosition);
-                        if (distanceFromCluster <= MIN_CAMERA_DISTANCE) {
-                            continue;
-                        }
-                        let found = [];
-                        let nearbyPoints = quad.Query(new Circle(point.lon, point.lat, this.getClusterSpacing(distanceFromCluster)), found);
-                        nearbyPoints = nearbyPoints.filter(x => !processedPoints.has(x.id) && !selectedIds.includes(x.id));
-                        if (nearbyPoints.length > 1) {
-                            let cluster = { center: point, points: [] };
-                            for (let nearby of nearbyPoints) {
-                                if (!cluster.points.includes(nearby)) {
-                                    cluster.points.push(nearby);
-                                    processedPoints.add(nearby.id);
-                                    this.currClusteredEntities.add(nearby.id);
-                                }
-                            }
-                            clusters.push(cluster);
-                        }
-                    }
-                }
-                if (quad.divided) {
-                    processQuad(quad.northwest);
-                    processQuad(quad.northeast);
-                    processQuad(quad.southwest);
-                    processQuad(quad.southeast);
-                }
-            };
-            processQuad(this.quadTree);
-            // Filter out clusters with only one point.
-            validClusters = clusters.filter((cluster) => cluster.points.length > 1);
-        }
-        // Get the entity IDs that are no longer clustered
-        const noLongerClustered = new Set(Array.from(this.prevClusteredEntities).filter((id) => !this.currClusteredEntities.has(id)));
-        // Update the previous clustered entities ref.
-        this.prevClusteredEntities = new Set(this.currClusteredEntities);
-        return { clusters: validClusters, noLongerClustered };
-    }
-    /**
-     * Removes Cesium cluster entity.
-     * @param clusterId
-     */
-    removeClusterEntity(clusterId) {
-        const clusterEntity = this.clusterEntities.get(clusterId);
-        if (clusterEntity) {
-            this.viewer.entities.remove(clusterEntity);
-            this.clusterEntities.delete(clusterId);
-        }
-    }
-    convertCartesianToCartographic(cartesian3) {
-        const carto = Cesium.Cartographic.fromCartesian(cartesian3);
-        const lon = Cesium.Math.toDegrees(carto.longitude);
-        const lat = Cesium.Math.toDegrees(carto.latitude);
-        const id = lon + ',' + lat;
-        return new Point(lon, lat, id);
-    }
-    /**
-     * Adds new entity to the clustering logic.
-     * @param id Bruce entity ID.
-     * @param cartesian3 entity's position.
-     */
-    addPoint(id, cartesian3) {
-        let point = this.convertCartesianToCartographic(cartesian3);
-        point.id = id;
-        return this.quadTree.Insert(point);
-    }
-    /**
-     * Adds entity to clustering logic.
-     * Will return false if entity could not be clustered and therefor should not be hidden.
-     * @param id
-     * @param entity
-     * @param queueUpdate
-     * @returns
-     */
-    AddEntity(id, entity, queueUpdate = true) {
-        if (this.disposed) {
-            return false;
-        }
-        if (!entity) {
-            return false;
-        }
-        if (entity.polygon || entity.polyline) {
-            return false;
-        }
-        const pos3d = GetValue(this.viewer, entity.position);
-        if (!(pos3d === null || pos3d === void 0 ? void 0 : pos3d.x)) {
-            return false;
-        }
-        if (!this.pointColorBg && entity.point) {
-            const pointColorBg = GetValue(this.viewer, entity.point.color);
-            if (pointColorBg) {
-                let cColor = null;
-                if (pointColorBg instanceof Object) {
-                    cColor = new Cesium.Color(pointColorBg.red, pointColorBg.green, pointColorBg.blue, pointColorBg.alpha);
-                }
-                else if (typeof pointColorBg === "string") {
-                    cColor = Cesium.Color.fromCssColorString(pointColorBg);
-                }
-                // Determine if text color should instead be black based on background.
-                // cColor contains r,g,b,a values where r,g,b are in the range [0,1].
-                if (cColor) {
-                    const brightness = (cColor.red * 299 + cColor.green * 587 + cColor.blue * 114) / 1000;
-                    if (brightness > 0.5) {
-                        this.pointColorTxt = "black";
-                    }
-                    else {
-                        this.pointColorTxt = "white";
-                    }
-                    this.pointColorBg = cColor.toCssColorString();
-                }
+        this.quadTree = new Quad(new Rectangle(0, 0, 360, 180), 30);
+        const points = [];
+        const distances = new Map();
+        const camera = this.viewer.camera.positionWC || this.viewer.camera.position;
+        const isolated = this.register.GetIsIsolatedAny();
+        for (const [id, record] of this.records) {
+            const state = this.register.GetState({ entityId: id, menuItemId: this.menuItemId });
+            if (state.hidden || (isolated && !state.isolated)) {
+                continue;
             }
+            const geometry = this.resolveGeometry(record.visual);
+            if (!geometry) {
+                continue;
+            }
+            const { position, radius, minDistance } = geometry;
+            const carto = Cesium.Cartographic.fromCartesian(position);
+            if (!carto) {
+                continue;
+            }
+            const point = new Point(Cesium.Math.toDegrees(carto.longitude), Cesium.Math.toDegrees(carto.latitude), id);
+            point.position = position;
+            point.radius = radius;
+            point.minDistance = minDistance;
+            if (!this.quadTree.Insert(point)) {
+                continue;
+            }
+            points.push(point);
+            distances.set(id, Cesium.Cartesian3.distance(position, camera));
         }
-        if (!this.iconUrl && entity.billboard) {
-            const iconUrl = GetValue(this.viewer, entity.billboard.image);
-            if (typeof iconUrl == "string") {
-                this.iconUrl = iconUrl;
+        const clusters = points.length < this.minTotalCount ? [] :
+            (0, point_clustering_core_1.ClusterItems)({
+                items: points.sort((a, b) => distances.get(a.id) - distances.get(b.id) || a.id.localeCompare(b.id)),
+                id: point => point.id,
+                eligible: point => Math.max(0, distances.get(point.id) - point.radius) > point.minDistance,
+                neighbours: point => this.quadTree.Query(new Circle(point.lon, point.lat, this.getClusterSpacing(distances.get(point.id))), [])
+            }).map(cluster => ({ center: cluster.representative, points: cluster.members }));
+        for (const cluster of clusters) {
+            for (const point of cluster.points) {
+                this.currClusteredEntities.add(point.id);
             }
         }
-        if (this.registeredEntityIds.has(id)) {
-            this.RemoveEntity(id, false);
+        return {
+            clusters,
+            noLongerClustered: new Set(Array.from(previous).filter(id => !this.currClusteredEntities.has(id)))
+        };
+    }
+    removeClusterEntity(id) {
+        const entity = this.clusterEntities.get(id);
+        if (!entity)
+            return;
+        this.picker.targets.delete(entity);
+        this.viewer.entities.remove(entity);
+        this.clusterEntities.delete(id);
+        this.clusterViews.delete(id);
+    }
+    /*
+     * Metadata is additive; existing three-argument calls keep their original signature.
+     */
+    AddEntity(id, visual, queueUpdate = true, metadata = {}) {
+        if (this.disposed || !visual) {
+            return false;
         }
-        const added = this.addPoint(id, pos3d);
-        if (!added) {
+        if (!this.resolveGeometry(visual)) {
+            this.RemoveEntity(id, queueUpdate);
             return false;
         }
+        this.records.set(id, { visual, metadata });
         this.registeredEntityIds.add(id);
         if (queueUpdate) {
-            this.updateQueue.Call();
+            this.Update();
         }
         return true;
     }
-    /**
-     * Removes entity from clustering logic.
-     * Warning: This will not reveal the entity, suppressShow will remain true.
-     * This is made with the assumption that the entity is being removed from viewer.
-     * @param id
-     * @param queueUpdate
-     * @returns
-     */
     RemoveEntity(id, queueUpdate = false) {
         if (this.disposed) {
             return;
         }
-        let pointToRemove = this.quadTree.Find(id);
-        if (pointToRemove) {
-            this.quadTree.Remove(pointToRemove);
-            if (queueUpdate) {
-                this.updateQueue.Call();
-            }
-        }
+        this.records.delete(id);
         this.registeredEntityIds.delete(id);
+        if (queueUpdate) {
+            this.Update();
+        }
     }
 }
 exports.PointClustering = PointClustering;