bruce-cesium 5.9.5 → 5.9.7

package/dist/bruce-cesium.umd.js

@@ -1142,48 +1142,70 @@
          */
         class AnimatePositionSeries {
             constructor(params) {
-                // Current position state.
-                this.lastCalcPos3d = null;
-                this.lastCalcPosIndexLast = -1;
-                this.lastCalcPosIndexNext = -1;
-                // Series data for rendering path.
+                // Animation state.
+                this.currentAnimatedPos = null;
+                this.actualTargetPos = null;
+                this.animationStartPos = null;
+                this.animationStartTime = null;
+                this.animationDuration = 350;
+                // Cached data for performance.
+                this.lastDesiredPosIndex = -1;
+                this.lastDesiredNextIndex = -1;
+                // Series data for rendering path
                 this.lastCalcSeriesPos3d = [];
                 this.lastCalcSeriesTime = null;
-                // Orientation.
+                // Orientation cache.
                 this.lastCalcOrient = null;
                 this.lastCalcOrientTime = null;
-                // 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 || 0;
                 this.roll = params.roll || 0;
-                // Animation from a starting position.
+                this.processHeadings();
+                this.sortPositions();
+                // Initialize animation from starting position if provided.
                 if (params.animateFromPos3d) {
-                    this.animateFromPos3d = params.animateFromPos3d;
+                    this.animationStartPos = 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.
+                    // Check if the provided timestamp is stale.
                     if (!providedTime || (currentTime - providedTime) >= this.animationDuration) {
-                        this.animateFromPos3dTimeStart = currentTime;
+                        this.animationStartTime = currentTime;
                     }
                     else {
-                        this.animateFromPos3dTimeStart = providedTime;
+                        this.animationStartTime = providedTime;
                     }
                 }
+            }
+            AddPosition(pos) {
+                if (!pos || !pos.pos3d || !pos.dateTime) {
+                    console.warn("Invalid position provided to AnimatePositionSeries.");
+                    return;
+                }
+                this.positions.push(pos);
                 this.processHeadings();
-                // Order positions by date.
+                this.sortPositions();
+                this.invalidateCache();
+            }
+            UpdatePitchRoll(pitch, roll) {
+                this.pitch = pitch;
+                this.roll = roll;
+                this.invalidateCache();
+            }
+            GetAnimateFromDateTime() {
+                return this.animationStartTime;
+            }
+            GetPositions() {
+                return this.positions;
+            }
+            sortPositions() {
                 if (this.positions.length > 0) {
-                    this.positions.sort((a, b) => {
-                        return a.dateTime.getTime() - b.dateTime.getTime();
-                    });
+                    this.positions.sort((a, b) => a.dateTime.getTime() - b.dateTime.getTime());
                 }
             }
-            GetAnimateFromDateTime() {
-                return this.animateFromPos3dTimeStart;
+            invalidateCache() {
+                this.lastCalcSeriesTime = null;
+                this.lastCalcOrientTime = null;
             }
             /**
              * Pre-process headings in the series.
@@ -1207,130 +1229,178 @@
                     }
                 }
             }
-            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.
+             * Calculate the desired position based on current time without any animation smoothing.
              */
-            interpolateToTargetPosition(startPos, targetPos, startTimeMs, currentTimeMs) {
-                if (!startPos || !targetPos) {
-                    return startPos || targetPos || new Cesium.Cartesian3();
+            calculateDesiredPosition(timeMs) {
+                // No positions available.
+                if (!this.positions || this.positions.length === 0) {
+                    return { position: null, lastIndex: -1, nextIndex: -1 };
                 }
-                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 Cesium.Cartesian3.lerp(startPos, targetPos, progress, new Cesium.Cartesian3());
+                // Only one position..
+                if (this.positions.length === 1) {
+                    return {
+                        position: this.positions[0].pos3d || null,
+                        lastIndex: 0,
+                        nextIndex: 0
+                    };
                 }
-                catch (e) {
-                    console.error("Error in position interpolation: ", e);
-                    return targetPos;
+                // Before first position - use first two positions for orientation.
+                if (timeMs <= this.positions[0].dateTime.getTime()) {
+                    return {
+                        position: this.positions[0].pos3d || null,
+                        lastIndex: 0,
+                        nextIndex: Math.min(1, this.positions.length - 1)
+                    };
                 }
+                // After last position - use last two positions for orientation.
+                const lastIdx = this.positions.length - 1;
+                if (timeMs >= this.positions[lastIdx].dateTime.getTime()) {
+                    return {
+                        position: this.positions[lastIdx].pos3d || null,
+                        lastIndex: Math.max(0, lastIdx - 1),
+                        nextIndex: lastIdx
+                    };
+                }
+                // Find positions to interpolate between.
+                for (let i = 0; i < this.positions.length - 1; i++) {
+                    const current = this.positions[i];
+                    const next = this.positions[i + 1];
+                    if (timeMs >= current.dateTime.getTime() && timeMs < next.dateTime.getTime()) {
+                        // Exact match on current position - still use current and next for orientation.
+                        if (timeMs === current.dateTime.getTime()) {
+                            return {
+                                position: current.pos3d || null,
+                                lastIndex: i,
+                                nextIndex: i + 1
+                            };
+                        }
+                        // Interpolate between current and next.
+                        if (!current.pos3d || !next.pos3d) {
+                            return {
+                                position: current.pos3d || next.pos3d || null,
+                                lastIndex: i,
+                                nextIndex: i + 1
+                            };
+                        }
+                        try {
+                            const progress = (timeMs - current.dateTime.getTime()) / (next.dateTime.getTime() - current.dateTime.getTime());
+                            const interpolatedPos = Cesium.Cartesian3.lerp(current.pos3d, next.pos3d, progress, new Cesium.Cartesian3());
+                            return {
+                                position: interpolatedPos,
+                                lastIndex: i,
+                                nextIndex: i + 1
+                            };
+                        }
+                        catch (e) {
+                            console.error("Error in position interpolation: ", e);
+                            return {
+                                position: current.pos3d,
+                                lastIndex: i,
+                                nextIndex: i + 1
+                            };
+                        }
+                    }
+                }
+                // Fallback to last position with previous position for orientation.
+                return {
+                    position: this.positions[lastIdx].pos3d || null,
+                    lastIndex: Math.max(0, lastIdx - 1),
+                    nextIndex: lastIdx
+                };
             }
             /**
-             * Main method to get the current position based on time
+             * Main method to get the current position based on time.
              */
             GetValue() {
-                let now = this.viewer.scene.lastRenderTime;
-                if (!now) {
-                    now = this.viewer.clock.currentTime;
+                let viewerTime = this.viewer.scene.lastRenderTime;
+                if (!viewerTime) {
+                    viewerTime = this.viewer.clock.currentTime;
                 }
-                const nowTimeMs = Cesium.JulianDate.toDate(now).getTime();
+                const viewerTimeMs = Cesium.JulianDate.toDate(viewerTime).getTime();
                 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) {
-                        return this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
-                    }
-                    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;
-                    }
-                    // Otherwise continue interpolation.
-                    const interpolatedPos = this.interpolateToTargetPosition(this.animateFromPos3d, idealPosition, this.animateFromPos3dTimeStart, currentRealTimeMs);
-                    this.lastCalcPos3d = interpolatedPos;
-                    return interpolatedPos;
-                }
-                // 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;
-            }
-            /**
-             * Calculate the ideal position based on current time without any smoothing.
-             */
-            calculateIdealPosition(timeMs) {
-                if (!this.positions || this.positions.length === 0) {
+                // Calculate the desired position based on time.
+                const desired = this.calculateDesiredPosition(viewerTimeMs);
+                if (!desired.position) {
+                    this.currentAnimatedPos = null;
+                    this.actualTargetPos = null;
                     return new Cesium.Cartesian3();
                 }
-                // Before first position.
-                if (timeMs <= this.positions[0].dateTime.getTime()) {
-                    this.lastCalcPosIndexLast = 0;
-                    this.lastCalcPosIndexNext = 0;
-                    return this.positions[0].pos3d || new Cesium.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 Cesium.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 Cesium.Cartesian3();
+                this.lastDesiredPosIndex = desired.lastIndex;
+                this.lastDesiredNextIndex = desired.nextIndex;
+                // Determine the desired position without interpolation.
+                let discreteTarget;
+                if (desired.lastIndex === desired.nextIndex) {
+                    discreteTarget = this.positions[desired.lastIndex].pos3d;
                 }
-                // Interpolate between surrounding positions.
-                const next = this.positions[lastIndex + 1];
-                if (!next) {
-                    this.lastCalcPosIndexNext = lastIndex;
-                    return last.pos3d || new Cesium.Cartesian3();
-                }
-                this.lastCalcPosIndexNext = lastIndex + 1;
-                try {
-                    // Ensure both position vectors are valid.
-                    if (!last.pos3d || !next.pos3d) {
-                        return last.pos3d || next.pos3d || new Cesium.Cartesian3();
+                // Use the next position as the target.
+                else {
+                    discreteTarget = this.positions[desired.nextIndex].pos3d;
+                }
+                // Check if we have a new actual target
+                const actualTargetChanged = !this.actualTargetPos || !Cesium.Cartesian3.equals(this.actualTargetPos, discreteTarget);
+                // First time or no previous position - start here.
+                if (!this.currentAnimatedPos) {
+                    if (this.animationStartPos) {
+                        this.actualTargetPos = discreteTarget;
+                        const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
+                        // Animation from start position complete.
+                        if (progress >= 1.0) {
+                            this.currentAnimatedPos = desired.position;
+                            this.animationStartPos = null;
+                            this.animationStartTime = null;
+                            return desired.position;
+                        }
+                        // Still animating from initial position.
+                        else {
+                            const easedProgress = this.easeInOutQuad(progress);
+                            this.currentAnimatedPos = Cesium.Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cesium.Cartesian3());
+                            return this.currentAnimatedPos;
+                        }
+                    }
+                    // No initial animation needed.
+                    else {
+                        this.currentAnimatedPos = desired.position;
+                        this.actualTargetPos = discreteTarget;
+                        return desired.position;
+                    }
+                }
+                // Target changed.
+                if (actualTargetChanged) {
+                    this.animationStartPos = this.currentAnimatedPos;
+                    this.animationStartTime = currentRealTimeMs;
+                    this.actualTargetPos = discreteTarget;
+                }
+                // Continue or start animation to target if we have an active animation.
+                if (this.animationStartPos && this.animationStartTime) {
+                    const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
+                    // Animation complete.
+                    if (progress >= 1.0) {
+                        this.currentAnimatedPos = desired.position;
+                        this.animationStartPos = null;
+                        this.animationStartTime = null;
+                        return desired.position;
+                    }
+                    // Continue animation to interpolated position.
+                    else {
+                        const easedProgress = this.easeInOutQuad(progress);
+                        this.currentAnimatedPos = Cesium.Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cesium.Cartesian3());
+                        return this.currentAnimatedPos;
                     }
-                    const progress = (timeMs - last.dateTime.getTime()) /
-                        (next.dateTime.getTime() - last.dateTime.getTime());
-                    return Cesium.Cartesian3.lerp(last.pos3d, next.pos3d, progress, new Cesium.Cartesian3());
-                }
-                catch (e) {
-                    console.error("Error in ideal position calculation: ", e);
-                    return last.pos3d || new Cesium.Cartesian3();
                 }
+                // No active animation - follow interpolated path directly.
+                this.currentAnimatedPos = desired.position;
+                return desired.position;
+            }
+            getAnimationProgress(currentTime, startTime) {
+                const elapsed = currentTime - startTime;
+                return Math.min(elapsed / this.animationDuration, 1.0);
             }
             /**
-             * Returns a series of positions to use for rendering the path..
+             * Returns a series of positions to use for rendering the path.
              */
             GetSeries() {
                 // Update at 30 fps.
@@ -1354,8 +1424,7 @@
                     this.lastCalcSeriesPos3d = [];
                     return [];
                 }
-                const totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() -
-                    this.positions[0].dateTime.getTime();
+                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;
@@ -1363,13 +1432,14 @@
                 const newPosses = [];
                 for (let i = 0; i < this.positions.length; i++) {
                     const pos = this.positions[i];
-                    if (!pos.pos3d)
+                    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;
+                    if (!add && this.lastDesiredPosIndex > -1 && this.lastDesiredNextIndex > -1) {
+                        add = i >= this.lastDesiredPosIndex && i <= this.lastDesiredNextIndex;
                     }
                     if (add) {
                         newPosses.push(pos.pos3d);
@@ -1407,10 +1477,10 @@
                 }
                 const nowTime = Cesium.JulianDate.toDate(now).getTime();
                 try {
-                    // Get last and next position indices.
-                    const lastIndex = this.lastCalcPosIndexLast;
-                    const nextIndex = this.lastCalcPosIndexNext;
-                    // Validate indices.
+                    // Get current position indices.
+                    const lastIndex = this.lastDesiredPosIndex;
+                    const nextIndex = this.lastDesiredNextIndex;
+                    // Invalid indices.
                     if (lastIndex < 0 || nextIndex < 0 ||
                         lastIndex >= this.positions.length || nextIndex >= this.positions.length) {
                         return this.lastCalcOrient || defaultQuaternion;
@@ -1420,6 +1490,17 @@
                     if (!lastPos || !nextPos) {
                         return this.lastCalcOrient || defaultQuaternion;
                     }
+                    // Single position case - use its heading if available.
+                    if (lastIndex === nextIndex) {
+                        if (lastPos.heading !== null) {
+                            this.lastCalcOrient = Cesium.Transforms.headingPitchRollQuaternion(currentPosition, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(lastPos.heading), Cesium.Math.toRadians(this.pitch), Cesium.Math.toRadians(this.roll)));
+                            this.lastCalcOrientTime = Date.now();
+                            return this.lastCalcOrient;
+                        }
+                        // No heading data and single position, return previous or default.
+                        return this.lastCalcOrient || defaultQuaternion;
+                    }
+                    // Two different positions - we can calculate orientation.
                     // Use explicit heading values if available.
                     if (lastPos.heading !== null && nextPos.heading !== null) {
                         // Calculate interpolated heading.
@@ -1433,8 +1514,7 @@
                         }
                         // Calculate interpolation factor.
                         let factor = 0;
-                        if (lastIndex !== nextIndex &&
-                            lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
+                        if (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));
@@ -1447,7 +1527,7 @@
                         // Create quaternion from heading, pitch, roll.
                         this.lastCalcOrient = Cesium.Transforms.headingPitchRollQuaternion(currentPosition, new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(interpolatedHeading), Cesium.Math.toRadians(this.pitch), Cesium.Math.toRadians(this.roll)));
                     }
-                    // Calculate heading from position changes if not available.
+                    // Calculate heading from position changes if heading data not available.
                     else {
                         if (!lastPos.pos3d || !nextPos.pos3d) {
                             return this.lastCalcOrient || defaultQuaternion;
@@ -6828,7 +6908,9 @@
                     continue;
                 }
                 entityRemoveAddState.delete(entity.id);
-                viewer.entities.remove(entity);
+                if (viewer.entities.contains(entity)) {
+                    viewer.entities.remove(entity);
+                }
             }
         });
     }
@@ -6850,7 +6932,9 @@
                     continue;
                 }
                 entityRemoveAddState.delete(entity.id);
-                viewer.entities.add(entity);
+                if (!viewer.entities.contains(entity)) {
+                    viewer.entities.add(entity);
+                }
             }
         });
     }
