bruce-cesium 5.3.7 → 5.3.8

package/dist/bruce-cesium.umd.js

@@ -1404,6 +1404,225 @@
             return series;
         }
         CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity = GetSeriesPossesForHistoricEntity;
+        /**
+         * Animates a tileset position and heading from a series of positions over time.
+         * Unlike other animation functions that directly modify the tileset,
+         * this provides a callback with calculated values for the caller to apply.
+         *
+         * Example:
+         * ```
+         * const dispose = CesiumAnimatedProperty.AnimateTPositionSeries({
+         *    viewer: viewer,
+         *    posses: positionSeries,
+         *    onUpdate: (position, heading) => {}
+         * });
+         *
+         * // To dispose:
+         * dispose();
+         * ```
+         * @param params Animation parameters
+         * @returns Function to stop the animation
+         */
+        class AnimateTPositionSeries {
+            constructor(params) {
+                // Cache for calculated values.
+                this.lastCalcTime = null;
+                this.lastCalcPos3d = null;
+                this.lastCalcHeading = null;
+                this.removal = null;
+                this.viewer = params.viewer;
+                this.onUpdate = params.onUpdate;
+                this.onDone = params.onDone;
+                // No positions to animate.
+                if (!params.posses || params.posses.length === 0) {
+                    return;
+                }
+                // Order positions by date.
+                const orderedPosses = [...params.posses].sort((a, b) => {
+                    return a.dateTime.getTime() - b.dateTime.getTime();
+                });
+                // Process headings - if all are null or 0, assume all are null.
+                this.positions = this.processHeadings([...orderedPosses]);
+                // Set up the animation loop.
+                this.removal = this.viewer.scene.postUpdate.addEventListener(() => this.update());
+                this.update();
+            }
+            /**
+             * Stop the animation and call the onDone callback if provided.
+             */
+            stop() {
+                if (this.removal) {
+                    this.removal();
+                    this.removal = null;
+                    if (this.onDone) {
+                        this.onDone();
+                    }
+                }
+            }
+            /**
+             * Update function called on each frame.
+             */
+            update() {
+                let now = this.viewer.scene.lastRenderTime;
+                if (!now) {
+                    now = this.viewer.clock.currentTime;
+                }
+                const nowTime = Cesium.JulianDate.toDate(now);
+                const nowTimeMs = nowTime.getTime();
+                // Skip calculation if time hasn't changed.
+                if (this.lastCalcTime === nowTimeMs) {
+                    return;
+                }
+                // Calculate position.
+                const position = this.calculatePosition(nowTimeMs);
+                // Update cache values.
+                this.lastCalcTime = nowTimeMs;
+                this.lastCalcPos3d = position.pos3d;
+                // Calculate heading.
+                this.lastCalcHeading = this.calculateHeading(nowTimeMs, position.indexLast, position.indexNext);
+                // Provide the calculated values to the caller.
+                this.onUpdate(this.lastCalcPos3d, this.lastCalcHeading);
+            }
+            /**
+             * Pre-process headings in the series.
+             * If all are null or 0, then assume all are null.
+             */
+            processHeadings(posses) {
+                let hasHeading = false;
+                for (let i = 0; i < posses.length; i++) {
+                    let pos = posses[i];
+                    if (pos.heading !== null && pos.heading !== 0) {
+                        hasHeading = true;
+                        break;
+                    }
+                }
+                if (!hasHeading) {
+                    for (let i = 0; i < posses.length; i++) {
+                        posses[i].heading = null;
+                    }
+                }
+                return posses;
+            }
+            /**
+             * Calculate the position at the given time
+             */
+            calculatePosition(currentTimeMs) {
+                const posses = this.positions;
+                // See if we're before the first position
+                if (currentTimeMs <= posses[0].dateTime.getTime()) {
+                    return {
+                        pos3d: posses[0].pos3d,
+                        indexLast: 0,
+                        indexNext: 0
+                    };
+                }
+                // See if we're after the last position
+                if (currentTimeMs >= posses[posses.length - 1].dateTime.getTime()) {
+                    const lastIndex = posses.length - 1;
+                    return {
+                        pos3d: posses[lastIndex].pos3d,
+                        indexLast: lastIndex,
+                        indexNext: lastIndex
+                    };
+                }
+                // Find the current position
+                let lastIndex = 0;
+                for (let i = 1; i < posses.length; i++) {
+                    let pos = posses[i];
+                    if (currentTimeMs >= pos.dateTime.getTime()) {
+                        lastIndex = i;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                const last = posses[lastIndex];
+                const next = posses[lastIndex + 1];
+                // If no next position, use the last one
+                if (!next) {
+                    return {
+                        pos3d: last.pos3d,
+                        indexLast: lastIndex,
+                        indexNext: lastIndex
+                    };
+                }
+                // Interpolate the position
+                const progress = (currentTimeMs - last.dateTime.getTime()) /
+                    (next.dateTime.getTime() - last.dateTime.getTime());
+                const interpolatedPos = Cesium.Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cesium.Cartesian3());
+                return {
+                    pos3d: interpolatedPos,
+                    indexLast: lastIndex,
+                    indexNext: lastIndex + 1
+                };
+            }
+            /**
+             * Calculate the heading at the given time.
+             */
+            calculateHeading(currentTimeMs, lastIndex, nextIndex) {
+                const posses = this.positions;
+                // Ensure valid indices.
+                if (lastIndex < 0 || nextIndex < 0 ||
+                    lastIndex >= posses.length || nextIndex >= posses.length) {
+                    return null;
+                }
+                const lastPos = posses[lastIndex];
+                const nextPos = posses[nextIndex];
+                // If the heading is present and not null, interpolate or use it directly.
+                if (lastPos.heading !== null && nextPos.heading !== null) {
+                    // If they're the same position or same time, just return the heading.
+                    if (lastIndex === nextIndex ||
+                        lastPos.dateTime.getTime() === nextPos.dateTime.getTime()) {
+                        return lastPos.heading;
+                    }
+                    let deltaHeading = nextPos.heading - lastPos.heading;
+                    // Handle wraparound between 359 and 0 degrees.
+                    if (deltaHeading > 180) {
+                        deltaHeading -= 360;
+                    }
+                    else if (deltaHeading < -180) {
+                        deltaHeading += 360;
+                    }
+                    const factor = (currentTimeMs - lastPos.dateTime.getTime()) /
+                        (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
+                    let interpolatedHeading = lastPos.heading + factor * deltaHeading;
+                    interpolatedHeading = (interpolatedHeading + 360) % 360;
+                    return interpolatedHeading;
+                }
+                // If no valid heading is available, calculate based on movement direction.
+                else {
+                    const previousPos = lastPos.pos3d;
+                    const currentPos = nextPos.pos3d;
+                    if (!previousPos || isNaN(previousPos.x) ||
+                        !currentPos || isNaN(currentPos.x)) {
+                        return null;
+                    }
+                    // Flatten to avoid orientation changes due to height differences.
+                    const adjustedPointPrev = Cesium.Cartographic.fromCartesian(previousPos);
+                    const adjustedPos3dPrev = Cesium.Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
+                    const adjustedPointNext = Cesium.Cartographic.fromCartesian(currentPos);
+                    const adjustedPos3dNext = Cesium.Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
+                    // Check if the positions are too close.
+                    if (Cesium.Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext) < 0.05) {
+                        return null;
+                    }
+                    const direction = Cesium.Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cesium.Cartesian3());
+                    // No movement.
+                    if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
+                        return null;
+                    }
+                    // Calculate heading from the direction vector.
+                    Cesium.Cartesian3.normalize(direction, direction);
+                    // Convert the direction to a heading angle.
+                    const east = Cesium.Cartesian3.UNIT_X;
+                    const north = Cesium.Cartesian3.UNIT_Y;
+                    const heading = Math.atan2(Cesium.Cartesian3.dot(direction, east), Cesium.Cartesian3.dot(direction, north));
+                    // Convert to degrees.
+                    return (Cesium.Math.toDegrees(heading) + 360) % 360;
+                }
+            }
+        }
+        CesiumAnimatedProperty.AnimateTPositionSeries = AnimateTPositionSeries;
     })(exports.CesiumAnimatedProperty || (exports.CesiumAnimatedProperty = {}));
 
     /**
@@ -16717,6 +16936,11 @@
             }
             getTilesetFeatureNeedsFullData(entityId, entityTypeId) {
                 var _a;
+                if (this.historic) {
+                    // Unfortunately when we are working with historic we have to request the entity.
+                    // This is because we need to know if a record exists at the point in time.
+                    return true;
+                }
                 const style = this.getTilesetFeatureStyle(entityId, entityTypeId);
                 if (!style) {
                     return false;
@@ -16841,6 +17065,12 @@
                 // We retain this information as a quick look-up on what has been registered.
                 // This lets us properly assign siblings to the same rego when hierarchy items are marked as collapsed.
                 this.loadedCesiumEntities = {};
+                // Callback to dispose the link between scene time and the root's historic position.
+                this.viewerDateTimeChangeRemoval = null;
+                // Series of points to help interpolate movement when the timeline changes.
+                this.historicPosses = [];
+                this.historicPossesLoading = false;
+                this.historicPossesLoadingProm = null;
                 const { viewer, register: visualsManager, getters, item } = params;
                 this.viewer = viewer;
                 this.getters = getters;
@@ -16982,6 +17212,8 @@
                                 historic: (_c = this.item.BruceEntity) === null || _c === void 0 ? void 0 : _c.historic,
                             });
                             this.viewer.scene.requestRender();
+                            // Monitor scene time changes and update the root Entity.
+                            this.viewerDateTimeSub(tileset);
                         }
                         catch (e) {
                             console.error(e);
@@ -17271,6 +17503,7 @@
                     menuItemId: this.item.id,
                     doRemove: false
                 });
+                this.viewerDateTimeDispose();
             }
             async ReRender(params) {
                 let { entityIds, force, entities } = params;
@@ -17290,6 +17523,139 @@
                 this.styler.SetEntityCache(entityIds, entities);
                 this.styler.QueueEntities(regos, true);
             }
+            /**
+             * Monitors the Cesium Viewer and updates the root Entity based on the scene time changing.
+             * If the root Entity is historic, this can allow for movement of the assembly as a whole.
+             * @parma tileset
+             */
+            viewerDateTimeSub(tileset) {
+                var _a, _b;
+                if (!((_a = this.item.BruceEntity) === null || _a === void 0 ? void 0 : _a.historic) || this.viewerDateTimeChangeRemoval) {
+                    return;
+                }
+                let accountId = (_b = this.item.tileset) === null || _b === void 0 ? void 0 : _b.ClientAccountID;
+                if (!accountId) {
+                    accountId = this.getters.GetAccountId();
+                }
+                const api = this.getters.GetBruceApi({
+                    accountId: accountId
+                });
+                // Returns a series of positions to use for position interpolation based on time.
+                // If the timeline range is different to the previous query, we'll re-request the data.
+                const getSeriesPosses = async () => {
+                    const minDateTime = this.viewer.clock.startTime.toString();
+                    const maxDateTime = this.viewer.clock.stopTime.toString();
+                    if (this.historicPossesMinDateTime == minDateTime &&
+                        this.historicPossesMaxDateTime == maxDateTime) {
+                        if (this.historicPossesLoading) {
+                            if (!await this.historicPossesLoadingProm) {
+                                return false;
+                            }
+                        }
+                        return this.historicPosses;
+                    }
+                    this.historicPossesMinDateTime = minDateTime;
+                    this.historicPossesMaxDateTime = maxDateTime;
+                    this.historicPossesLoading = true;
+                    this.historicPossesLoadingProm = new Promise(async (res) => {
+                        // 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 BModels.EntityHistoricData.GetList({
+                            attrKey: null,
+                            dateTimeFrom: startStr,
+                            dateTimeTo: stopStr,
+                            entityIds: [this.rootId],
+                            api: api
+                        });
+                        const posses = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, Cesium.HeightReference.NONE, historicData.recordsByIds[this.rootId]);
+                        if (this.historicPossesMinDateTime == minDateTime &&
+                            this.historicPossesMaxDateTime == maxDateTime) {
+                            this.historicPosses = posses;
+                            this.historicPossesMinDateTime = minDateTime;
+                            this.historicPossesMaxDateTime = maxDateTime;
+                            this.historicPossesLoading = false;
+                            res(posses);
+                        }
+                        res(false);
+                    });
+                    return await this.historicPossesLoadingProm;
+                };
+                getSeriesPosses().then((posses) => {
+                    if (this.disposed || posses === false) {
+                        return;
+                    }
+                    let animation = new exports.CesiumAnimatedProperty.AnimateTPositionSeries({
+                        viewer: this.viewer,
+                        posses: posses,
+                        onUpdate: (pos3d, heading) => {
+                            if (this.disposed) {
+                                return;
+                            }
+                            const location = Cesium.Cartographic.fromCartesian(pos3d);
+                            const lat = Cesium.Math.toDegrees(location.latitude);
+                            const lon = Cesium.Math.toDegrees(location.longitude);
+                            const alt = location.height;
+                            const cTileset = this.cTileset;
+                            const prevCoords = cTileset._bruceCoords;
+                            const coords = {
+                                "Entity.ID": null,
+                                ...prevCoords,
+                                transform: {
+                                    ...prevCoords === null || prevCoords === void 0 ? void 0 : prevCoords.transform,
+                                    heading: heading
+                                },
+                                ucs: {
+                                    name: null,
+                                    transform: null,
+                                    ...prevCoords === null || prevCoords === void 0 ? void 0 : prevCoords.ucs,
+                                    "Entity.ID": this.rootId,
+                                    location: {
+                                        altitude: alt,
+                                        latitude: lat,
+                                        longitude: lon
+                                    }
+                                }
+                            };
+                            this.applyCoords(tileset, coords);
+                        }
+                    });
+                    this.viewerDateTimeChangeRemoval = () => {
+                        if (animation) {
+                            animation.stop();
+                            animation = null;
+                        }
+                    };
+                });
+            }
+            viewerDateTimeDispose() {
+                var _a;
+                (_a = this.viewerDateTimeChangeRemoval) === null || _a === void 0 ? void 0 : _a.call(this);
+                this.viewerDateTimeChangeRemoval = null;
+            }
+            /**
+             * Updates the Tileset with latest coordinates.
+             * This is used to refresh with new values, not to render the first time!
+             * @param tileset
+             * @param coords
+             */
+            applyCoords(tileset, coords) {
+                if (this.disposed || !this.cTileset || this.cTileset.isDestroyed()) {
+                    return;
+                }
+                const settings = tileset.settings;
+                exports.TilesetRenderEngine.ApplyPosition({
+                    cTileset: this.Tileset,
+                    position: {
+                        ucs: coords === null || coords === void 0 ? void 0 : coords.ucs,
+                        location: (coords === null || coords === void 0 ? void 0 : coords.location) == null ? settings.location : coords.location,
+                        transform: (coords === null || coords === void 0 ? void 0 : coords.transform) == null ? settings.transform : coords.transform
+                    }
+                });
+                this.viewer.scene.requestRender();
+            }
         }
         TilesetCadRenderManager.Manager = Manager;
     })(exports.TilesetCadRenderManager || (exports.TilesetCadRenderManager = {}));
@@ -30008,7 +30374,7 @@
         }
     }
 
-    const VERSION = "5.3.7";
+    const VERSION = "5.3.8";
 
     exports.VERSION = VERSION;
     exports.isHistoricMetadataChanged = isHistoricMetadataChanged;