@jorgmoritz/gis-manager 0.1.26 → 0.1.28

package/dist/vue/index.cjs

@@ -1185,6 +1185,7 @@ var SceneManager = class {
       const tileset = await this.apply3Dtiles(url);
       if (tileset) {
         tileset._customId = layer_id;
+        tileset._url = url;
         this.viewer.scene.primitives.add(tileset);
         console.log(`[SceneManager] \u65B0\u5EFA 3DTiles_id`, tileset._customId);
       }
@@ -1916,6 +1917,8 @@ var PathPreview = class {
     __publicField(this, "fovController");
     // FOV 控制器
     __publicField(this, "currentFOV");
+    /** 已加载的 3D Tiles 实例（预览窗口独立的） */
+    __publicField(this, "tilesets", /* @__PURE__ */ new Map());
     this.currentFOV = opts.fov ?? 50;
     this.ensureViewer();
     this.ensureFOVController();
@@ -1970,8 +1973,201 @@ var PathPreview = class {
       }
     } catch {
     }
-    v.scene;
     this.overlayViewer = v;
+    this.syncFromMainViewer();
+    this.disableUserInteraction();
+  }
+  /**
+   * 从主 viewer 同步配置
+   * 共享 Provider（安全）而非 DataSource
+   */
+  syncFromMainViewer() {
+    if (!this.overlayViewer) return;
+    this.syncImageryLayers();
+    this.syncTerrainProvider();
+    this.syncSceneSettings();
+    this.sync3DTiles();
+  }
+  /**
+   * 同步影像图层（共享 ImageryProvider）
+   */
+  syncImageryLayers() {
+    const v = this.overlayViewer;
+    if (!v) return;
+    try {
+      v.imageryLayers?.removeAll?.();
+      const mainImageryLayers = this.mainViewer.imageryLayers;
+      for (let i = 0; i < mainImageryLayers.length; i++) {
+        const layer = mainImageryLayers.get(i);
+        try {
+          v.imageryLayers?.addImageryProvider?.(layer.imageryProvider);
+        } catch {
+        }
+      }
+    } catch (e) {
+      console.warn("[PathPreview] Failed to sync imagery layers:", e);
+    }
+  }
+  /**
+   * 同步地形提供者（共享 TerrainProvider）
+   */
+  syncTerrainProvider() {
+    const v = this.overlayViewer;
+    if (!v) return;
+    try {
+      if (this.mainViewer.terrainProvider) {
+        v.terrainProvider = this.mainViewer.terrainProvider;
+      }
+    } catch (e) {
+      console.warn("[PathPreview] Failed to sync terrain provider:", e);
+    }
+  }
+  /**
+   * 同步 3D Tiles（点云、倾斜摄影等）
+   * 注意：Primitive 不能直接共享，需要创建独立实例
+   * 此方法查找主 viewer 中的 tileset 并尝试使用相同 URL 创建新实例
+   */
+  sync3DTiles() {
+    const v = this.overlayViewer;
+    if (!v) return;
+    const C = this.CesiumNS;
+    const mainPrimitives = this.mainViewer.scene.primitives;
+    try {
+      for (let i = 0; i < mainPrimitives.length; i++) {
+        const primitive = mainPrimitives.get(i);
+        if (primitive && primitive instanceof C.Cesium3DTileset) {
+          const customId = primitive._customId;
+          const url = primitive._url || primitive.resource?.url;
+          if (url && customId && !this.tilesets.has(customId)) {
+            this.add3DTiles(url, customId);
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("[PathPreview] Failed to sync 3DTiles:", e);
+    }
+  }
+  /**
+   * 手动添加 3D Tiles 到预览窗口
+   * @param url 3D Tiles URL
+   * @param id 唯一标识符
+   */
+  async add3DTiles(url, id) {
+    const v = this.overlayViewer;
+    if (!v) return void 0;
+    if (this.tilesets.has(id)) {
+      return this.tilesets.get(id);
+    }
+    const C = this.CesiumNS;
+    try {
+      const tileset = await C.Cesium3DTileset.fromUrl(url, {
+        maximumScreenSpaceError: 16
+      });
+      if (tileset) {
+        tileset._customId = id;
+        tileset._url = url;
+        v.scene.primitives.add(tileset);
+        this.tilesets.set(id, tileset);
+        console.log("[PathPreview] Added 3DTiles:", id);
+      }
+      return tileset;
+    } catch (e) {
+      console.warn("[PathPreview] Failed to add 3DTiles:", url, e);
+      return void 0;
+    }
+  }
+  /**
+   * 移除 3D Tiles
+   */
+  remove3DTiles(id) {
+    const v = this.overlayViewer;
+    if (!v) return;
+    const tileset = this.tilesets.get(id);
+    if (tileset) {
+      try {
+        v.scene.primitives.remove(tileset);
+      } catch {
+      }
+      this.tilesets.delete(id);
+    }
+  }
+  /**
+   * 同步场景设置（Globe、天空、雾效等）
+   */
+  syncSceneSettings() {
+    const v = this.overlayViewer;
+    if (!v) return;
+    const s = v.scene;
+    const mainScene = this.mainViewer.scene;
+    try {
+      if (s.globe && mainScene.globe) {
+        s.globe.show = mainScene.globe.show;
+        s.globe.enableLighting = mainScene.globe.enableLighting;
+        s.globe.baseColor = mainScene.globe.baseColor;
+        s.globe.showGroundAtmosphere = mainScene.globe.showGroundAtmosphere;
+        s.globe.depthTestAgainstTerrain = mainScene.globe.depthTestAgainstTerrain;
+      }
+      if (mainScene.skyBox) {
+        s.skyBox = mainScene.skyBox;
+      } else {
+        s.skyBox = void 0;
+      }
+      if (mainScene.skyAtmosphere) {
+        s.skyAtmosphere.show = mainScene.skyAtmosphere.show;
+      }
+      if (s.fog && mainScene.fog) {
+        s.fog.enabled = mainScene.fog.enabled;
+        s.fog.density = mainScene.fog.density;
+      }
+      v.shadows = this.mainViewer.shadows;
+      if (s.postProcessStages?.fxaa && mainScene.postProcessStages?.fxaa) {
+        s.postProcessStages.fxaa.enabled = mainScene.postProcessStages.fxaa.enabled;
+      }
+    } catch (e) {
+      console.warn("[PathPreview] Failed to sync scene settings:", e);
+    }
+  }
+  /**
+   * 禁用用户交互，相机仅通过 setPose() 控制
+   */
+  disableUserInteraction() {
+    const v = this.overlayViewer;
+    if (!v) return;
+    const s = v.scene;
+    try {
+      const scc = s.screenSpaceCameraController;
+      if (scc) {
+        scc.enableInputs = false;
+        scc.enableRotate = false;
+        scc.enableTranslate = false;
+        scc.enableZoom = false;
+        scc.enableTilt = false;
+        scc.enableLook = false;
+        scc.inertiaSpin = 0;
+        scc.inertiaZoom = 0;
+        scc.inertiaTranslate = 0;
+      }
+      const canvas = s?.canvas ?? v.scene?.canvas;
+      if (canvas && canvas.style) {
+        canvas.style.pointerEvents = "none";
+        try {
+          canvas.setAttribute("tabindex", "-1");
+        } catch {
+        }
+      }
+      v.trackedEntity = void 0;
+      if (v.clock) {
+        v.clock.shouldAnimate = false;
+      }
+    } catch (e) {
+      console.warn("[PathPreview] Failed to disable user interaction:", e);
+    }
+  }
+  /**
+   * 刷新同步（运行时更新）
+   */
+  refresh() {
+    this.syncFromMainViewer();
   }
   /**
    * 创建 FOV 控制器
@@ -2133,30 +2329,63 @@ var PathPreview = class {
       this.fovController.hide();
     }
   }
-  // destroy(): void {
-  //   if (this.destroyed) return;
-  //   this.destroyed = true;
-  //   // try {
-  //   //   if (this.footprintEntity) (this.layer.entities as any).remove(this.footprintEntity);
-  //   // } catch {}
-  //   this.footprintEntity = undefined;
-  //   
-  //   // 销毁 FOV 控制器
-  //   try {
-  //     this.fovController?.destroy();
-  //   } catch {}
-  //   this.fovController = undefined;
-  //   
-  //   try {
-  //     (this.overlayViewer as any)?.destroy?.();
-  //   } catch {}
-  //   this.overlayViewer = undefined;
-  //   try {
-  //     if (this.containerEl && this.containerEl.parentElement)
-  //       this.containerEl.parentElement.removeChild(this.containerEl);
-  //   } catch {}
-  //   this.containerEl = undefined;
-  // }
+  /**
+   * 显示预览窗口
+   */
+  show() {
+    if (this.containerEl) {
+      this.containerEl.style.display = "block";
+    }
+  }
+  /**
+   * 隐藏预览窗口
+   */
+  hide() {
+    if (this.containerEl) {
+      this.containerEl.style.display = "none";
+    }
+  }
+  /**
+   * 获取预览 viewer 实例
+   */
+  getOverlayViewer() {
+    return this.overlayViewer;
+  }
+  /**
+   * 销毁预览窗口，释放所有资源
+   */
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    try {
+      this.fovController?.destroy();
+    } catch {
+    }
+    this.fovController = void 0;
+    this.footprintEntity = void 0;
+    try {
+      this.tilesets.forEach((tileset) => {
+        try {
+          this.overlayViewer?.scene?.primitives?.remove?.(tileset);
+        } catch {
+        }
+      });
+      this.tilesets.clear();
+    } catch {
+    }
+    try {
+      this.overlayViewer?.destroy?.();
+    } catch {
+    }
+    this.overlayViewer = void 0;
+    try {
+      if (this.containerEl && this.containerEl.parentElement) {
+        this.containerEl.parentElement.removeChild(this.containerEl);
+      }
+    } catch {
+    }
+    this.containerEl = void 0;
+  }
 };
 
 // src/core/path-manager/FrustumPyramid.ts
@@ -2892,11 +3121,11 @@ var AirplaneCursor = class {
         setPos(addVec(pose.position, C.Cartesian3.multiplyByScalar(e3, step, new C.Cartesian3())));
         moved = true;
       }
-      if (this.keysPressed.has("z")) {
+      if (this.keysPressed.has("c")) {
         setPos(addVec(pose.position, C.Cartesian3.multiplyByScalar(u3, step, new C.Cartesian3())));
         moved = true;
       }
-      if (this.keysPressed.has("c")) {
+      if (this.keysPressed.has("z")) {
         setPos(addVec(pose.position, C.Cartesian3.multiplyByScalar(u3, -step, new C.Cartesian3())));
         moved = true;
       }
@@ -4044,6 +4273,7 @@ var PathEditingEventHandler = class {
     __publicField(this, "contextMenuManager");
     __publicField(this, "vertexDragHandler");
     __publicField(this, "callbacks");
+    __publicField(this, "keydownListener");
     this.CesiumNS = options.CesiumNS;
     this.viewer = options.viewer;
     this.hiddenClimbIndex = options.hiddenClimbIndex;
@@ -4168,6 +4398,37 @@ var PathEditingEventHandler = class {
       }
       this.handleRightClick(movement);
     }, C.ScreenSpaceEventType.RIGHT_CLICK);
+    this.keydownListener = (e) => {
+      if (e.code !== "Space") return;
+      const target = e.target;
+      if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) {
+        return;
+      }
+      if (this.vertexDragHandler.isDragging()) return;
+      e.preventDefault();
+      this.handleSpaceKeyInsert();
+    };
+    document.addEventListener("keydown", this.keydownListener);
+  }
+  /**
+   * 处理空格键快捷插入航点
+   * 在飞机游标当前位置，将航点添加到所有航点末尾
+   */
+  handleSpaceKeyInsert() {
+    const airplaneCursor = this.callbacks.getAirplaneCursor?.();
+    if (!airplaneCursor) {
+      console.warn("[PathEditingEventHandler] \u7A7A\u683C\u952E\u63D2\u5165\uFF1A\u98DE\u673A\u6E38\u6807\u4E0D\u5B58\u5728");
+      return;
+    }
+    const pose = airplaneCursor.getPose();
+    if (!pose || !pose.position) {
+      console.warn("[PathEditingEventHandler] \u7A7A\u683C\u952E\u63D2\u5165\uFF1A\u65E0\u6CD5\u83B7\u53D6\u6E38\u6807\u59FF\u6001");
+      return;
+    }
+    const positions = this.callbacks.getPositions?.() || [];
+    const insertAt = positions.length;
+    console.log("[PathEditingEventHandler] \u7A7A\u683C\u952E\u5FEB\u6377\u63D2\u5165\u822A\u70B9\uFF0C\u4F4D\u7F6E\u7D22\u5F15:", insertAt);
+    this.handleInsertVertex(insertAt, pose, "after");
   }
   /**
    * 处理右键点击事件
@@ -4182,12 +4443,13 @@ var PathEditingEventHandler = class {
       const entity = picked?.id;
       const airplaneCursor = this.callbacks.getAirplaneCursor?.();
       const vertexIndex = pickVertexIndex(this.viewer, movement.position, this.hiddenClimbIndex);
+      const viewportPosition = this.canvasToViewportPosition(movement.position);
       if (typeof vertexIndex === "number") {
         const menuItems = this.buildVertexContextMenuItems(vertexIndex);
-        this.contextMenuManager.show(movement.position, menuItems);
+        this.contextMenuManager.show(viewportPosition, menuItems);
       } else if (airplaneCursor && airplaneCursor.containsEntity(entity)) {
         const menuItems = this.buildAirplaneCursorContextMenuItems();
-        this.contextMenuManager.show(movement.position, menuItems);
+        this.contextMenuManager.show(viewportPosition, menuItems);
       }
     } catch (error) {
       console.error("Error handling right click:", error);
@@ -4491,6 +4753,18 @@ var PathEditingEventHandler = class {
       return 0;
     }
   }
+  /**
+   * 将 canvas 坐标转换为视口坐标
+   * Cesium 事件返回的坐标是相对于 canvas 的，而菜单需要相对于视口的坐标
+   */
+  canvasToViewportPosition(canvasPosition) {
+    const canvas = this.viewer.scene.canvas;
+    const rect = canvas.getBoundingClientRect();
+    return {
+      x: canvasPosition.x + rect.left,
+      y: canvasPosition.y + rect.top
+    };
+  }
   /**
    * 🆕 从鼠标事件获取位置
    */
