bruce-cesium 5.3.6 → 5.3.8

package/dist/bruce-cesium.es5.js

@@ -1,6 +1,6 @@
 import { BruceEvent, Cartes, Entity as Entity$1, Carto, Geometry, MathUtils, LRUCache, Api, Calculator, ClientFile, EntityTag, EntityType, ObjectUtils, Style, ProjectViewTile, DelayQueue, EntityLod, Bounds, ZoomControl, EntityRelationType, ENVIRONMENT, EntityHistoricData, Tileset, EntityCoords, DataLab, EntitySource, MenuItem, EntityRelation, ProgramKey, ProjectView, ProjectViewBookmark, Camera, ProjectViewLegacyTile, EntityAttachment, EntityAttachmentType, EntityAttribute, AbstractApi, Session } from 'bruce-models';
 import * as Cesium from 'cesium';
-import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, ColorBlendMode, HeadingPitchRoll, Transforms, Model, SceneMode, GeoJsonDataSource, Primitive, Cesium3DTileFeature, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, KmlDataSource, SceneTransforms, EllipsoidTerrainProvider, CesiumInspector, OrthographicFrustum, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, Cesium3DTileset, PolygonPipeline, Matrix4, Matrix3, IonResource, EasingFunction, NearFarScalar, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Quaternion, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, ClassificationType, ArcType, CornerType, ShadowMode, ConstantProperty, ConstantPositionProperty, HorizontalOrigin, VerticalOrigin, ColorBlendMode, HeadingPitchRoll, Transforms, Model, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, SceneMode, GeoJsonDataSource, Primitive, Cesium3DTileFeature, Cesium3DTileStyle, Cesium3DTileColorBlendMode, HeadingPitchRange, Ion, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, NearFarScalar, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, Cesium3DTileset, Matrix4, Matrix3, IonResource, CesiumInspector, defined, ClockRange, EllipsoidGeodesic, sampleTerrainMostDetailed, PolygonPipeline, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, BoundingSphere, GeometryInstance, Quaternion, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
 
 const TIME_LAG = 300;
 const POSITION_CHECK_TIMER = 950;
@@ -1406,6 +1406,225 @@ var CesiumAnimatedProperty;
         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 = 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 = Cartesian3.lerp(last.pos3d, next.pos3d, progress, new 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 = Cartographic.fromCartesian(previousPos);
+                const adjustedPos3dPrev = Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
+                const adjustedPointNext = Cartographic.fromCartesian(currentPos);
+                const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
+                // Check if the positions are too close.
+                if (Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext) < 0.05) {
+                    return null;
+                }
+                const direction = Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cartesian3());
+                // No movement.
+                if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
+                    return null;
+                }
+                // Calculate heading from the direction vector.
+                Cartesian3.normalize(direction, direction);
+                // Convert the direction to a heading angle.
+                const east = Cartesian3.UNIT_X;
+                const north = Cartesian3.UNIT_Y;
+                const heading = Math.atan2(Cartesian3.dot(direction, east), Cartesian3.dot(direction, north));
+                // Convert to degrees.
+                return (Math$1.toDegrees(heading) + 360) % 360;
+            }
+        }
+    }
+    CesiumAnimatedProperty.AnimateTPositionSeries = AnimateTPositionSeries;
 })(CesiumAnimatedProperty || (CesiumAnimatedProperty = {}));
 
 /**
@@ -16772,6 +16991,11 @@ var TilesetRenderEngine;
         }
         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;
@@ -16874,7 +17098,7 @@ var TilesetRenderEngine;
  * CAD tilesets are referred to as "MODEL" tilesets in some other areas of Bruce code.
  */
 var TilesetCadRenderManager;
-(function (TilesetCadRenderManager) {
+(function (TilesetCadRenderManager$$1) {
     class Manager {
         get Disposed() {
             return this.disposed;
@@ -16901,6 +17125,12 @@ var TilesetCadRenderManager;
             // 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;
@@ -17042,6 +17272,8 @@ var TilesetCadRenderManager;
                             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);
@@ -17331,6 +17563,7 @@ var TilesetCadRenderManager;
                 menuItemId: this.item.id,
                 doRemove: false
             });
+            this.viewerDateTimeDispose();
         }
         async ReRender(params) {
             let { entityIds, force, entities } = params;
@@ -17350,8 +17583,141 @@ var TilesetCadRenderManager;
             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 = JulianDate.toDate(this.viewer.clock.startTime);
+                    const stopTmp = 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 EntityHistoricData.GetList({
+                        attrKey: null,
+                        dateTimeFrom: startStr,
+                        dateTimeTo: stopStr,
+                        entityIds: [this.rootId],
+                        api: api
+                    });
+                    const posses = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(this.viewer, 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 CesiumAnimatedProperty.AnimateTPositionSeries({
+                    viewer: this.viewer,
+                    posses: posses,
+                    onUpdate: (pos3d, heading) => {
+                        if (this.disposed) {
+                            return;
+                        }
+                        const location = Cartographic.fromCartesian(pos3d);
+                        const lat = Math$1.toDegrees(location.latitude);
+                        const lon = Math$1.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;
+            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;
+    TilesetCadRenderManager$$1.Manager = Manager;
 })(TilesetCadRenderManager || (TilesetCadRenderManager = {}));
 
 var DataLabRenderManager;
@@ -30105,7 +30471,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.3.6";
+const VERSION = "5.3.8";
 
 export { VERSION, CesiumViewMonitor, ViewerUtils, ViewerEventTracker, MenuItemManager, isHistoricMetadataChanged, EntityRenderEngine, EntityRenderEnginePoint, EntityRenderEnginePolyline, EntityRenderEnginePolygon, EntityRenderEngineModel3d, MenuItemCreator, VisualsRegister, RenderManager, EntitiesIdsRenderManager, DataLabRenderManager, EntitiesLoadedRenderManager, EntitiesRenderManager, EntityRenderManager, TilesetCadRenderManager, TilesetArbRenderManager, TilesetEntitiesRenderManager, TilesetOsmRenderManager, TilesetPointcloudRenderManager, TilesetGooglePhotosRenderManager, DataSourceStaticKmlManager, GoogleSearchRenderManager, RelationsRenderManager, SharedGetters, CesiumParabola, EntityLabel, ViewRenderEngine, TileRenderEngine, TilesetRenderEngine, CESIUM_INSPECTOR_KEY, CESIUM_TIMELINE_KEY, ViewUtils, DrawingUtils, MeasureUtils, EntityUtils, CesiumEntityStyler, CesiumAnimatedProperty, CesiumAnimatedInOut, Draw3dPolygon, Draw3dPolyline, MeasureCreator, Walkthrough, Widget, VIEWER_BOOKMARKS_WIDGET_KEY, WidgetBookmarks, WidgetBranding, WidgetCursorBar, WidgetEmbeddedInfoView, WidgetInfoView, WidgetNavCompass$$1 as WidgetNavCompass, VIEWER_VIEW_BAR_WIDGET_KEY, WidgetViewBar, WidgetControlViewBar, WidgetControlViewBarSearch, VIEWER_LEFT_PANEL_WIDGET_KEY, VIEWER_LEFT_PANEL_CSS_VAR_LEFT, WidgetLeftPanel, WidgetLeftPanelTab, WidgetLeftPanelTabBookmarks };
 //# sourceMappingURL=bruce-cesium.es5.js.map