bruce-cesium 5.9.6 → 5.9.8

package/dist/bruce-cesium.umd.js

@@ -1142,19 +1142,18 @@
          */
         class AnimatePositionSeries {
             constructor(params) {
-                // Animation state.
-                this.currentAnimatedPos = null;
-                this.currentTargetPos = null;
-                this.animationStartPos = null;
-                this.animationStartTime = null;
-                this.animationDuration = 200;
-                // Cached data for performance.
+                this.currentPos = null;
+                this.currentVelocity = new Cesium.Cartesian3(0, 0, 0);
+                this.smoothingFactor = 0.5;
+                this.positionHistory = [];
+                this.maxHistorySize = 10;
+                this.averageSpeed = 0;
+                this.averageTimeInterval = 0;
+                this.lastUpdateTime = null;
                 this.lastDesiredPosIndex = -1;
                 this.lastDesiredNextIndex = -1;
-                // Series data for rendering path
                 this.lastCalcSeriesPos3d = [];
                 this.lastCalcSeriesTime = null;
-                // Orientation cache.
                 this.lastCalcOrient = null;
                 this.lastCalcOrientTime = null;
                 this.viewer = params.viewer;
@@ -1163,25 +1162,23 @@
                 this.roll = params.roll || 0;
                 this.processHeadings();
                 this.sortPositions();
-                // Initialize animation from starting position if provided.
-                if (params.animateFromPos3d) {
-                    this.animationStartPos = params.animateFromPos3d;
-                    const currentTime = Date.now();
-                    const providedTime = params.animateFromPos3dTimeStart || 0;
-                    // Check if the provided timestamp is stale.
-                    if (!providedTime || (currentTime - providedTime) >= this.animationDuration) {
-                        this.animationStartTime = currentTime;
-                    }
-                    else {
-                        this.animationStartTime = providedTime;
-                    }
-                }
             }
             AddPosition(pos) {
                 if (!pos || !pos.pos3d || !pos.dateTime) {
                     console.warn("Invalid position provided to AnimatePositionSeries.");
                     return;
                 }
+                const now = Date.now();
+                const posTime = pos.dateTime.getTime();
+                this.positionHistory.push({
+                    pos: pos.pos3d.clone(),
+                    time: posTime,
+                    realTime: now
+                });
+                if (this.positionHistory.length > this.maxHistorySize) {
+                    this.positionHistory.shift();
+                }
+                this.analyzeMovementPatterns();
                 this.positions.push(pos);
                 this.processHeadings();
                 this.sortPositions();
@@ -1192,12 +1189,70 @@
                 this.roll = roll;
                 this.invalidateCache();
             }
-            GetAnimateFromDateTime() {
-                return this.animationStartTime;
-            }
             GetPositions() {
                 return this.positions;
             }
+            analyzeMovementPatterns() {
+                if (this.positionHistory.length < 2) {
+                    return;
+                }
+                let totalDistance = 0;
+                let totalTimeSpan = 0;
+                let totalRealTimeSpan = 0;
+                let validSegments = 0;
+                for (let i = 1; i < this.positionHistory.length; i++) {
+                    const prev = this.positionHistory[i - 1];
+                    const curr = this.positionHistory[i];
+                    const distance = Cesium.Cartesian3.distance(prev.pos, curr.pos);
+                    const timeSpan = Math.abs(curr.time - prev.time) / 1000.0;
+                    const realTimeSpan = Math.abs(curr.realTime - prev.realTime) / 1000.0;
+                    if (distance > 0.1 && timeSpan > 0.01) {
+                        totalDistance += distance;
+                        totalTimeSpan += timeSpan;
+                        totalRealTimeSpan += realTimeSpan;
+                        validSegments++;
+                    }
+                }
+                if (validSegments > 0) {
+                    this.averageSpeed = totalDistance / totalTimeSpan;
+                    this.averageTimeInterval = totalRealTimeSpan / validSegments;
+                    this.averageSpeed = Math.max(0.1, Math.min(this.averageSpeed, 1000));
+                    this.averageTimeInterval = Math.max(0.01, Math.min(this.averageTimeInterval, 10));
+                }
+            }
+            calculateExpectedPosition(viewerTimeMs) {
+                const desired = this.calculateDesiredPosition(viewerTimeMs);
+                if (!desired.position) {
+                    return { position: null, timeDelta: 0 };
+                }
+                let timeDelta = 0;
+                if (this.positionHistory.length >= 2) {
+                    // Calculate how far behind we are based on viewer time vs real time.
+                    const now = Date.now();
+                    const timeDiffFromNow = (viewerTimeMs - now) / 1000.0;
+                    // Negative means we're behind, positive means ahead.
+                    timeDelta = timeDiffFromNow;
+                }
+                return { position: desired.position, timeDelta };
+            }
+            calculateAutonomousSpeed(distanceToTarget, timeDelta) {
+                let baseSpeed = this.averageSpeed || 50;
+                let speedMultiplier = 1.0;
+                // Calculate speed multiplier based on distance and time lag.
+                if (distanceToTarget > 50) {
+                    speedMultiplier *= Math.min(100.0, distanceToTarget / 10.0);
+                }
+                else if (distanceToTarget > 10) {
+                    const distanceMultiplier = Math.min(20.0, 1.0 + (distanceToTarget / 5.0));
+                    speedMultiplier *= distanceMultiplier;
+                }
+                else if (Math.abs(timeDelta) > 0.1) {
+                    const timeLagMultiplier = Math.max(0.1, 1.0 - (timeDelta * 5.0));
+                    speedMultiplier *= Math.min(50.0, timeLagMultiplier);
+                }
+                // Minimum 10% speed.
+                return Math.max(baseSpeed * 0.1, baseSpeed * speedMultiplier);
+            }
             sortPositions() {
                 if (this.positions.length > 0) {
                     this.positions.sort((a, b) => a.dateTime.getTime() - b.dateTime.getTime());
@@ -1207,10 +1262,6 @@
                 this.lastCalcSeriesTime = null;
                 this.lastCalcOrientTime = null;
             }
-            /**
-             * 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;
@@ -1232,15 +1283,10 @@
             easeInOutQuad(t) {
                 return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
             }
-            /**
-             * Calculate the desired position based on current time without any animation smoothing.
-             */
             calculateDesiredPosition(timeMs) {
-                // No positions available
                 if (!this.positions || this.positions.length === 0) {
                     return { position: null, lastIndex: -1, nextIndex: -1 };
                 }
-                // Only one position.
                 if (this.positions.length === 1) {
                     return {
                         position: this.positions[0].pos3d || null,
@@ -1248,7 +1294,6 @@
                         nextIndex: 0
                     };
                 }
-                // Before first position - use first two positions for orientation.
                 if (timeMs <= this.positions[0].dateTime.getTime()) {
                     return {
                         position: this.positions[0].pos3d || null,
@@ -1256,7 +1301,6 @@
                         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 {
@@ -1265,12 +1309,10 @@
                         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,
@@ -1278,7 +1320,6 @@
                                 nextIndex: i + 1
                             };
                         }
-                        // Interpolate between current and next.
                         if (!current.pos3d || !next.pos3d) {
                             return {
                                 position: current.pos3d || next.pos3d || null,
@@ -1305,99 +1346,59 @@
                         }
                     }
                 }
-                // 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.
-             */
             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 desired position based on time.
-                const desired = this.calculateDesiredPosition(nowTimeMs);
-                // If no desired position, return empty position.
-                if (!desired.position) {
-                    this.currentAnimatedPos = null;
-                    this.currentTargetPos = null;
+                const expected = this.calculateExpectedPosition(viewerTimeMs);
+                if (!expected.position) {
+                    this.currentPos = null;
+                    this.currentVelocity = new Cesium.Cartesian3(0, 0, 0);
                     return new Cesium.Cartesian3();
                 }
-                // Cache the desired position info for orientation calculations.
+                const desired = this.calculateDesiredPosition(viewerTimeMs);
                 this.lastDesiredPosIndex = desired.lastIndex;
                 this.lastDesiredNextIndex = desired.nextIndex;
-                // First time or no previous position - start here.
-                if (!this.currentAnimatedPos) {
-                    // If we have a starting animation position, animate from it.
-                    if (this.animationStartPos) {
-                        this.currentTargetPos = desired.position;
-                        const progress = this.getAnimationProgress(currentRealTimeMs, this.animationStartTime);
-                        if (progress >= 1.0) {
-                            // Animation complete.
-                            this.currentAnimatedPos = desired.position;
-                            this.animationStartPos = null;
-                            this.animationStartTime = null;
-                            return desired.position;
-                        }
-                        else {
-                            // Continue animation.
-                            const easedProgress = this.easeInOutQuad(progress);
-                            this.currentAnimatedPos = Cesium.Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cesium.Cartesian3());
-                            return this.currentAnimatedPos;
-                        }
-                    }
-                    else {
-                        // No animation, start at desired position.
-                        this.currentAnimatedPos = desired.position;
-                        this.currentTargetPos = desired.position;
-                        return desired.position;
-                    }
-                }
-                // Check if target has changed.
-                const targetChanged = !this.currentTargetPos || !Cesium.Cartesian3.equals(this.currentTargetPos, desired.position);
-                if (targetChanged) {
-                    // Target changed mid-animation - start new animation from current position.
-                    this.animationStartPos = this.currentAnimatedPos;
-                    this.animationStartTime = currentRealTimeMs;
-                    this.currentTargetPos = desired.position;
-                }
-                // Continue or start animation to target.
-                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.
-                    else {
-                        const easedProgress = this.easeInOutQuad(progress);
-                        this.currentAnimatedPos = Cesium.Cartesian3.lerp(this.animationStartPos, desired.position, easedProgress, new Cesium.Cartesian3());
-                        return this.currentAnimatedPos;
-                    }
-                }
-                // No animation needed - already at target.
-                this.currentAnimatedPos = desired.position;
-                return desired.position;
-            }
-            getAnimationProgress(currentTime, startTime) {
-                const elapsed = currentTime - startTime;
-                return Math.min(elapsed / this.animationDuration, 1.0);
+                if (!this.currentPos) {
+                    this.currentPos = expected.position.clone();
+                    this.currentVelocity = new Cesium.Cartesian3(0, 0, 0);
+                    this.lastUpdateTime = currentRealTimeMs;
+                    return this.currentPos;
+                }
+                const deltaTime = this.lastUpdateTime ? (currentRealTimeMs - this.lastUpdateTime) / 1000.0 : 0.016;
+                this.lastUpdateTime = currentRealTimeMs;
+                const clampedDeltaTime = Math.min(deltaTime, 0.1);
+                const targetDistance = Cesium.Cartesian3.distance(this.currentPos, expected.position);
+                if (targetDistance < 0.5) {
+                    this.currentPos = expected.position.clone();
+                    this.currentVelocity = new Cesium.Cartesian3(0, 0, 0);
+                    return this.currentPos;
+                }
+                // Check if we're really far behind and need to teleport.
+                if (targetDistance > 500) {
+                    this.currentPos = expected.position.clone();
+                    this.currentVelocity = new Cesium.Cartesian3(0, 0, 0);
+                    return this.currentPos;
+                }
+                const direction = Cesium.Cartesian3.subtract(expected.position, this.currentPos, new Cesium.Cartesian3());
+                Cesium.Cartesian3.normalize(direction, direction);
+                const targetSpeed = this.calculateAutonomousSpeed(targetDistance, expected.timeDelta);
+                const targetVelocity = Cesium.Cartesian3.multiplyByScalar(direction, targetSpeed, new Cesium.Cartesian3());
+                this.currentVelocity = Cesium.Cartesian3.lerp(this.currentVelocity, targetVelocity, this.smoothingFactor, new Cesium.Cartesian3());
+                const velocityDelta = Cesium.Cartesian3.multiplyByScalar(this.currentVelocity, clampedDeltaTime, new Cesium.Cartesian3());
+                this.currentPos = Cesium.Cartesian3.add(this.currentPos, velocityDelta, new Cesium.Cartesian3());
+                return this.currentPos;
             }
-            /**
-             * Returns a series of positions to use for rendering the path.
-             */
             GetSeries() {
-                // Update at 30 fps.
                 let doUpdate = this.lastCalcSeriesTime == null;
                 if (!doUpdate && this.lastCalcSeriesTime && (new Date().getTime() - this.lastCalcSeriesTime) > 1000 / 30) {
                     doUpdate = true;
@@ -1405,33 +1406,27 @@
                 if (!doUpdate) {
                     return this.lastCalcSeriesPos3d;
                 }
-                // Ensure position indices are up-to-date.
                 this.GetValue();
                 let now = this.viewer.scene.lastRenderTime;
                 if (!now) {
                     now = this.viewer.clock.currentTime;
                 }
                 const nowDate = Cesium.JulianDate.toDate(now);
-                // Get total duration.
                 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 totalDuration = this.positions[this.positions.length - 1].dateTime.getTime() - this.positions[0].dateTime.getTime();
+                const visibilityPercentage = 0.05;
                 const visibilityDuration = totalDuration * visibilityPercentage;
-                // Gather positions that fall within the visibility duration.
                 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.
+                    }
+                    let add = nowDate >= new Date(pos.dateTime.getTime() - visibilityDuration / 2) && nowDate <= new Date(pos.dateTime.getTime() + visibilityDuration / 2);
                     if (!add && this.lastDesiredPosIndex > -1 && this.lastDesiredNextIndex > -1) {
                         add = i >= this.lastDesiredPosIndex && i <= this.lastDesiredNextIndex;
                     }
@@ -1443,11 +1438,7 @@
                 this.lastCalcSeriesPos3d = newPosses;
                 return newPosses;
             }
-            /**
-             * 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;
@@ -1455,26 +1446,34 @@
                 if (!doUpdate && this.lastCalcOrient) {
                     return this.lastCalcOrient;
                 }
-                // Default quaternion to return if we can't calculate.
                 const defaultQuaternion = new Cesium.Quaternion();
                 if (!this.positions || this.positions.length === 0) {
                     return defaultQuaternion;
                 }
-                // Ensure position is up-to-date.
                 const currentPosition = this.GetValue();
                 if (!currentPosition) {
                     return defaultQuaternion;
                 }
-                let now = this.viewer.scene.lastRenderTime;
-                if (!now) {
-                    now = this.viewer.clock.currentTime;
-                }
-                const nowTime = Cesium.JulianDate.toDate(now).getTime();
                 try {
-                    // Get current position indices.
+                    const velocityMagnitude = Cesium.Cartesian3.magnitude(this.currentVelocity);
+                    const minimumSpeedForVelocityOrientation = Math.max(1.0, this.averageSpeed * 0.1);
+                    if (velocityMagnitude > minimumSpeedForVelocityOrientation) {
+                        const normalizedVelocity = Cesium.Cartesian3.normalize(this.currentVelocity, new Cesium.Cartesian3());
+                        const rotationMatrix = Cesium.Transforms.rotationMatrixFromPositionVelocity(currentPosition, normalizedVelocity);
+                        const quaternion = Cesium.Quaternion.fromRotationMatrix(rotationMatrix);
+                        const hpr = new Cesium.HeadingPitchRoll(0, Cesium.Math.toRadians(this.pitch), Cesium.Math.toRadians(this.roll));
+                        const pitchRollQuaternion = Cesium.Quaternion.fromHeadingPitchRoll(hpr);
+                        this.lastCalcOrient = Cesium.Quaternion.multiply(quaternion, pitchRollQuaternion, new Cesium.Quaternion());
+                        this.lastCalcOrientTime = Date.now();
+                        return this.lastCalcOrient;
+                    }
+                    let now = this.viewer.scene.lastRenderTime;
+                    if (!now) {
+                        now = this.viewer.clock.currentTime;
+                    }
+                    const nowTime = Cesium.JulianDate.toDate(now).getTime();
                     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;
@@ -1484,74 +1483,53 @@
                     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.
                         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 (lastPos.dateTime.getTime() !== nextPos.dateTime.getTime()) {
-                            factor = (nowTime - lastPos.dateTime.getTime()) /
-                                (nextPos.dateTime.getTime() - lastPos.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 = 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 heading data not available.
                     else {
                         if (!lastPos.pos3d || !nextPos.pos3d) {
                             return this.lastCalcOrient || defaultQuaternion;
                         }
-                        // Flatten positions to avoid altitude-related heading changes.
                         const adjustedPointPrev = Cesium.Cartographic.fromCartesian(lastPos.pos3d);
                         const adjustedPos3dPrev = Cesium.Cartesian3.fromRadians(adjustedPointPrev.longitude, adjustedPointPrev.latitude, 0);
                         const adjustedPointNext = Cesium.Cartographic.fromCartesian(nextPos.pos3d);
                         const adjustedPos3dNext = Cesium.Cartesian3.fromRadians(adjustedPointNext.longitude, adjustedPointNext.latitude, 0);
-                        // Skip if positions are too close (less than 5cm).
                         const distance = Cesium.Cartesian3.distance(adjustedPos3dPrev, adjustedPos3dNext);
                         if (distance < 0.05) {
                             return this.lastCalcOrient || defaultQuaternion;
                         }
-                        // Calculate direction vector.
                         const direction = Cesium.Cartesian3.subtract(adjustedPos3dNext, adjustedPos3dPrev, new Cesium.Cartesian3());
-                        // Skip if no movement.
                         if (direction.x === 0 && direction.y === 0 && direction.z === 0) {
                             return this.lastCalcOrient || defaultQuaternion;
                         }
-                        // Normalize the direction vector.
                         Cesium.Cartesian3.normalize(direction, direction);
-                        // Calculate rotation based on movement direction.
                         const rotationMatrix = Cesium.Transforms.rotationMatrixFromPositionVelocity(currentPosition, direction);
-                        // Convert to quaternion.
                         const quaternion = Cesium.Quaternion.fromRotationMatrix(rotationMatrix);
-                        // Add pitch and roll adjustments.
                         const hpr = new Cesium.HeadingPitchRoll(0, Cesium.Math.toRadians(this.pitch), Cesium.Math.toRadians(this.roll));
                         const pitchRollQuaternion = Cesium.Quaternion.fromHeadingPitchRoll(hpr);
-                        // Combine quaternions.
                         this.lastCalcOrient = Cesium.Quaternion.multiply(quaternion, pitchRollQuaternion, new Cesium.Quaternion());
                     }
                 }
@@ -1562,6 +1540,52 @@
                 this.lastCalcOrientTime = Date.now();
                 return this.lastCalcOrient;
             }
+            GetCurrentVelocity() {
+                return this.currentVelocity ? this.currentVelocity.clone() : new Cesium.Cartesian3(0, 0, 0);
+            }
+            SupplementSeries(newSeries) {
+                if (!newSeries || newSeries.length === 0) {
+                    return;
+                }
+                for (const pos of newSeries) {
+                    if (!pos || !pos.pos3d || !pos.dateTime) {
+                        continue;
+                    }
+                    const existingIndex = this.positions.findIndex(p => p.dateTime.getTime() === pos.dateTime.getTime());
+                    if (existingIndex >= 0) {
+                        this.positions[existingIndex] = pos;
+                    }
+                    else {
+                        this.AddPosition(pos);
+                    }
+                }
+            }
+            UpdatePositionForDateTime(pos3d, dateTime, heading) {
+                if (!pos3d || !dateTime) {
+                    return;
+                }
+                const existingIndex = this.positions.findIndex(p => p.dateTime.getTime() === dateTime.getTime());
+                const newPos = {
+                    pos3d: pos3d,
+                    dateTime: dateTime,
+                    heading: heading !== undefined ? heading : null
+                };
+                if (existingIndex >= 0) {
+                    this.positions[existingIndex] = newPos;
+                    this.processHeadings();
+                    this.sortPositions();
+                    this.invalidateCache();
+                }
+                else {
+                    this.AddPosition(newPos);
+                }
+            }
+            HasPositionForDateTime(dateTime) {
+                return this.positions.some(p => p.dateTime.getTime() === dateTime.getTime());
+            }
+            GetPositionCount() {
+                return this.positions.length;
+            }
         }
         CesiumAnimatedProperty.AnimatePositionSeries = AnimatePositionSeries;
         function GetSeriesPossesForHistoricEntity(viewer, dataHeightRef, heightRef, historic) {
@@ -5432,7 +5456,7 @@
          * @returns
          */
         async function Render(params) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
             const entity = params.entity;
             if (!params.entityHistoric) {
                 params.entityHistoric = [];
@@ -5633,39 +5657,69 @@
                             // Unset width/height.
                             cEntity.billboard.width = undefined;
                             cEntity.billboard.height = undefined;
+                            const pos3d = exports.EntityUtils.GetPos({
+                                viewer: params.viewer,
+                                entity,
+                                recordHeightRef: heightRef,
+                                returnHeightRef: heightRef,
+                                allowRendered: false
+                            });
                             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 = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
-                            if (series.length > 1) {
-                                animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
-                                    posses: series,
-                                    viewer: params.viewer,
-                                    animateFromPos3d: prevPos3d,
-                                    animateFromPos3dTimeStart: prevStartTime
-                                });
-                                cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
-                                cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                                animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                                const animateSeries = animatePosition;
+                                const series = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                                if (series.length) {
+                                    animateSeries.SupplementSeries(series);
+                                }
+                                const dateTimeStr = (_d = (_c = entity.Bruce.Outline) === null || _c === void 0 ? void 0 : _c.find(x => !!x.DateTime)) === null || _d === void 0 ? void 0 : _d.DateTime;
+                                const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                                if (dateTime) {
+                                    animateSeries.UpdatePositionForDateTime(pos3d, dateTime);
+                                }
+                                // We don't have a date-stamped incoming position.
+                                if (!dateTime && !series.length) {
+                                    animatePosition = null;
+                                }
                             }