@@ -4516,6 +4790,10 @@ var PathEditingEventHandler = class {
    * 销毁事件处理器
    */
   destroy() {
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = void 0;
+    }
     try {
       this.vertexDragHandler.destroy();
     } catch {
@@ -4927,6 +5205,10 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
     } catch {
     }
   };
+  const getTotalDistance = () => {
+    if (positions.length < 2) return 0;
+    return calculatePathDistance(CesiumNS, positions, positions.length - 1, hiddenClimbIndex);
+  };
   const vertexInsertionHandler = new VertexInsertionHandler({
     CesiumNS,
     layer,
@@ -4937,6 +5219,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   if (!cursorStart) cursorStart = positions[hiddenClimbIndex === 1 ? 1 : 0];
   let airplaneCursor;
   const insertVertex = (insertAt, p3, poseOrient) => {
+    console.log("[PathEditing] \u63D2\u5165\u9876\u70B9\u524D positions \u957F\u5EA6:", positions.length, "insertAt:", insertAt);
     const actualIndex = vertexInsertionHandler.insertVertex(
       insertAt,
       p3,
@@ -4952,6 +5235,8 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       airplaneCursor,
       poseOrient
     );
+    console.log("[PathEditing] \u63D2\u5165\u9876\u70B9\u540E positions \u957F\u5EA6:", positions.length, "actualIndex:", actualIndex);
+    entity.polyline.positions = new C.CallbackProperty(() => positions.slice(), false);
     setActiveIndex(actualIndex);
     createOrUpdateMarkerForIndex(actualIndex);
   };
@@ -4982,6 +5267,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
         } catch {
         }
       }
