deeptwins-engine-3d 0.0.47 → 0.0.48

package/dist/cameraControl/ModelRoamRealTime.d.ts

@@ -6,6 +6,7 @@ interface Position {
     lng: number;
     lat: number;
     alt: number;
+    timestamp?: number;
 }
 export default class ModelRoamRealTime {
     readonly _map: any;
@@ -16,16 +17,16 @@ export default class ModelRoamRealTime {
     private readonly _onPositionUpdate;
     modelLayer: any;
     polylineLayer: any;
-    private positions;
-    private positionsLineC3;
-    private positionInterC3;
+    private receivedPositions;
+    private completedSegments;
+    private currentSegment;
+    private futureSegments;
+    private currentPointIndex;
+    private segmentCounter;
     private _eventPreUpdate;
     private modelMatrix;
     private hpRoll;
-    private _time;
     status: 'stop' | 'running' | 'destroy';
-    private currentPathIndex;
-    private maxPathIndex;
     private targetHeading;
     private currentHeading;
     private rotationSpeed;
@@ -35,9 +36,20 @@ export default class ModelRoamRealTime {
     /**
      * 实时添加点位
      * @param newPosition 新位置点
-     * @throws 如果新位置与上一个位置完全相同
      */
     updatePosition(newPosition: Position): void;
+    /**
+     * 判断两个位置是否相同
+     */
+    private isSamePosition;
+    /**
+     * 创建新的路径段
+     */
+    private createNewSegment;
+    /**
+     * 开始漫游
+     */
+    private startRoaming;
     /**
      * 计算两点之间的路径点
      * 使用插值算法生成平滑的路径
@@ -49,7 +61,7 @@ export default class ModelRoamRealTime {
     private _getInterPosition;
     /**
      * 初始化模型
-     * 加载模型
+     * 加载模型到第一个位置
      * @param initialPosition 初始位置
      */
     private initModel;
@@ -58,6 +70,31 @@ export default class ModelRoamRealTime {
      * 更新模型位置、朝向和路径线
      */
     private updateModel;
+    /**
+     * 完成当前路径段，切换到下一个路径段
+     */
+    private completeCurrentSegment;
+    /**
+     * 初始化轨迹线Entity
+     */
+    private initTrailLine;
+    /**
+     * 获取轨迹线位置点
+     * 返回：所有原始接收位置点 + 当前路径段已飞行的插值点
+     */
+    private getTrailLinePositions;
+    /**
+     * 更新轨迹线 - 现在由CallbackProperty自动更新
+     */
+    private updateTrailLine;
+    /**
+     * 获取当前状态信息
+     */
+    getStatus(): any;
+    /**
+     * 获取详细的飞行信息
+     */
+    getFlightDetails(): any;
     /**
      * 计算模型朝向
      * @param start 起始点

package/dist/cameraControl/ModelRoamRealTime.js

@@ -20,6 +20,10 @@ import { colorString } from "../tool/utils";
  * 位置信息
  */
 
+/**
+ * 路径段信息
+ */
+
 /**
  * 相机设置
  */
@@ -44,12 +48,19 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
     _defineProperty(this, "modelLayer", void 0);
     // 轨迹layer
     _defineProperty(this, "polylineLayer", void 0);
-    // 所有位置信息点
-    _defineProperty(this, "positions", []);
-    // 所有轨迹位置信息点 Cartesian3
-    _defineProperty(this, "positionsLineC3", []);
-    // 插值后的位置信息点 Cartesian3
-    _defineProperty(this, "positionInterC3", []);
+    // 重新设计的数据结构
+    // 接收到的原始位置数据
+    _defineProperty(this, "receivedPositions", []);
+    // 已完成飞行的路径段
+    _defineProperty(this, "completedSegments", []);
+    // 当前正在飞行的路径段
+    _defineProperty(this, "currentSegment", null);
+    // 未来计划飞行的路径段队列
+    _defineProperty(this, "futureSegments", []);
+    // 当前在路径段中的索引位置
+    _defineProperty(this, "currentPointIndex", 0);
+    // 路径段计数器
+    _defineProperty(this, "segmentCounter", 0);
     // 帧率更新的事件
     _defineProperty(this, "_eventPreUpdate", void 0);
     // 模型参数
@@ -58,14 +69,8 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
     // 模型姿态
     _defineProperty(this, "hpRoll", new Cesium.HeadingPitchRoll());
     // 漫游相关
-    // 上个点位的时间
-    _defineProperty(this, "_time", new Date().getTime());
     // 状态
     _defineProperty(this, "status", 'stop');
-    // 当前漫游路径点索引
-    _defineProperty(this, "currentPathIndex", 0);
-    // 最大路径点索引
-    _defineProperty(this, "maxPathIndex", 0);
     // 目标朝向角度
     _defineProperty(this, "targetHeading", 0);
     // 当前朝向角度
@@ -87,55 +92,38 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
      * 更新模型位置、朝向和路径线
      */
     _defineProperty(this, "updateModel", function () {
-      if (_this.currentPathIndex >= _this.maxPathIndex) {
+      if (!_this.currentSegment || _this.status !== 'running') {
         return;
       }
-      if (_this.currentPathIndex > 0 && _this.currentPathIndex < _this.positionInterC3.length - 1 && !_this.positionInterC3[_this.currentPathIndex - 1].equals(_this.positionInterC3[_this.currentPathIndex])) {
-        _this.getHeading(_this.positionInterC3[_this.currentPathIndex - 1], _this.positionInterC3[_this.currentPathIndex]);
+
+      // 检查当前路径段是否完成
+      if (_this.currentPointIndex >= _this.currentSegment.interpolatedPoints.length) {
+        _this.completeCurrentSegment();
+        return;
+      }
+      var currentPos = _this.currentSegment.interpolatedPoints[_this.currentPointIndex];
+
+      // 计算朝向
+      if (_this.currentPointIndex > 0) {
+        var prevPos = _this.currentSegment.interpolatedPoints[_this.currentPointIndex - 1];
+        _this.getHeading(prevPos, currentPos);
       }
+
       // 更新朝向
       _this.updateHeading();
-      var currentPos = _this.positionInterC3[_this.currentPathIndex];
-      if (!_this.positionsLineC3.some(function (pos) {
-        return pos.equals(currentPos);
-      })) {
-        _this.positionsLineC3.push(currentPos);
-        if (_this.positions.length > 1) {
-          // 更新轨迹
-          _this.polylineLayer && _this._map.scene.primitives.remove(_this.polylineLayer);
-          var trailGeometry = new Cesium.GeometryInstance({
-            id: '_modelRoamRealTimePolyline',
-            geometry: new Cesium.PolylineGeometry({
-              positions: _this.positionsLineC3,
-              width: _this.polylineOptions.width,
-              vertexFormat: Cesium.PolylineMaterialAppearance.VERTEX_FORMAT
-            })
-          });
-          _this.polylineLayer = _this._map.scene.primitives.add(new Cesium.Primitive({
-            geometryInstances: trailGeometry,
-            appearance: _this.polylineLayer ? _this.polylineLayer.appearance : new Cesium.PolylineMaterialAppearance({
-              material: new Cesium.Material({
-                fabric: {
-                  type: 'Color',
-                  uniforms: {
-                    color: colorString(_this.polylineOptions.color)
-                  }
-                }
-              })
-            }),
-            asynchronous: false
-          }));
-        }
-      }
-      if (_this.modelLayer && _this.currentPathIndex < _this.positionInterC3.length) {
-        // 更新模型位置
-        var _position = _this.positionInterC3[_this.currentPathIndex];
-        _this.modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(_position, _this.hpRoll, Cesium.Ellipsoid.WGS84, Cesium.Transforms.localFrameToFixedFrameGenerator('north', 'west'));
+
+      // 初始化轨迹线（如果还未创建）
+      _this.updateTrailLine();
+
+      // 更新模型位置
+      if (_this.modelLayer) {
+        // 只有位置真正发生变化时才更新矩阵
+        _this.modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(currentPos, _this.hpRoll, Cesium.Ellipsoid.WGS84, Cesium.Transforms.localFrameToFixedFrameGenerator('north', 'west'));
         _this.modelLayer.modelMatrix = _this.modelMatrix;
 
         // 调用位置更新回调
         if (_this._onPositionUpdate) {
-          var cartographic = Cesium.Cartographic.fromCartesian(_position);
+          var cartographic = Cesium.Cartographic.fromCartesian(currentPos);
           _this._onPositionUpdate({
             lon: Cesium.Math.toDegrees(cartographic.longitude),
             lat: Cesium.Math.toDegrees(cartographic.latitude),
@@ -146,19 +134,18 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
           _this.updateCameraView();
         }
       }
-      _this.currentPathIndex++;
+      _this.currentPointIndex++;
     });
-    var _ref = options || {},
-      model = _ref.model,
-      polyline = _ref.polyline,
-      onPositionUpdate = _ref.onPositionUpdate,
-      flyTo = _ref.flyTo;
     if (!map) {
       throw new Error('undefined map');
     }
-    if (!options.model && !((_options$model = options.model) !== null && _options$model !== void 0 && _options$model.url)) {
-      throw new Error('undefined model');
+    if (!options || !options.model || !((_options$model = options.model) !== null && _options$model !== void 0 && _options$model.url)) {
+      throw new Error('undefined model or invalid options');
     }
+    var model = options.model,
+      polyline = options.polyline,
+      onPositionUpdate = options.onPositionUpdate,
+      flyTo = options.flyTo;
     this._map = map;
     this.modelOptions = model;
     this.polylineOptions = merge(constant.DEFAULT_POLYLINE_PRIMITIVE_OPTIONS(), cloneDeep(polyline || {}));
@@ -169,44 +156,97 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
   /**
    * 实时添加点位
    * @param newPosition 新位置点
-   * @throws 如果新位置与上一个位置完全相同
    */
   _createClass(ModelRoamRealTime, [{
     key: "updatePosition",
     value: function updatePosition(newPosition) {
+      console.log(newPosition);
+      if (!newPosition) return;
       if (this.status === 'destroy') return;
-      if (!this.positions.length) {
+
+      // 添加时间戳
+      if (!newPosition.timestamp) {
+        newPosition.timestamp = new Date().getTime();
+      }
+
+      // 如果是第一次接收数据，初始化模型
+      if (this.receivedPositions.length === 0) {
+        this.receivedPositions.push(newPosition);
         this.initModel(newPosition);
         return;
       }
 
-      // 获取最后一个目标点的位置（而不是当前飞行位置）
-      var lastTargetPos = this.positions[this.positions.length - 1];
-      if (lastTargetPos) {
-        if (newPosition.lng === lastTargetPos.lng && newPosition.lat === lastTargetPos.lat && Math.abs(newPosition.alt - lastTargetPos.alt) < 0.1) {
-          return;
-        }
+      // 检查是否与上一个位置相同
+      var lastPos = this.receivedPositions[this.receivedPositions.length - 1];
+      if (this.isSamePosition(newPosition, lastPos)) {
+        return;
       }
 
-      // 将新位置添加到目标点数组
-      this.positions.push(newPosition);
-
-      // 从最后一个目标点计算到新点的路径
-      var lastPos = Cesium.Cartesian3.fromDegrees(lastTargetPos.lng, lastTargetPos.lat, lastTargetPos.alt);
-      var newPos = Cesium.Cartesian3.fromDegrees(newPosition.lng, newPosition.lat, newPosition.alt);
-
-      // 飞行时间
-      var newTime = new Date().getTime();
-      var flightTime = (newTime - this._time) / 1000;
-      this._time = newTime;
-      var newPath = this._getInterPosition(lastPos, newPos, flightTime);
-      if (this.status === 'running') {
-        this.positionInterC3 = this.positionInterC3.concat(newPath);
-        this.maxPathIndex = this.positionInterC3.length;
+      // 添加新位置到接收队列
+      this.receivedPositions.push(newPosition);
+
+      // 创建新的路径段
+      this.createNewSegment(lastPos, newPosition);
+
+      // 如果模型还未开始运行，启动运行
+      if (this.status === 'stop') {
+        this.startRoaming();
+      }
+    }
+
+    /**
+     * 判断两个位置是否相同
+     */
+  }, {
+    key: "isSamePosition",
+    value: function isSamePosition(pos1, pos2) {
+      return pos1.lng === pos2.lng && pos1.lat === pos2.lat && Math.abs(pos1.alt - pos2.alt) < 0.1;
+    }
+
+    /**
+     * 创建新的路径段
+     */
+  }, {
+    key: "createNewSegment",
+    value: function createNewSegment(startPos, endPos) {
+      var startC3 = Cesium.Cartesian3.fromDegrees(startPos.lng, startPos.lat, startPos.alt);
+      var endC3 = Cesium.Cartesian3.fromDegrees(endPos.lng, endPos.lat, endPos.alt);
+
+      // 计算飞行时间
+      var flightTime = endPos.timestamp && startPos.timestamp ? (endPos.timestamp - startPos.timestamp) / 1000 : 5; // 默认5秒
+
+      // 计算插值点
+      var interpolatedPoints = this._getInterPosition(startC3, endC3, flightTime);
+      var newSegment = {
+        startPos: startPos,
+        endPos: endPos,
+        interpolatedPoints: interpolatedPoints,
+        segmentIndex: this.segmentCounter++,
+        isCompleted: false
+      };
+
+      // 如果当前没有正在飞行的路径段，则设为当前段
+      if (!this.currentSegment) {
+        this.currentSegment = newSegment;
+        this.currentPointIndex = 0;
       } else {
-        this.currentPathIndex = 0;
+        // 否则加入未来路径段队列
+        this.futureSegments.push(newSegment);
       }
     }
+
+    /**
+     * 开始漫游
+     */
+  }, {
+    key: "startRoaming",
+    value: function startRoaming() {
+      if (this.status === 'running') return;
+      this.status = 'running';
+      // 监听帧率更新
+      this._eventPreUpdate = this._map.on(constant.SCENE_EVENT_TYPE.PRE_UPDATE, this.updateModel);
+    }
+
     /**
      * 计算两点之间的路径点
      * 使用插值算法生成平滑的路径
@@ -278,9 +318,10 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       }
       return arr;
     }
+
     /**
      * 初始化模型
-     * 加载模型
+     * 加载模型到第一个位置
      * @param initialPosition 初始位置
      */
   }, {
@@ -292,20 +333,17 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              // 添加初始位置到目标点数组
-              this.positions.push(initialPosition);
-              pos = Cesium.Cartesian3.fromDegrees(initialPosition.lng, initialPosition.lat, initialPosition.alt);
-              this.positionsLineC3 = [pos];
-              // 创建模型矩阵
+              pos = Cesium.Cartesian3.fromDegrees(initialPosition.lng, initialPosition.lat, initialPosition.alt); // 创建模型矩阵
               this.modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(pos, this.hpRoll, Cesium.Ellipsoid.WGS84, Cesium.Transforms.localFrameToFixedFrameGenerator('north', 'west'));
-              _context.next = 6;
+              _context.next = 4;
               return Cesium.Model.fromGltfAsync(_objectSpread({
                 id: uuidv4(),
                 modelMatrix: this.modelMatrix
               }, this.modelOptions));
-            case 6:
+            case 4:
               model = _context.sent;
               this.modelLayer = this._map.scene.primitives.add(model);
+
               // 开启动画
               this.modelLayer.readyEvent.addEventListener(function () {
                 if (_this2.flyTo) {
@@ -315,13 +353,8 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
                   loop: Cesium.ModelAnimationLoop.REPEAT,
                   multiplier: 2
                 });
-                if (_this2.status === 'stop') {
-                  _this2.status = 'running';
-                  // 监听帧率
-                  _this2._eventPreUpdate = _this2._map.on(constant.SCENE_EVENT_TYPE.PRE_UPDATE, _this2.updateModel);
-                }
               });
-            case 9:
+            case 7:
             case "end":
               return _context.stop();
           }
@@ -333,14 +366,178 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       return initModel;
     }())
   }, {
-    key: "getHeading",
+    key: "completeCurrentSegment",
     value:
+    /**
+     * 完成当前路径段，切换到下一个路径段
+     */
+    function completeCurrentSegment() {
+      if (!this.currentSegment) return;
+
+      // 标记当前段为已完成
+      this.currentSegment.isCompleted = true;
+      this.completedSegments.push(this.currentSegment);
+
+      // 从未来路径段队列中取出下一个路径段
+      if (this.futureSegments.length > 0) {
+        this.currentSegment = this.futureSegments.shift();
+        this.currentPointIndex = 0;
+      } else {
+        // 没有更多路径段，等待新数据
+        this.currentSegment = null;
+        this.currentPointIndex = 0;
+      }
+    }
+
+    /**
+     * 初始化轨迹线Entity
+     */
+  }, {
+    key: "initTrailLine",
+    value: function initTrailLine() {
+      var _this3 = this;
+      // 创建轨迹线Entity，使用callback动态更新位置
+      this.polylineLayer = this._map.entities.add({
+        id: '_modelRoamRealTimePolyline',
+        polyline: {
+          positions: new Cesium.CallbackProperty(function () {
+            return _this3.getTrailLinePositions();
+          }, false),
+          width: this.polylineOptions.width || 3,
+          material: colorString(this.polylineOptions.color || '#00ff00'),
+          clampToGround: false
+        }
+      });
+    }
+
+    /**
+     * 获取轨迹线位置点
+     * 返回：所有原始接收位置点 + 当前路径段已飞行的插值点
+     */
+  }, {
+    key: "getTrailLinePositions",
+    value: function getTrailLinePositions() {
+      var positions = [];
+
+      // 确保receivedPositions是数组且有足够数据
+      if (!Array.isArray(this.receivedPositions) || this.receivedPositions.length < 2) {
+        return positions;
+      }
+
+      // 添加所有原始接收到的位置点（转换为Cartesian3）
+      this.receivedPositions.forEach(function (pos) {
+        if (pos && typeof pos.lng === 'number' && typeof pos.lat === 'number' && typeof pos.alt === 'number') {
+          positions.push(Cesium.Cartesian3.fromDegrees(pos.lng, pos.lat, pos.alt));
+        }
+      });
+
+      // 如果当前有正在飞行的路径段，添加已飞行过的插值点
+      if (this.currentSegment && Array.isArray(this.currentSegment.interpolatedPoints) && this.currentPointIndex > 0) {
+        // 添加当前路径段中已经飞行过的插值点（跳过第一个点，避免重复）
+        for (var i = 1; i <= this.currentPointIndex && i < this.currentSegment.interpolatedPoints.length; i++) {
+          positions.push(this.currentSegment.interpolatedPoints[i]);
+        }
+      }
+      return positions;
+    }
+
+    /**
+     * 更新轨迹线 - 现在由CallbackProperty自动更新
+     */
+  }, {
+    key: "updateTrailLine",
+    value: function updateTrailLine() {
+      // 由于使用了CallbackProperty和getTrailLinePositions方法
+      // 轨迹线会自动更新显示：所有原始位置点 + 当前段已飞行的插值点
+      if (!this.polylineLayer && this.receivedPositions.length >= 2) {
+        this.initTrailLine();
+      }
+    }
+
+    /**
+     * 获取当前状态信息
+     */
+  }, {
+    key: "getStatus",
+    value: function getStatus() {
+      var _this$currentSegment;
+      var currentProgress = this.currentSegment ? Math.round(this.currentPointIndex / this.currentSegment.interpolatedPoints.length * 100) : 0;
+      return {
+        status: this.status,
+        receivedPositionsCount: this.receivedPositions.length,
+        completedSegmentsCount: this.completedSegments.length,
+        currentSegmentIndex: ((_this$currentSegment = this.currentSegment) === null || _this$currentSegment === void 0 ? void 0 : _this$currentSegment.segmentIndex) || null,
+        currentSegmentProgress: "".concat(currentProgress, "%"),
+        futureSegmentsCount: this.futureSegments.length,
+        currentPointIndex: this.currentPointIndex,
+        totalTrailPoints: this.getTrailLinePositions().length,
+        isWaitingForData: !this.currentSegment && this.futureSegments.length === 0
+      };
+    }
+
+    /**
+     * 获取详细的飞行信息
+     */
+  }, {
+    key: "getFlightDetails",
+    value: function getFlightDetails() {
+      var _this4 = this;
+      return {
+        // 当前位置信息
+        currentPosition: this.currentSegment && this.currentPointIndex < this.currentSegment.interpolatedPoints.length ? function () {
+          var pos = _this4.currentSegment.interpolatedPoints[_this4.currentPointIndex];
+          var cartographic = Cesium.Cartographic.fromCartesian(pos);
+          return {
+            longitude: Cesium.Math.toDegrees(cartographic.longitude),
+            latitude: Cesium.Math.toDegrees(cartographic.latitude),
+            height: cartographic.height
+          };
+        }() : null,
+        // 当前路径段信息
+        currentSegment: this.currentSegment ? {
+          index: this.currentSegment.segmentIndex,
+          startPos: this.currentSegment.startPos,
+          endPos: this.currentSegment.endPos,
+          totalPoints: this.currentSegment.interpolatedPoints.length,
+          currentPoint: this.currentPointIndex,
+          progress: Math.round(this.currentPointIndex / this.currentSegment.interpolatedPoints.length * 100)
+        } : null,
+        // 队列信息
+        queue: {
+          completed: Array.isArray(this.completedSegments) ? this.completedSegments.map(function (seg) {
+            return {
+              index: seg.segmentIndex,
+              from: "(".concat(seg.startPos.lng, ", ").concat(seg.startPos.lat, ")"),
+              to: "(".concat(seg.endPos.lng, ", ").concat(seg.endPos.lat, ")")
+            };
+          }) : [],
+          future: Array.isArray(this.futureSegments) ? this.futureSegments.map(function (seg) {
+            return {
+              index: seg.segmentIndex,
+              from: "(".concat(seg.startPos.lng, ", ").concat(seg.startPos.lat, ")"),
+              to: "(".concat(seg.endPos.lng, ", ").concat(seg.endPos.lat, ")"),
+              points: seg.interpolatedPoints.length
+            };
+          }) : []
+        },
+        // 整体统计
+        statistics: {
+          totalDataReceived: this.receivedPositions.length,
+          totalSegmentsCreated: this.segmentCounter,
+          totalTrailPoints: this.getTrailLinePositions().length,
+          memoryStatus: "\u5DF2\u5B8C\u6210\u6BB5\u6570: ".concat(this.completedSegments.length, ", \u7B49\u5F85\u6BB5\u6570: ").concat(this.futureSegments.length)
+        }
+      };
+    }
+
     /**
      * 计算模型朝向
      * @param start 起始点
      * @param end 终点
      */
-    function getHeading(start, end) {
+  }, {
+    key: "getHeading",
+    value: function getHeading(start, end) {
       var startCartographic = Cesium.Cartographic.fromCartesian(start);
       var endCartographic = Cesium.Cartographic.fromCartesian(end);
       var startLonLat = [Cesium.Math.toDegrees(startCartographic.longitude), Cesium.Math.toDegrees(startCartographic.latitude)];
@@ -355,6 +552,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       var localDirection = Cesium.Matrix4.multiplyByPointAsVector(Cesium.Matrix4.inverse(transform, new Cesium.Matrix4()), direction, new Cesium.Cartesian3());
       this.targetHeading = Math.atan2(localDirection.x, localDirection.y);
     }
+
     /**
      * 更新模型朝向
      */
@@ -382,6 +580,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       // 更新模型朝向
       this.hpRoll = new Cesium.HeadingPitchRoll(this.currentHeading, 0.0, 0.0);
     }
+
     /**
      * 更新相机视角
      * 根据当前模式更新相机位置和朝向
@@ -389,16 +588,17 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
   }, {
     key: "updateCameraView",
     value: function updateCameraView() {
-      if (!this.modelLayer || !this.positionInterC3) {
+      if (!this.modelLayer || !this.currentSegment) {
         return;
       }
-      var position = this.currentPathIndex >= this.positionInterC3.length ? this.positionInterC3[this.positionInterC3.length - 1] : this.positionInterC3[this.currentPathIndex];
+      var position = this.currentPointIndex >= this.currentSegment.interpolatedPoints.length ? this.currentSegment.interpolatedPoints[this.currentSegment.interpolatedPoints.length - 1] : this.currentSegment.interpolatedPoints[this.currentPointIndex];
       if (this.follow === 'first') {
         this.updateFirstPersonView(position);
       } else if (this.follow === 'third') {
         this.updateThirdPersonView(position);
       }
     }
+
     /**
      * 更新第一人称视角
      * @param position 模型当前位置
@@ -416,6 +616,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
         }
       });
     }
+
     /**
      * 更新第三人称视角
      * @param position 模型当前位置
@@ -425,6 +626,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
     value: function updateThirdPersonView(position) {
       this._map.camera.lookAt(position, new Cesium.HeadingPitchRange(this.hpRoll.heading, Cesium.Math.toRadians(this.thirdPersonSettings.pitch), this.thirdPersonSettings.distance));
     }
+
     /**
      * 设置第一人称视角
      */
@@ -436,6 +638,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       this.follow = 'first';
       this.updateCameraView();
     }
+
     /**
      * 设置第一人称视角
      */
@@ -447,6 +650,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       this.follow = 'third';
       this.updateCameraView();
     }
+
     /**
      * 取消视角跟随
      */
@@ -456,6 +660,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       if (this.status === 'destroy') return;
       this.follow = null;
     }
+
     /**
      * 飞行定位到模型
      */
@@ -466,6 +671,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
       boundingSphere.radius = Math.max(boundingSphere.radius || 100);
       this._map.camera.flyToBoundingSphere(boundingSphere);
     }
+
     /**
      * 监听
      */
@@ -474,6 +680,7 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
     value: function on(type, event) {
       return this._map._event.listenToModelRoam(type, event, this);
     }
+
     /**
      * 销毁实例
      * 清理所有资源
@@ -489,14 +696,15 @@ var ModelRoamRealTime = /*#__PURE__*/function () {
         this.modelLayer = null;
       }
       if (this.polylineLayer) {
-        this._map.scene.primitives.remove(this.polylineLayer);
+        this._map.entities.remove(this.polylineLayer);
         this.polylineLayer = null;
       }
-      this.positions = [];
-      this.positionsLineC3 = [];
-      this.positionInterC3 = [];
-      this.currentPathIndex = 0;
-      this.maxPathIndex = 0;
+      this.receivedPositions = [];
+      this.completedSegments = [];
+      this.currentSegment = null;
+      this.futureSegments = [];
+      this.currentPointIndex = 0;
+      this.segmentCounter = 0;
     }
   }]);
   return ModelRoamRealTime;

package/dist/deepTwins/index.js

@@ -39,7 +39,8 @@ var DeepTwins = /*#__PURE__*/function () {
                   terrain: this._getTerrain.bind(this),
                   moduleLayer: this._getModuleLayer.bind(this),
                   trafficHistoryLayer: this._YunJing.TrafficHistoryLayer,
-                  trafficLayer: this._YunJing.TrafficLayer
+                  trafficLayer: this._YunJing.TrafficLayer,
+                  gridVTLayer: this._YunJing.GridVTLayer
                 });
               }
             case 5:

package/dist/index.js

@@ -45,7 +45,7 @@ window.Cesium = Cesium;
 var DeepTwinsEngine3D = /*#__PURE__*/_createClass(function DeepTwinsEngine3D() {
   _classCallCheck(this, DeepTwinsEngine3D);
 });
-_defineProperty(DeepTwinsEngine3D, "Version", '0.0.47');
+_defineProperty(DeepTwinsEngine3D, "Version", '0.0.48');
 _defineProperty(DeepTwinsEngine3D, "Map", Map);
 _defineProperty(DeepTwinsEngine3D, "GroundSkyBox", GroundSkyBox);
 _defineProperty(DeepTwinsEngine3D, "RasterLayer", RasterLayer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deeptwins-engine-3d",
-  "version": "0.0.47",
+  "version": "0.0.48",
   "description": "map for 3d",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",