-                            else {
-                                const pos3d = exports.EntityUtils.GetPos({
-                                    viewer: params.viewer,
-                                    entity,
-                                    recordHeightRef: heightRef,
-                                    returnHeightRef: heightRef,
-                                    allowRendered: false
-                                });
-                                if (!prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d)) {
-                                    animatePosition = new exports.CesiumAnimatedProperty.AnimatePosition({
-                                        durationMs: 200,
-                                        targetPos3d: pos3d,
-                                        viewer: params.viewer,
-                                        startPos3d: prevPos3d
+                            if (!animatePosition) {
+                                // 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({
+                                        posses: series,
+                                        viewer: params.viewer
                                     });
                                     cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                                }
+                                else {
+                                    const dateTimeStr = (_f = (_e = entity.Bruce.Outline) === null || _e === void 0 ? void 0 : _e.find(x => !!x.DateTime)) === null || _f === void 0 ? void 0 : _f.DateTime;
+                                    const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                                    const posChanged = !prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d);
+                                    if (posChanged) {
+                                        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: null
+                                            });
+                                        }
+                                        posses.push({
+                                            pos3d: pos3d,
+                                            dateTime: dateTime,
+                                            heading: null
+                                        });
+                                        animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
+                                            posses: posses,
+                                            viewer: params.viewer
+                                        });
+                                        cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                                        cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                                    }
                                 }
                             }
                             // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