+      console.log("[PathEditing] \u5220\u9664\u9876\u70B9\u524D positions \u957F\u5EA6:", positions.length, "deleteAt:", deleteAt);
       positions.splice(deleteAt, 1);
       handles.splice(deleteAt, 1);
       headings.splice(deleteAt, 1);
@@ -4989,6 +5275,8 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       rolls.splice(deleteAt, 1);
       fovs.splice(deleteAt, 1);
       heightMarkers.splice(deleteAt, 1);
+      console.log("[PathEditing] \u5220\u9664\u9876\u70B9\u540E positions \u957F\u5EA6:", positions.length);
+      entity.polyline.positions = new C.CallbackProperty(() => positions.slice(), false);
       const newEditedIndices = /* @__PURE__ */ new Set();
       editedIndices.forEach((idx) => {
         if (idx < deleteAt) {
@@ -5111,7 +5399,9 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
               totalVerticesBefore: totalBefore,
               totalVerticesAfter: totalAfter,
               newVertex,
-              timestamp: /* @__PURE__ */ new Date()
+              timestamp: /* @__PURE__ */ new Date(),
+              totalDistance: getTotalDistance()
+              // 🆕 航线总里程
             };
             options.onVertexInsertDetail(operationInfo);
           } catch (error) {
@@ -5132,7 +5422,9 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
               displayNumber,
               totalVerticesBefore: totalBefore,
               totalVerticesAfter: totalAfter,
-              timestamp: /* @__PURE__ */ new Date()
+              timestamp: /* @__PURE__ */ new Date(),
+              totalDistance: getTotalDistance()
+              // 🆕 航线总里程
             };
             options.onVertexDeleteDetail(operationInfo);
           } catch (error) {
@@ -5212,7 +5504,9 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
               totalVerticesAfter: positions.length,
               newVertex: vertexInfo,
               newPosition: finalPosition,
-              timestamp: /* @__PURE__ */ new Date()
+              timestamp: /* @__PURE__ */ new Date(),
+              totalDistance: getTotalDistance()
+              // 🆕 航线总里程
             };
             options.onVertexDragCompleteDetail(operationInfo);
           } catch (error) {
@@ -5241,6 +5535,18 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   );
   const cleanupSession = () => {
     setActiveIndex(void 0);
+    try {
+      handles.forEach((handle) => {
+        if (handle) {
+          try {
+            layer.entities.remove(handle);
+          } catch {
+          }
+        }
+      });
+      handles.length = 0;
+    } catch {
+    }
     try {
       heightMarkers.forEach((m) => m?.destroy());
     } catch {
@@ -5565,7 +5871,55 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
     /**
      * 🆕 获取游标当前姿态（包含高度）
      */
-    getCursorPose: () => airplaneCursor?.getPose()
+    getCursorPose: () => airplaneCursor?.getPose(),
+    /**
+     * 🆕 动态更新爬升高度（climbHeight）
+     * 更新隐藏爬升点（index 1）的高度，实现安全飞行高度的动态调节
+     * @param climbHeight 新的爬升高度（米）
+     * @returns 是否更新成功
+     */
+    updateClimbHeight: function(climbHeight) {
+      if (hiddenClimbIndex !== 1 || positions.length < 2) {
+        console.warn("[updateClimbHeight] No hidden climb point exists");
+        return false;
+      }
+      try {
+        const startPos = positions[0];
+        const startCarto = C.Cartographic.fromCartesian(startPos);
+        const newAltitude = startCarto.height + climbHeight;
+        const success = this.updateWaypointAltitude(1, newAltitude);
+        if (success) {
+          try {
+            entity.properties._climbHeight = climbHeight;
+          } catch {
+          }
+          console.log("[updateClimbHeight] \u2705 \u722C\u5347\u9AD8\u5EA6\u5DF2\u66F4\u65B0:", climbHeight, "\u7C73");
+        }
+        return success;
+      } catch (error) {
+        console.error("[updateClimbHeight] Error:", error);
+        return false;
+      }
+    },
+    /**
+     * 🆕 获取起飞点信息
+     * @returns 起飞点的经纬度和高度
+     */
+    getStartPoint: () => {
+      if (positions.length < 1) return null;
+      try {
+        const startPos = positions[0];
+        const carto = C.Cartographic.fromCartesian(startPos);
+        return {
+          position: startPos,
+          latitude: C.Math.toDegrees(carto.latitude),
+          longitude: C.Math.toDegrees(carto.longitude),
+          altitude: carto.height
+        };
+      } catch {
+        return null;
+      }
+    }
   };
 }
 function fovToFocalLength(fovDeg) {
@@ -5741,6 +6095,7 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
   const DEFAULT_MAIN_WIDTH = options?.width ?? 6;
   let startCartographic;
   let hasStart = false;
+  let createdEntity = void 0;
   const getPositionFromMouse = (movement) => {
     const scene = viewer.scene;
     const winPos = movement?.position ?? movement?.endPosition ?? movement;
@@ -5841,6 +6196,7 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
           _hasHiddenClimb: climbHeight > 0
         }
       });
