bruce-cesium 5.5.0 → 5.5.2

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, HorizontalOrigin, VerticalOrigin, ConstantProperty, ClassificationType, ConstantPositionProperty, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, ColorBlendMode, HeadingPitchRoll, Transforms, Model, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, 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, BoundingSphere, GeometryInstance, ModelGraphics, PolygonGraphics, CorridorGraphics, PointGraphics, BillboardGraphics, EllipseGraphics, PolylineDashMaterialProperty, Quaternion, ScreenSpaceEventHandler, ScreenSpaceEventType, CzmlDataSource, Intersect, Fullscreen } from 'cesium';
+import { Cartographic, Cartesian2, Math as Math$1, Cartesian3, CallbackProperty, Color, HeightReference, Rectangle, JulianDate, Entity, DistanceDisplayCondition, HorizontalOrigin, VerticalOrigin, ConstantProperty, ClassificationType, ConstantPositionProperty, ArcType, CornerType, ShadowMode, PolygonHierarchy, PolylineGraphics, ColorMaterialProperty, ColorBlendMode, HeadingPitchRoll, Transforms, Model, Primitive, Cesium3DTileFeature, SceneMode, GeoJsonDataSource, Cesium3DTileStyle, HeadingPitchRange, Cesium3DTileColorBlendMode, Ion, KmlDataSource, SceneTransforms, OrthographicFrustum, EasingFunction, NearFarScalar, Cesium3DTileset, Matrix4, Matrix3, IonResource, EllipsoidTerrainProvider, IonImageryProvider, createWorldImagery, createWorldImageryAsync, BingMapsImageryProvider, BingMapsStyle, MapboxImageryProvider, MapboxStyleImageryProvider, ArcGisMapServerImageryProvider, OpenStreetMapImageryProvider, UrlTemplateImageryProvider, GridImageryProvider, GeographicTilingScheme, ImageryLayer, TileMapServiceImageryProvider, CesiumTerrainProvider, 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;
@@ -1144,34 +1144,57 @@ var CesiumAnimatedProperty;
      */
     class AnimatePositionSeries {
         constructor(params) {
+            // Current position state.
             this.lastCalcPos3d = null;
             this.lastCalcPosIndexLast = -1;
             this.lastCalcPosIndexNext = -1;
-            this.lastCalcTime = null;
+            // Series data for rendering path.
             this.lastCalcSeriesPos3d = [];
             this.lastCalcSeriesTime = null;
+            // Orientation.
             this.lastCalcOrient = null;
             this.lastCalcOrientTime = null;
-            // Indicates that the first time we get a GetValue position, we need to animate into it.
+            // Starting animation state.
             this.animateFromPos3d = null;
             this.animateFromPos3dTimeStart = null;
+            this.animationDuration = 200; // milliseconds
             this.viewer = params.viewer;
-            this.positions = params.posses;
-            this.pitch = params.pitch;
-            this.roll = params.roll;
-            this.animateFromPos3d = params.animateFromPos3d;
-            this.animateFromPos3dTimeStart = Date.now();
+            this.positions = params.posses || [];
+            this.pitch = params.pitch || 0;
+            this.roll = params.roll || 0;
+            // Animation from a starting position.
+            if (params.animateFromPos3d) {
+                this.animateFromPos3d = params.animateFromPos3d;
+                const currentTime = Date.now();
+                const providedTime = params.animateFromPos3dTimeStart || 0;
+                // Check if the provided timestamp is stale (animation would have already completed)
+                // If so, use current time to restart the animation.
+                if (!providedTime || (currentTime - providedTime) >= this.animationDuration) {
+                    this.animateFromPos3dTimeStart = currentTime;
+                }
+                else {
+                    this.animateFromPos3dTimeStart = providedTime;
+                }
+            }
             this.processHeadings();
             // Order positions by date.
-            this.positions.sort((a, b) => {
-                return a.dateTime.getTime() - b.dateTime.getTime();
-            });
+            if (this.positions.length > 0) {
+                this.positions.sort((a, b) => {
+                    return a.dateTime.getTime() - b.dateTime.getTime();
+                });
+            }
+        }
+        GetAnimateFromDateTime() {
+            return this.animateFromPos3dTimeStart;
         }
         /**
          * Pre-process headings in the series.
          * If all are null or 0, then we assume all are null.
          */
         processHeadings() {
+            if (!this.positions || this.positions.length === 0) {
+                return;
+            }
             let hasHeading = false;
             for (let i = 0; i < this.positions.length; i++) {
                 let pos = this.positions[i];
@@ -1189,100 +1212,130 @@ var CesiumAnimatedProperty;
         GetPositions() {
             return this.positions;
         }
+        easeInOutQuad(t) {
+            return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+        }
+        /**
+         * Interpolates between the starting position and target position.
+         */
+        interpolateToTargetPosition(startPos, targetPos, startTimeMs, currentTimeMs) {
+            if (!startPos || !targetPos) {
+                return startPos || targetPos || new Cartesian3();
+            }
+            const elapsedTime = currentTimeMs - startTimeMs;
+            let progress = Math.min(elapsedTime / this.animationDuration, 1.0);
+            // Apply easing for more natural motion.
+            progress = this.easeInOutQuad(progress);
+            try {
+                return Cartesian3.lerp(startPos, targetPos, progress, new Cartesian3());
+            }
+            catch (e) {
+                console.error("Error in position interpolation: ", e);
+                return targetPos;
+            }
+        }
+        /**
+         * Main method to get the current position based on time
+         */
         GetValue() {
             let now = this.viewer.scene.lastRenderTime;
             if (!now) {
                 now = this.viewer.clock.currentTime;
             }
             const nowTimeMs = JulianDate.toDate(now).getTime();
-            // Skip calculation if time hasn't changed.
-            if (this.lastCalcTime === nowTimeMs) {
+            const currentRealTimeMs = Date.now();
+            // Calculate the ideal position based on time.
+            const idealPosition = this.calculateIdealPosition(nowTimeMs);
+            // First run initialization.
+            if (!this.lastCalcPos3d) {
+                this.lastCalcPos3d = idealPosition;
+                // If we have a starting position, animate from it.
                 if (this.animateFromPos3d) {
-                    // We emit an interpolated position if we're animating from the start position.
-                    const interpolatedPos = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
-                    if (Cartesian3.equals(interpolatedPos, this.animateFromPos3d)) {
-                        this.animateFromPos3d = null;
-                    }
-                    return interpolatedPos;
-                }
-                return this.lastCalcPos3d;
-            }
-            const calculate = () => {
-                // See if we're before the first position.
-                if (nowTimeMs <= this.positions[0].dateTime.getTime()) {
-                    this.lastCalcPosIndexLast = 0;
-                    this.lastCalcPosIndexNext = 0;
-                    return this.positions[0].pos3d;
-                }
-                // See if we're after the last position.
-                if (nowTimeMs >= this.positions[this.positions.length - 1].dateTime.getTime()) {
-                    this.lastCalcPosIndexLast = this.positions.length - 1;
-                    this.lastCalcPosIndexNext = this.positions.length - 1;
-                    return this.positions[this.positions.length - 1].pos3d;
-                }
-                // Find the current position.
-                let lastIndex = 0;
-                for (let i = 1; i < this.positions.length; i++) {
-                    let pos = this.positions[i];
-                    if (nowTimeMs >= pos.dateTime.getTime()) {
-                        lastIndex = i;
-                    }
-                    else {
-                        break;
-                    }
+                    return this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
                 }
-                const last = this.positions[lastIndex];
-                this.lastCalcPosIndexLast = lastIndex;
-                // Interpolate the position.
-                let next = this.positions[lastIndex + 1];
-                if (!next) {
-                    this.lastCalcPosIndexNext = lastIndex;
-                    return last.pos3d;
-                }
-                this.lastCalcPosIndexNext = lastIndex + 1;
-                let progress = (nowTimeMs - last.dateTime.getTime()) / (next.dateTime.getTime() - last.dateTime.getTime());
-                return Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
-            };
-            this.lastCalcTime = nowTimeMs;
-            this.lastCalcPos3d = calculate();
-            let pos3d = this.lastCalcPos3d;
-            // We emit an interpolated position if we're animating from the start position.
-            if (this.animateFromPos3d && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
-                if (Cartesian3.equals(this.animateFromPos3d, this.lastCalcPos3d)) {
+                return idealPosition;
+            }
+            // If we're animating from a start position.
+            if (this.animateFromPos3d) {
+                const elapsedTime = currentRealTimeMs - this.animateFromPos3dTimeStart;
+                // If animation is complete, just return ideal position and clear animation state.
+                if (elapsedTime >= this.animationDuration) {
                     this.animateFromPos3d = null;
+                    this.lastCalcPos3d = idealPosition;
+                    return idealPosition;
                 }
-                else if (this.animateFromPos3d) {
-                    pos3d = this.interpolateToStartPos3d(this.animateFromPos3dTimeStart, Date.now());
-                    if (Cartesian3.equals(pos3d, this.animateFromPos3d)) {
-                        this.animateFromPos3d = null;
-                    }
-                }
+                // Otherwise continue interpolation.
+                const interpolatedPos = this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
+                this.lastCalcPos3d = interpolatedPos;
+                return interpolatedPos;
             }
-            return pos3d;
+            // If we're not animating, directly use the ideal position.
+            // This ensures we're exactly where we should be based on time.
+            this.lastCalcPos3d = idealPosition;
+            return idealPosition;
         }
         /**
-         * Interpolates between the start position and the last calculated position.
-         * This lets us animate in the series positions.
-         * @param nowMs
+         * Calculate the ideal position based on current time without any smoothing.
          */
-        interpolateToStartPos3d(startMs, nowMs) {
-            const startPos = this.animateFromPos3d;
-            const targetPos = this.lastCalcPos3d;
-            if (!startPos || !targetPos) {
-                return startPos ? startPos : targetPos;
+        calculateIdealPosition(timeMs) {
+            if (!this.positions || this.positions.length === 0) {
+                return new Cartesian3();
             }
-            const duration = nowMs - startMs;
-            let progress = duration / 300; // 300ms duration.
-            if (progress > 1) {
-                progress = 1;
+            // Before first position.
+            if (timeMs <= this.positions[0].dateTime.getTime()) {
+                this.lastCalcPosIndexLast = 0;
+                this.lastCalcPosIndexNext = 0;
+                return this.positions[0].pos3d || new Cartesian3();
+            }
+            // After last position.
+            if (timeMs >= this.positions[this.positions.length - 1].dateTime.getTime()) {
+                const lastIndex = this.positions.length - 1;
+                this.lastCalcPosIndexLast = lastIndex;
+                this.lastCalcPosIndexNext = lastIndex;
+                return this.positions[lastIndex].pos3d || new Cartesian3();
+            }
+            // Find the position before and after the current time.
+            let lastIndex = 0;
+            for (let i = 0; i < this.positions.length - 1; i++) {
+                if (timeMs >= this.positions[i].dateTime.getTime() &&
+                    timeMs < this.positions[i + 1].dateTime.getTime()) {
+                    lastIndex = i;
+                    break;
+                }
+            }
+            const last = this.positions[lastIndex];
+            this.lastCalcPosIndexLast = lastIndex;
+            // If we're exactly at this position's time.
+            if (timeMs === last.dateTime.getTime()) {
+                this.lastCalcPosIndexNext = lastIndex;
+                return last.pos3d || new Cartesian3();
+            }
+            // Interpolate between surrounding positions.
+            const next = this.positions[lastIndex + 1];
+            if (!next) {
+                this.lastCalcPosIndexNext = lastIndex;
+                return last.pos3d || new Cartesian3();
+            }
+            this.lastCalcPosIndexNext = lastIndex + 1;
+            try {
+                // Ensure both position vectors are valid.
+                if (!last.pos3d || !next.pos3d) {
+                    return last.pos3d || next.pos3d || new Cartesian3();
+                }
+                const progress = (timeMs - last.dateTime.getTime()) /
+                    (next.dateTime.getTime() - last.dateTime.getTime());
+                return Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cartesian3());
+            }
+            catch (e) {
+                console.error("Error in ideal position calculation: ", e);
+                return last.pos3d || new Cartesian3();
             }
-            return Cartesian3.lerp(startPos, targetPos, progress, new Cartesian3());
         }
         /**
-         * Returns a series of positions to use for rendering the path.
+         * Returns a series of positions to use for rendering the path..
          */
         GetSeries() {
-            // We update 30 times a second.
+            // Update at 30 fps.
             let doUpdate = this.lastCalcSeriesTime == null;
             if (!doUpdate && this.lastCalcSeriesTime && (new Date().getTime() - this.lastCalcSeriesTime) > 1000 / 30) {
                 doUpdate = true;
@@ -1290,7 +1343,7 @@ var CesiumAnimatedProperty;
             if (!doUpdate) {
                 return this.lastCalcSeriesPos3d;
             }
-            // Refresh cached values.
+            // Ensure position indices are up-to-date.
             this.GetValue();
             let now = this.viewer.scene.lastRenderTime;
             if (!now) {
@@ -1298,17 +1351,25 @@ var CesiumAnimatedProperty;
             }
             const nowDate = JulianDate.toDate(now);
             // Get total duration.
-            const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() - this.positions[0].dateTime.getTime();
+            if (!this.positions || this.positions.length < 2) {
+                this.lastCalcSeriesTime = nowDate.getTime();
+                this.lastCalcSeriesPos3d = [];
+                return [];
+            }
+            const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() -
+                this.positions[0].dateTime.getTime();
             // Percentage of the polyline to be visible before and after each point.
             const visibilityPercentage = 0.05; // 5%
             const visibilityDuration = totalDuration * visibilityPercentage;
             // Gather positions that fall within the visibility duration.
-            // No positions is valid.
             const newPosses = [];
             for (let i = 0; i < this.positions.length; i++) {
                 const pos = this.positions[i];
-                let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) && nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
-                // Not valid time-wise but if we're currently rendering this segment then we'll show it.
+                if (!pos.pos3d)
+                    continue;
+                let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) &&
+                    nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
+                // Also include the segment we're currently traversing.
                 if (!add && this.lastCalcPosIndexLast > -1 && this.lastCalcPosIndexNext > -1) {
                     add = i >= this.lastCalcPosIndexLast && i <= this.lastCalcPosIndexNext;
                 }
@@ -1321,93 +1382,112 @@ var CesiumAnimatedProperty;
             return newPosses;
         }
         /**
-         * Returns the orientation of the Entity.
-         * This will be based on either the series data, or a calculated heading if it's not available in the data.
-         * @returns
+         * Returns the orientation based on current position and heading.
          */
         GetOrient() {
+            // Update at 30 fps.
             let doUpdate = this.lastCalcOrientTime == null;
             if (!doUpdate && this.lastCalcOrientTime && (new Date().getTime() - this.lastCalcOrientTime) > 1000 / 30) {
                 doUpdate = true;
             }
-            if (!doUpdate) {
+            if (!doUpdate && this.lastCalcOrient) {
                 return this.lastCalcOrient;
             }
-            if (this.positions.length === 0) {
-                return this.lastCalcOrient;
+            // Default quaternion to return if we can't calculate.
+            const defaultQuaternion = new Quaternion();
+            if (!this.positions || this.positions.length === 0) {
+                return defaultQuaternion;
+            }
+            // Ensure position is up-to-date.
+            const currentPosition = this.GetValue();
+            if (!currentPosition) {
+                return defaultQuaternion;
             }
-            // Refresh cached values.
-            this.GetValue();
             let now = this.viewer.scene.lastRenderTime;
             if (!now) {
                 now = this.viewer.clock.currentTime;
             }
             const nowTime = JulianDate.toDate(now).getTime();
-            // Determine the indices of the last and next positions
-            const lastIndex = this.lastCalcPosIndexLast;
-            const nextIndex = this.lastCalcPosIndexNext;
-            // Ensure valid indices
-            if (lastIndex < 0 || nextIndex < 0 || lastIndex >= this.positions.length || nextIndex >= this.positions.length) {
-                return this.lastCalcOrient;
-            }
-            const lastPos = this.positions[lastIndex];
-            const nextPos = this.positions[nextIndex];
-            // If the heading is present and not null, interpolate or use it directly
-            if (lastPos.heading !== null && nextPos.heading !== null) {
-                let deltaHeading = nextPos.heading - lastPos.heading;
-                // Handle wraparound between 359 and 0 degrees
-                if (deltaHeading > 180) {
-                    deltaHeading -= 360;
-                }
-                else if (deltaHeading < -180) {
-                    deltaHeading += 360;
+            try {
+                // Get last and next position indices.
+                const lastIndex = this.lastCalcPosIndexLast;
+                const nextIndex = this.lastCalcPosIndexNext;
+                // Validate indices.
+                if (lastIndex < 0 || nextIndex < 0 ||
+                    lastIndex >= this.positions.length || nextIndex >= this.positions.length) {
+                    return this.lastCalcOrient || defaultQuaternion;
+                }
+                const lastPos = this.positions[lastIndex];
+                const nextPos = this.positions[nextIndex];
+                if (!lastPos || !nextPos) {
+                    return this.lastCalcOrient || defaultQuaternion;
+                }
+                // Use explicit heading values if available.
+                if (lastPos.heading !== null && nextPos.heading !== null) {
+                    // Calculate interpolated heading.
+                    let deltaHeading = nextPos.heading - lastPos.heading;
+                    // Handle wrap-around between 359° and 0°.
+                    if (deltaHeading > 180) {
+                        deltaHeading -= 360;
+                    }
+                    else if (deltaHeading < -180) {
+                        deltaHeading += 360;
+                    }
+                    // Calculate interpolation factor.
+                    let factor = 0;
+                    if (lastIndex !== nextIndex &&
+                        lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
+                        factor = (nowTime - lastPos.dateTime.getTime()) /
+                            (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
+                        factor = Math.max(0, Math.min(1, factor));
+                    }
+                    // Apply easing for smoother rotation.
+                    factor = this.easeInOutQuad(factor);
+                    // Calculate final heading.
+                    let interpolatedHeading = lastPos.heading + factor * deltaHeading;
+                    interpolatedHeading = (interpolatedHeading + 360) % 360;
+                    // Create quaternion from heading, pitch, roll.
+                    this.lastCalcOrient = Transforms.headingPitchRollQuaternion(currentPosition, new HeadingPitchRoll(Math$1.toRadians(interpolatedHeading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
+                }
+                // Calculate heading from position changes if not available.
+                else {
+                    if (!lastPos.pos3d || !nextPos.pos3d) {
+                        return this.lastCalcOrient || defaultQuaternion;
+                    }
+                    // Flatten positions to avoid altitude-related heading changes.
+                    const adjustedPointPrev = Cartographic.fromCartesian(lastPos.pos3d);
+                    const adjustedPos3dPrev = Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
+                    const adjustedPointNext = Cartographic.fromCartesian(nextPos.pos3d);
+                    const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
+                    // Skip if positions are too close (less than 5cm).
+                    const distance = Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext);
+                    if (distance < 0.05) {
+                        return this.lastCalcOrient || defaultQuaternion;
+                    }
+                    // Calculate direction vector.
+                    const direction = Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cartesian3());
+                    // Skip if no movement.
+                    if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
+                        return this.lastCalcOrient || defaultQuaternion;
+                    }
+                    // Normalize the direction vector.
+                    Cartesian3.normalize(direction, direction);
+                    // Calculate rotation based on movement direction.
+                    const rotationMatrix = Transforms.rotationMatrixFromPositionVelocity(currentPosition, direction);
+                    // Convert to quaternion.
+                    const quaternion = Quaternion.fromRotationMatrix(rotationMatrix);
+                    // Add pitch and roll adjustments.
+                    const hpr = new HeadingPitchRoll(0, Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll));
+                    const pitchRollQuaternion = Quaternion.fromHeadingPitchRoll(hpr);
+                    // Combine quaternions.
+                    this.lastCalcOrient = Quaternion.multiply(quaternion, pitchRollQuaternion, new Quaternion());
                 }
-                const factor = (nowTime - lastPos.dateTime.getTime()) / (nextPos.dateTime.getTime() - lastPos.dateTime.getTime());
-                let interpolatedHeading = lastPos.heading + factor * deltaHeading;
-                interpolatedHeading = (interpolatedHeading + 360) % 360;
-                this.lastCalcOrient = Transforms.headingPitchRollQuaternion(this.lastCalcPos3d, new HeadingPitchRoll(Math$1.toRadians(interpolatedHeading), Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll)));
             }
-            // If no valid heading is available, calculate based on movement direction
-            else {
-                const previousPos = this.positions[lastIndex].pos3d;
-                if (!previousPos || isNaN(previousPos.x)) {
-                    return this.lastCalcOrient;
-                }
-                const nextPos = this.positions[nextIndex].pos3d;
-                if (!nextPos || isNaN(nextPos.x)) {
-                    return this.lastCalcOrient;
-                }
-                // 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(nextPos);
-                const adjustedPos3dNext = Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
-                // Check if the previous and current positions are the same.
-                // We apply a threshold as well to avoid jittering.
-                if (Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext) < 0.05) {
-                    return this.lastCalcOrient;
-                }
-                const direction = Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cartesian3());
-                // No movement, return the last calculated orientation.
-                if (direction.x == 0 && direction.y == 0 && direction.z == 0) {
-                    return this.lastCalcOrient;
-                }
-                Cartesian3.normalize(direction, direction);
-                // Calculate the rotation matrix from the position and direction.
-                let curPosition = this.lastCalcPos3d;
-                if (!curPosition || isNaN(curPosition.x)) {
-                    curPosition = adjustedPos3dPrev;
-                }
-                const rotationMatrix = Transforms.rotationMatrixFromPositionVelocity(curPosition, direction);
-                // Convert the rotation matrix to a quaternion.
-                const quaternion = Quaternion.fromRotationMatrix(rotationMatrix);
-                // Apply pitch and roll adjustments
-                const hpr = new HeadingPitchRoll(0, Math$1.toRadians(this.pitch), Math$1.toRadians(this.roll));
-                const pitchRollQuaternion = Quaternion.fromHeadingPitchRoll(hpr);
-                // Combine the direction quaternion with pitch and roll.
-                Quaternion.multiply(quaternion, pitchRollQuaternion, quaternion);
-                this.lastCalcOrient = quaternion;
+            catch (e) {
+                console.error("Error calculating orientation: ", e);
+                return this.lastCalcOrient || defaultQuaternion;
             }
+            this.lastCalcOrientTime = Date.now();
             return this.lastCalcOrient;
         }
     }
@@ -1544,91 +1624,100 @@ var CesiumAnimatedProperty;
                 }
             }
         }
-        /**
-         * Update function called on each render frame.
-         */
         update() {
             if (!this.positions || this.positions.length === 0) {
                 return;
             }
-            let now = this.viewer.scene.lastRenderTime;
-            if (!now) {
-                now = this.viewer.clock.currentTime;
-            }
+            // Get current time.
+            let now = this.viewer.scene.lastRenderTime || this.viewer.clock.currentTime;
             const nowTime = JulianDate.toDate(now);
             const nowTimeMs = nowTime.getTime();
-            // Skip calculation if time hasn't changed.
-            if (this.lastCalcTime === nowTimeMs) {
-                // If we're currently mid-animation, we need to update the position over time.
-                if (this.lastCalcPosApplyOverTime) {
-                    const interpolatedPos = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
-                    if (Cartesian3.equals(interpolatedPos, this.lastCalcPos3dApplyOverTimeTarget)) {
-                        this.lastCalcPosApplyOverTime = false;
-                        this.lastCalcPos3d = interpolatedPos;
-                    }
-                    this.onUpdate(interpolatedPos, this.lastCalcHeading);
-                }
+            const currentRealTimeMs = Date.now();
+            // Calculate the ideal position based on current time.
+            const targetPosition = this.calculatePosition(nowTimeMs);
+            // Initialize if this is the first update.
+            if (!this.lastCalcPos3d) {
+                this.lastCalcPos3d = targetPosition.pos3d;
+                this.onUpdate(targetPosition.pos3d, this.lastCalcHeading);
                 return;
             }
-            // Calculate position.
-            const position = this.calculatePosition(nowTimeMs);
-            // Calculate what position to emit.
-            let pos3d = null;
-            // Update cache values.
-            this.lastCalcTime = nowTimeMs;
-            if (position.applyOverTime && Cartes.ValidateCartes3(this.lastCalcPos3d)) {
-                if (Cartesian3.equals(this.lastCalcPos3d, position.pos3d)) {
-                    pos3d = position.pos3d;
+            // Check if target has changed.
+            if (!this.lastCalcPos3dApplyOverTimeTarget ||
+                !Cartesian3.equals(this.lastCalcPos3dApplyOverTimeTarget, targetPosition.pos3d)) {
+                // If we were already interpolating, get the current interpolated position as our new starting point.
+                if (this.lastCalcPosApplyOverTime && this.lastCalcPos3dApplyOverTimeTimeStart) {
+                    // Calculate where we are in the current interpolation.
+                    const currentInterpolatedPos = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, currentRealTimeMs);
+                    // Use this as our new starting position.
+                    this.lastCalcPos3d = currentInterpolatedPos;
+                }
+                // Set new target and start time.
+                this.lastCalcPos3dApplyOverTimeTarget = targetPosition.pos3d;
+                this.lastCalcPos3dApplyOverTimeTimeStart = currentRealTimeMs;
+                this.lastCalcPosApplyOverTime = true;
+            }
+            // Calculate the interpolated position.
+            let pos3d;
+            if (this.lastCalcPosApplyOverTime) {
+                pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, currentRealTimeMs);
+                // If we've reached the target, update our base position.
+                if (Cartesian3.distance(pos3d, this.lastCalcPos3dApplyOverTimeTarget) < 0.01) {
+                    this.lastCalcPos3d = this.lastCalcPos3dApplyOverTimeTarget;
                     this.lastCalcPosApplyOverTime = false;
                 }
-                else if (Cartesian3.equals(this.lastCalcPos3dApplyOverTimeTarget, position.pos3d)) {
-                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
-                    if (Cartesian3.equals(pos3d, this.lastCalcPos3dApplyOverTimeTarget)) {
-                        this.lastCalcPos3d = pos3d;
-                        this.lastCalcPosApplyOverTime = false;
-                    }
-                }
-                else {
-                    if (!this.lastCalcPosApplyOverTime) {
-                        this.lastCalcPos3dApplyOverTimeTimeStart = Date.now();
-                    }
-                    this.lastCalcPosApplyOverTime = true;
-                    this.lastCalcPos3dApplyOverTimeTarget = position.pos3d;
-                    pos3d = this.interpolatePos3dOverTime(this.lastCalcPos3dApplyOverTimeTimeStart, Date.now());
-                }
             }
             else {
-                this.lastCalcPos3d = position.pos3d;
-                pos3d = position.pos3d;
+                pos3d = this.lastCalcPos3d;
             }
             // Calculate heading.
-            const posses = this.positions;
-            const lastPos = posses[position.indexLast];
-            const nextPos = posses[position.indexNext];
-            if (lastPos && nextPos) {
-                this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
+            if (this.lastCalcPos3dApplyOverTimeTarget) {
+                if (this.lastCalcPos3d) {
+                    const minDistanceThreshold = 0.05;
+                    const currentToTargetDistance = Cartesian3.distance(this.lastCalcPos3d, this.lastCalcPos3dApplyOverTimeTarget);
+                    if (currentToTargetDistance >= minDistanceThreshold) {
+                        const lastPos = {
+                            pos3d: this.lastCalcPos3d,
+                            dateTime: this.lastCalcPos3dApplyOverTimeTimeStart ? new Date(this.lastCalcPos3dApplyOverTimeTimeStart) : null,
+                            heading: null
+                        };
+                        const nextPos = {
+                            pos3d: this.lastCalcPos3dApplyOverTimeTarget,
+                            dateTime: null,
+                            heading: null
+                        };
+                        if (lastPos && nextPos) {
+                            this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
+                        }
+                    }
+                }
+            }
+            else {
+                const posses = this.positions;
+                const lastPos = posses[targetPosition.indexLast];
+                const nextPos = posses[targetPosition.indexNext];
+                if (lastPos && nextPos) {
+                    this.lastCalcHeading = this.calculateHeading(nowTimeMs, lastPos, nextPos);
+                }
             }
             // Provide the calculated values to the caller.
             this.onUpdate(pos3d, this.lastCalcHeading);
         }
-        /**
-         * Interpolates the position over time between the last and target positions.
-         * This is used when we reach a boundary position so to smoothly animate to it, we move from the current position to it.
-         * @param nowMs
-         */
-        interpolatePos3dOverTime(prevMs, nowMs) {
+        interpolatePos3dOverTime(startTimeMs, currentTimeMs) {
             const lastPos = this.lastCalcPos3d;
             const targetPos = this.lastCalcPos3dApplyOverTimeTarget;
             if (!lastPos || !targetPos) {
                 return lastPos ? lastPos : targetPos;
             }
-            const duration = nowMs - prevMs;
-            let progress = duration / 300; // 300ms duration.
-            if (progress > 1) {
-                progress = 1;
-            }
+            const interpolationDuration = 200;
+            const elapsedTime = currentTimeMs - startTimeMs;
+            let progress = Math.min(elapsedTime / interpolationDuration, 1.0);
+            // Optional step to make it smoother.
+            progress = this.easeInOutQuad(progress);
             return Cartesian3.lerp(lastPos, targetPos, progress, new Cartesian3());
         }
+        easeInOutQuad(t) {
+            return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+        }
         /**
          * Pre-process headings in the series.
          * If all are null or 0, then assume all are null.
@@ -4611,6 +4700,7 @@ var EntityRenderEnginePoint;
                                 viewer: params.viewer
                             });
                             position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                            position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
                         }
                         else {
                             position = new CallbackProperty(() => EntityUtils.GetPos({
@@ -4622,7 +4712,7 @@ var EntityRenderEnginePoint;
                             }), true);
                         }
                         cEntity = new Entity({
-                            id: ObjectUtils.UId(10),
+                            id: ObjectUtils.UId(15),
                             billboard: {
                                 horizontalOrigin: HorizontalOrigin.CENTER,
                                 verticalOrigin: VerticalOrigin.BOTTOM,
@@ -4668,15 +4758,21 @@ var EntityRenderEnginePoint;
                         cEntity.billboard.width = undefined;
                         cEntity.billboard.height = undefined;
                         const prevPos3d = GetCValue(params.viewer, cEntity.position);
+                        let prevStartTime = null;
+                        if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                            prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
+                        }
                         // If we have a series of time-based positions then we'll animate as time changes.
                         const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                         if (series.length > 1) {
                             animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                                 posses: series,
                                 viewer: params.viewer,
-                                animateFromPos3d: prevPos3d
+                                animateFromPos3d: prevPos3d,
+                                animateFromPos3dTimeStart: prevStartTime
                             });
                             cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                            cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
                         }
                         else {
                             const pos3d = EntityUtils.GetPos({
@@ -4761,7 +4857,7 @@ var EntityRenderEnginePoint;
             }
             if (!params.rendered || !params.rendered.ellipse) {
                 cEntity = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     ellipse: {
                         semiMajorAxis: radius,
                         semiMinorAxis: radius,
@@ -4879,7 +4975,7 @@ var EntityRenderEnginePoint;
                 }
                 else {
                     outlineEntity = new Entity({
-                        id: ObjectUtils.UId(10),
+                        id: ObjectUtils.UId(15),
                         ellipse: {
                             semiMajorAxis: radius + outlineWidth,
                             semiMinorAxis: radius + outlineWidth,
@@ -4930,6 +5026,7 @@ var EntityRenderEnginePoint;
                         viewer: params.viewer
                     });
                     position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                    position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
                 }
                 else {
                     position = new CallbackProperty(() => EntityUtils.GetPos({
@@ -4941,7 +5038,7 @@ var EntityRenderEnginePoint;
                     }), true);
                 }
                 cEntity = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     // point: {
                     //     pixelSize: size,
                     //     color: cColor,
@@ -4992,15 +5089,21 @@ var EntityRenderEnginePoint;
                 cEntity.billboard.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
                 cEntity.billboard.disableDepthTestDistance = new ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
                 const prevPos3d = GetCValue(params.viewer, cEntity.position);
+                let prevStartTime = null;
+                if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                    prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
+                }
                 // If we have a series of time-based positions then we'll animate as time changes.
                 const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                 if (series.length > 1) {
                     animatePosition = new CesiumAnimatedProperty.AnimatePositionSeries({
                         posses: series,
                         viewer: params.viewer,
-                        animateFromPos3d: prevPos3d
+                        animateFromPos3d: prevPos3d,
+                        animateFromPos3dTimeStart: prevStartTime
                     });
                     cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
                 }
                 else {
                     const pos3d = EntityUtils.GetPos({
@@ -5048,7 +5151,7 @@ var EntityRenderEnginePoint;
             let trackEntity = siblings === null || siblings === void 0 ? void 0 : siblings[0];
             if (!trackEntity || !trackEntity.polyline) {
                 trackEntity = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     polyline: {
                         positions: [],
                         width: width,
@@ -6529,6 +6632,7 @@ var EntityRenderEngineModel3d;
                     roll: roll
                 });
                 position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
             }
             else {
                 position = new CallbackProperty(() => EntityUtils.GetPos({
@@ -6552,7 +6656,7 @@ var EntityRenderEngineModel3d;
                 }, false);
             }
             cEntity = new Entity({
-                id: ObjectUtils.UId(10),
+                id: ObjectUtils.UId(15),
                 model: {
                     uri: params.lodUrl,
                     heightReference: heightRef,
@@ -6596,6 +6700,10 @@ var EntityRenderEngineModel3d;
             cEntity.model.colorBlendMode = new ConstantProperty(blendMode);
             cEntity.model.distanceDisplayCondition = new ConstantProperty(EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
             const prevPos3d = GetCValue(params.viewer, cEntity.position);
+            let prevStartTime = null;
+            if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
+            }
             // If we have a series of time-based positions then we'll animate as time changes.
             const series = CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
             if (series.length > 1) {
@@ -6604,9 +6712,11 @@ var EntityRenderEngineModel3d;
                     viewer: params.viewer,
                     pitch: pitch,
                     roll: roll,
-                    animateFromPos3d: prevPos3d
+                    animateFromPos3d: prevPos3d,
+                    animateFromPos3dTimeStart: prevStartTime
                 });
                 cEntity.position = new CallbackProperty(() => animatePosition.GetValue(), false);
+                cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
             }
             else {
                 const posChanged = !prevPos3d || !Cartesian3.equals(prevPos3d, pos3d);
@@ -6776,7 +6886,7 @@ var EntityRenderEngineModel3d;
             let trackEntity = siblings === null || siblings === void 0 ? void 0 : siblings[0];
             if (!trackEntity || !trackEntity.polyline) {
                 trackEntity = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     polyline: {
                         positions: [],
                         width: width,
@@ -7164,7 +7274,7 @@ var EntityRenderEnginePolyline;
         if (!params.rendered || ((!params.rendered.polyline && units == "px") ||
             (!params.rendered.corridor && units == "m"))) {
             cEntity = new Entity({
-                id: ObjectUtils.UId(10),
+                id: ObjectUtils.UId(15),
                 polyline: units == "px" ? {
                     positions: posses,
                     material: cColor,
@@ -7547,7 +7657,7 @@ var EntityRenderEnginePolygon;
         let cEntity = null;
         if (!params.rendered || !params.rendered.polygon) {
             cEntity = new Entity({
-                id: ObjectUtils.UId(10),
+                id: ObjectUtils.UId(15),
                 polygon: {
                     hierarchy: new PolygonHierarchy(posses, holePosses.map(x => new PolygonHierarchy(x))),
                     material: cFillColor,
@@ -7643,7 +7753,7 @@ var EntityRenderEnginePolygon;
             if (!cEntityBorder || ((!cEntityBorder.polyline && units == "px") ||
                 (!cEntityBorder.corridor && units == "m"))) {
                 cEntityBorder = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     polyline: units == "px" ? new PolylineGraphics({
                         positions: borderPosses,
                         material: cLineColor,
@@ -7736,7 +7846,7 @@ var EntityRenderEnginePolygon;
                 const posses = holePosses[i];
                 Cartes.CloseRing3(posses);
                 const cEntityHole = new Entity({
-                    id: ObjectUtils.UId(10),
+                    id: ObjectUtils.UId(15),
                     polyline: units == "px" ? new PolylineGraphics({
                         positions: posses,
                         material: cLineColor,
@@ -8363,7 +8473,7 @@ var EntityRenderEngine;
                 rendered = rendered.filter(x => x != null);
                 if (rendered.length) {
                     const rootEntity = new Entity({
-                        id: ObjectUtils.UId(10)
+                        id: ObjectUtils.UId(15)
                     });
                     rootEntity._siblingGraphics = [];
                     rootEntity._renderGroup = GetRenderGroupId(zoomItem);
@@ -17110,7 +17220,7 @@ var SharedGetters;
                 if (params.viewer && params.debugShowBounds) {
                     // Cell id -> entity.
                     const cellCache = {};
-                    const cellPrefix = ObjectUtils.UId(10) + "_";
+                    const cellPrefix = ObjectUtils.UId(15) + "_";
                     getter.OnScanUpdate.Subscribe((cells) => {
                         if (window.ON_SCAN_UPDATE_PAUSED == true) {
                             return;
@@ -17909,7 +18019,7 @@ var TilesetCadRenderManager;
                         if (this.disposed) {
                             return;
                         }
-                        // Reverse heading .
+                        // Reverse heading.
                         // Not sure if calc or model is the issue.
                         // This is all for a single demo until we figure out how we configure assemblies for this anyways.
                         heading = heading + 180;
@@ -30769,7 +30879,7 @@ class WidgetViewBar extends Widget.AWidget {
     }
 }
 
-const VERSION = "5.5.0";
+const VERSION = "5.5.2";
 
 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, CESIUM_TIMELINE_LIVE_KEY, CESIUM_TIMELINE_LIVE_PADDING_KEY, CESIUM_TIMELINE_INTERVAL_KEY, DEFAULT_LIVE_PADDING_SECONDS, 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