@@ -6953,7 +7037,7 @@
          * @returns
          */
         function Render(params) {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const entity = params.entity;
             if (!params.entityHistoric) {
                 params.entityHistoric = [];
@@ -7055,6 +7139,7 @@
                 }
             };
             let cEntity = params.rendered;
+            let prevPos3d = cEntity ? GetCValue(params.viewer, cEntity.position) : null;
             if (!cEntity || !cEntity.model) {
                 updateShouldShowTrack();
                 if (!color) {
@@ -7144,12 +7229,11 @@
                 cEntity.model.colorBlendAmount = new Cesium.ConstantProperty(blendAmount);
                 cEntity.model.colorBlendMode = new Cesium.ConstantProperty(blendMode);
                 cEntity.model.distanceDisplayCondition = new Cesium.ConstantProperty(exports.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.
+                // If we've loaded a set of series positions then we'll animate through them.
                 const series = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
                 if (series.length > 1) {
                     animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
@@ -7164,17 +7248,50 @@
                     cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
                 }
                 else {
+                    const dateTimeStr = (_b = (_a = entity.Bruce.Outline) === null || _a === void 0 ? void 0 : _a.find(x => !!x.DateTime)) === null || _b === void 0 ? void 0 : _b.DateTime;
+                    const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
                     const posChanged = !prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d);
                     if (posChanged) {
-                        animatePosition = new exports.CesiumAnimatedProperty.AnimatePosition({
-                            durationMs: 200,
-                            targetPos3d: pos3d,
-                            viewer: params.viewer,
-                            startPos3d: prevPos3d
-                        });
-                        cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                        if (cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
+                            const prevAnimatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                            animatePosition = prevAnimatePosition;
+                            animatePosition.AddPosition({
+                                pos3d: pos3d,
+                                dateTime: dateTime,
+                                heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                            });
+                            animatePosition.UpdatePitchRoll(pitch, roll);
+                        }
+                        else {
+                            let posses = [];
+                            const isLive = exports.ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
+                            if (prevPos3d && isLive) {
+                                posses.push({
+                                    pos3d: prevPos3d,
+                                    // Guess so that we can determine a direction of movement right away :)
+                                    dateTime: new Date(dateTime.getTime() - 1000),
+                                    heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                                });
+                            }
+                            posses.push({
+                                pos3d: pos3d,
+                                dateTime: dateTime,
+                                heading: !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading
+                            });
+                            animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
+                                posses: posses,
+                                viewer: params.viewer,
+                                pitch: pitch,
+                                roll: roll,
+                                animateFromPos3d: prevPos3d && !isLive ? prevPos3d : null,
+                                animateFromPos3dTimeStart: null
+                            });
+                            cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                        }
                     }
                 }