@@ -5964,39 +6018,52 @@
                     cEntity.billboard.heightReference = new Cesium.ConstantProperty(heightRef);
                     cEntity.billboard.distanceDisplayCondition = new Cesium.ConstantProperty(exports.EntityRenderEngine.GetDisplayCondition(params.minDistance, params.maxDistance));
                     cEntity.billboard.disableDepthTestDistance = new Cesium.ConstantProperty(disableDepthTest ? Number.POSITIVE_INFINITY : undefined);
+                    const pos3d = exports.EntityUtils.GetPos({
+                        viewer: params.viewer,
+                        entity,
+                        recordHeightRef: heightRef,
+                        returnHeightRef: heightRef,
+                        allowRendered: false
+                    });
                     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 = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
-                    if (series.length > 1) {
-                        animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
-                            posses: series,
-                            viewer: params.viewer,
-                            animateFromPos3d: prevPos3d,
-                            animateFromPos3dTimeStart: prevStartTime
-                        });
-                        cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
-                        cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
-                    }
-                    else {
-                        const pos3d = exports.EntityUtils.GetPos({
-                            viewer: params.viewer,
-                            entity,
-                            recordHeightRef: heightRef,
-                            returnHeightRef: heightRef,
-                            allowRendered: false
-                        });
-                        if (!prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d)) {
-                            animatePosition = new exports.CesiumAnimatedProperty.AnimatePosition({
-                                durationMs: 200,
-                                targetPos3d: pos3d,
-                                viewer: params.viewer,
-                                startPos3d: prevPos3d
+                        animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                        const animateSeries = animatePosition;
+                        const series = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                        if (series.length) {
+                            animateSeries.SupplementSeries(series);
+                        }
+                        const dateTimeStr = (_h = (_g = entity.Bruce.Outline) === null || _g === void 0 ? void 0 : _g.find(x => !!x.DateTime)) === null || _h === void 0 ? void 0 : _h.DateTime;
+                        const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                        if (dateTime) {
+                            animateSeries.UpdatePositionForDateTime(pos3d, dateTime);
+                        }
+                        // We don't have a date-stamped incoming position.
+                        if (!dateTime && !series.length) {
+                            animatePosition = null;
+                        }
+                    }
+                    if (!animatePosition) {
+                        // If we have a series of time-based positions then we'll animate as time changes.
+                        const series = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                        if (series.length > 1) {
+                            animatePosition = new exports.CesiumAnimatedProperty.AnimatePositionSeries({
+                                posses: series,
+                                viewer: params.viewer
                             });
                             cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                        }
+                        else {
+                            if (!prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d)) {
+                                animatePosition = new exports.CesiumAnimatedProperty.AnimatePosition({
+                                    durationMs: 200,
+                                    targetPos3d: pos3d,
+                                    viewer: params.viewer,
+                                    startPos3d: prevPos3d
+                                });
+                                cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                            }
                         }
                     }
                     // We'll use "SetDefaultColor" to updating the internal reference and to allow for an animation.
@@ -6015,7 +6082,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 = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
+                const lStyle = (_k = (_j = params.fullStyle) === null || _j === void 0 ? void 0 : _j.polylineStyle) !== null && _k !== void 0 ? _k : {};
                 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;
@@ -7031,7 +7098,7 @@
          * @returns
          */
         function Render(params) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f;
             const entity = params.entity;
             if (!params.entityHistoric) {
                 params.entityHistoric = [];
@@ -7223,40 +7290,41 @@
                 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));