+      createdEntity = created;
       try {
         tempHandles.forEach((hh, idx) => {
           try {
@@ -5877,8 +6233,21 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
           } else {
             editOptions.preview = { enabled: true };
           }
-          if (options?.onVertexSelectDetail) {
-            editOptions.onVertexSelectDetail = options.onVertexSelectDetail;
+          const autoOpts = typeof auto === "object" ? auto : {};
+          if (autoOpts.onVertexSelectDetail) {
+            editOptions.onVertexSelectDetail = autoOpts.onVertexSelectDetail;
+          }
+          if (autoOpts.onVertexDragMoveDetail) {
+            editOptions.onVertexDragMoveDetail = autoOpts.onVertexDragMoveDetail;
+          }
+          if (autoOpts.onVertexDragCompleteDetail) {
+            editOptions.onVertexDragCompleteDetail = autoOpts.onVertexDragCompleteDetail;
+          }
+          if (autoOpts.onVertexInsertDetail) {
+            editOptions.onVertexInsertDetail = autoOpts.onVertexInsertDetail;
+          }
+          if (autoOpts.onVertexDeleteDetail) {
+            editOptions.onVertexDeleteDetail = autoOpts.onVertexDeleteDetail;
           }
           const editSession = startPathEditing(CesiumNS, viewer, created, editOptions);
           if (editSession && options?.onEditingStarted) {
@@ -5904,6 +6273,12 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
         handler?.destroy();
       } catch {
       }
+      if (createdEntity) {
+        try {
+          layer.entities.remove(createdEntity);
+        } catch {
+        }
+      }
     }
   };
 }