+                // If we're animating position then we can animate orientation too based on the interpolated position.
                 if (animatePosition && animatePosition instanceof exports.CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetOrient) {
                     cEntity.orientation = new Cesium.CallbackProperty(() => {
                         return animatePosition.GetOrient();
@@ -7182,15 +7299,16 @@
                 }
                 else {
                     const prevHeading = cEntity.model._heading;
+                    // Not worth animating.
                     if (prevHeading == null || prevHeading == heading || isNaN(prevHeading)) {
                         const hpr = new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(heading), Cesium.Math.toRadians(pitch), Cesium.Math.toRadians(roll));
                         const orient = Cesium.Transforms.headingPitchRollQuaternion(pos3d, hpr);
                         cEntity.orientation = new Cesium.CallbackProperty(() => orient, true);
                     }
-                    // Animate orientation. We'll calculate the heading based on movement.
+                    // Animate the change.
                     else {
                         const animateHeading = new exports.CesiumAnimatedProperty.AnimateHeading({
-                            durationMs: 200,
+                            durationMs: 500,
                             targetHeading: heading,
                             viewer: params.viewer,
                             startHeading: prevHeading
@@ -7222,7 +7340,7 @@
                 else {
                     cEntity.model.scale = new Cesium.CallbackProperty(() => scale * styleScale, true);
                 }
-                // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
+                // We'll use "SetDefaultColor" to update the internal reference and to allow for an animation.
                 // cEntity.model.color = new Cesium.CallbackProperty(() => color, true);
                 exports.CesiumEntityStyler.SetDefaultColor({
                     color: color ? color : new Cesium.Color(),
@@ -7319,7 +7437,7 @@
             // Generate a polyline 'track' for the historic data.
             // We do this for historic data that exists and is moving.
             if (shouldShowTrack && animatePosition && animatePosition instanceof exports.CesiumAnimatedProperty.AnimatePositionSeries && animatePosition.GetSeries) {
-                const lStyle = (_b = (_a = params.fullStyle) === null || _a === void 0 ? void 0 : _a.polylineStyle) !== null && _b !== void 0 ? _b : {};
+                const lStyle = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
                 const bColor = lStyle.lineColor ? BModels.Calculator.GetColor(lStyle.lineColor, entity, params.tags) : null;
                 const cColor = bColor ? ColorToCColor(bColor) : Cesium.Color.fromCssColorString("rgba(255, 193, 7, 0.8)");
                 let width = lStyle.lineWidth ? EnsureNumber(BModels.Calculator.GetNumber(lStyle.lineWidth, entity, params.tags)) : 2;
@@ -33027,7 +33145,7 @@
         }
     }
 
-    const VERSION = "5.9.5";
+    const VERSION = "5.9.7";
 
     exports.VERSION = VERSION;
     exports.isOutlineChanged = isOutlineChanged;