bruce-cesium 5.9.6 → 5.9.8

package/dist/lib/bruce-cesium.js

@@ -72,5 +72,5 @@ __exportStar(require("./widgets/controls-view-bar/widget-control-view-bar-search
 __exportStar(require("./widgets/widget-left-panel"), exports);
 __exportStar(require("./widgets/tabs-left-panel/widget-left-panel-tab"), exports);
 __exportStar(require("./widgets/tabs-left-panel/widget-left-panel-tab-bookmarks"), exports);
-exports.VERSION = "5.9.6";
+exports.VERSION = "5.9.8";
 //# sourceMappingURL=bruce-cesium.js.map

package/dist/lib/rendering/cesium-animated-property.js

@@ -372,19 +372,18 @@ var CesiumAnimatedProperty;
      */
     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;
@@ -393,25 +392,23 @@ var CesiumAnimatedProperty;
             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();
@@ -422,12 +419,70 @@ var CesiumAnimatedProperty;
             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());
@@ -437,10 +492,6 @@ var CesiumAnimatedProperty;
             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;
@@ -462,15 +513,10 @@ var CesiumAnimatedProperty;
         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,
@@ -478,7 +524,6 @@ var CesiumAnimatedProperty;
                     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,
@@ -486,7 +531,6 @@ var CesiumAnimatedProperty;
                     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 {
@@ -495,12 +539,10 @@ var CesiumAnimatedProperty;
                     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,
@@ -508,7 +550,6 @@ var CesiumAnimatedProperty;
                             nextIndex: i + 1
                         };
                     }
-                    // Interpolate between current and next.
                     if (!current.pos3d || !next.pos3d) {
                         return {
                             position: current.pos3d || next.pos3d || null,
@@ -535,99 +576,59 @@ var CesiumAnimatedProperty;
                     }
                 }
             }
-            // 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;
@@ -635,33 +636,27 @@ var CesiumAnimatedProperty;
             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;
                 }
@@ -673,11 +668,7 @@ var CesiumAnimatedProperty;
             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;
@@ -685,26 +676,34 @@ var CesiumAnimatedProperty;
             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;
@@ -714,74 +713,53 @@ var CesiumAnimatedProperty;
                 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());
                 }
             }
@@ -792,6 +770,52 @@ var CesiumAnimatedProperty;
             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) {