-                let prevStartTime = null;
                 if (cEntity.position && cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"]) {
-                    prevStartTime = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"].GetAnimateFromDateTime();
-                }
-                // 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({
-                        posses: series,
-                        viewer: params.viewer,
-                        pitch: pitch,
-                        roll: roll,
-                        animateFromPos3d: prevPos3d,
-                        animateFromPos3dTimeStart: prevStartTime
-                    });
-                    cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
-                    cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
-                }
-                else {
+                    animatePosition = cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"];
+                    const animateSeries = animatePosition;
+                    const series = exports.CesiumAnimatedProperty.GetSeriesPossesForHistoricEntity(params.viewer, heightRef, heightRef, params.entityHistoric);
+                    if (series.length) {
+                        animateSeries.SupplementSeries(series);
+                    }
                     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) {
-                        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 {
+                    if (dateTime) {
+                        animateSeries.UpdatePositionForDateTime(pos3d, dateTime, !EnsureNumber(transform === null || transform === void 0 ? void 0 : transform.heading) ? null : heading);
+                    }
+                    // We don't have a date-stamped incoming position.
+                    if (!dateTime && !series.length) {
+                        animatePosition = null;
+                    }
+                }
+                if (!animatePosition) {
+                    // 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({
+                            posses: series,
+                            viewer: params.viewer,
+                            pitch: pitch,
+                            roll: roll
+                        });
+                        cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
+                        cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
+                    }
+                    else {
+                        const dateTimeStr = (_d = (_c = entity.Bruce.Outline) === null || _c === void 0 ? void 0 : _c.find(x => !!x.DateTime)) === null || _d === void 0 ? void 0 : _d.DateTime;
+                        const dateTime = dateTimeStr ? new Date(dateTimeStr) : null;
+                        const posChanged = !prevPos3d || !Cesium.Cartesian3.equals(prevPos3d, pos3d);
+                        if (posChanged) {
                             let posses = [];
                             const isLive = exports.ViewUtils.GetTimeDetails({ viewer: params.viewer }).isLive;
                             if (prevPos3d && isLive) {
@@ -7276,9 +7344,7 @@
                                 posses: posses,
                                 viewer: params.viewer,
                                 pitch: pitch,
-                                roll: roll,
-                                animateFromPos3d: prevPos3d && !isLive ? prevPos3d : null,
-                                animateFromPos3dTimeStart: null
+                                roll: roll
                             });
                             cEntity.position = new Cesium.CallbackProperty(() => animatePosition.GetValue(), false);
                             cEntity.position["CesiumAnimatedProperty.AnimatePositionSeries"] = animatePosition;
@@ -7431,7 +7497,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 = (_d = (_c = params.fullStyle) === null || _c === void 0 ? void 0 : _c.polylineStyle) !== null && _d !== void 0 ? _d : {};
+                const lStyle = (_f = (_e = params.fullStyle) === null || _e === void 0 ? void 0 : _e.polylineStyle) !== null && _f !== void 0 ? _f : {};
                 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;
@@ -33139,7 +33205,7 @@
         }
     }
 
-    const VERSION = "5.9.6";
+    const VERSION = "5.9.8";
 
     exports.VERSION = VERSION;
     exports.isOutlineChanged = isOutlineChanged;