@jorgmoritz/gis-manager 0.1.27 → 0.1.29

package/dist/vue/index.js

@@ -1183,6 +1183,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);
       }
@@ -1914,6 +1915,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();
@@ -1968,8 +1971,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 控制器
@@ -2131,30 +2327,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
@@ -4042,6 +4271,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;
@@ -4166,6 +4396,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");
   }
   /**
    * 处理右键点击事件
@@ -4180,12 +4441,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);
@@ -4489,6 +4751,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
+    };
+  }
   /**
    * 🆕 从鼠标事件获取位置
    */
@@ -4514,6 +4788,10 @@ var PathEditingEventHandler = class {
    * 销毁事件处理器
    */
   destroy() {
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = void 0;
+    }
     try {
       this.vertexDragHandler.destroy();
     } catch {
@@ -6396,6 +6674,98 @@ function renderFlightPath(CesiumNS, viewer, options) {
   }
   return entity;
 }
+function renderFlightPathPreview(CesiumNS, viewer, options) {
+  const C = CesiumNS;
+  const entity = renderFlightPath(CesiumNS, viewer, options);
+  const vertexLabelManager = entity._vertexLabelManager;
+  let selectedWaypointIndex = options.initialSelectedIndex ?? null;
+  const polyline = entity.polyline;
+  let positions = [];
+  if (polyline && polyline.positions) {
+    const posValue = polyline.positions.getValue?.(C.JulianDate.now());
+    if (Array.isArray(posValue)) {
+      positions = posValue;
+    }
+  }
+  let waypointDataArray = [];
+  try {
+    const adapterOptions = {
+      CesiumNS,
+      ...options.adapterOptions
+    };
+    const converted = convertSinoflyWayline(options.data, adapterOptions);
+    if (converted && converted.waypointData) {
+      waypointDataArray = [...converted.waypointData].sort((a, b) => a.index - b.index);
+    }
+  } catch (e) {
+    console.warn("[renderFlightPathPreview] \u65E0\u6CD5\u83B7\u53D6\u822A\u70B9\u6570\u636E:", e);
+  }
+  const hasHiddenClimb = entity.properties?._hasHiddenClimb?.getValue?.() ?? false;
+  const hiddenClimbIndex = hasHiddenClimb ? 1 : void 0;
+  const updateWaypointHighlight = (newIndex) => {
+    if (!vertexLabelManager || positions.length === 0) return;
+    const editedIndices = /* @__PURE__ */ new Set();
+    vertexLabelManager.recreateAllLabels(positions, editedIndices, newIndex ?? void 0);
+  };
+  if (selectedWaypointIndex !== null) {
+    updateWaypointHighlight(selectedWaypointIndex);
+  }
+  const handler = new C.ScreenSpaceEventHandler(viewer.scene.canvas);
+  handler.setInputAction((movement) => {
+    const pickedObject = viewer.scene.pick(movement.position);
+    if (C.defined(pickedObject) && pickedObject.id) {
+      const pickedEntity = pickedObject.id;
+      const properties = pickedEntity.properties;
+      if (properties) {
+        const type = properties._type?.getValue?.(C.JulianDate.now());
+        const ownerId = properties._ownerId?.getValue?.(C.JulianDate.now());
+        const vertexIndex = properties._vertexIndex?.getValue?.(C.JulianDate.now());
+        if (type === "vertex-label" && ownerId === entity.id && vertexIndex !== void 0) {
+          let displayIndex = vertexIndex;
+          if (hiddenClimbIndex === 1) {
+            if (vertexIndex >= 2) {
+              displayIndex = vertexIndex - 2;
+            }
+          } else {
+            displayIndex = vertexIndex;
+          }
+          selectedWaypointIndex = vertexIndex;
+          updateWaypointHighlight(selectedWaypointIndex);
+          if (options.onWaypointClick) {
+            const waypointData = waypointDataArray.find((wp) => wp.index === vertexIndex);
+            options.onWaypointClick(displayIndex, waypointData);
+          }
+        }
+      }
+    }
+  }, C.ScreenSpaceEventType.LEFT_CLICK);
+  const controller = {
+    setSelectedWaypoint: (index) => {
+      if (index === null) {
+        selectedWaypointIndex = null;
+        updateWaypointHighlight(null);
+        return;
+      }
+      let actualIndex = index;
+      if (hiddenClimbIndex === 1) {
+        actualIndex = index + 2;
+      }
+      selectedWaypointIndex = actualIndex;
+      updateWaypointHighlight(selectedWaypointIndex);
+    },
+    getSelectedWaypoint: () => {
+      if (selectedWaypointIndex === null) return null;
+      if (hiddenClimbIndex === 1) {
+        return selectedWaypointIndex >= 2 ? selectedWaypointIndex - 2 : null;
+      }
+      return selectedWaypointIndex;
+    },
+    destroy: () => {
+      handler.destroy();
+    }
+  };
+  return { entity, controller };
+}
 
 // src/core/CZMLPathManager.ts
 var _CZMLPathManager = class _CZMLPathManager {
@@ -6479,6 +6849,37 @@ var _CZMLPathManager = class _CZMLPathManager {
   renderFlightPath(options) {
     return renderFlightPath(this.CesiumNS, this.viewer, options);
   }
+  /**
+   * 预览模式渲染飞航路线：支持航点点击高亮
+   * 
+   * 与 renderFlightPath 不同，此方法返回一个控制器对象，支持：
+   * - 航点点击事件回调
+   * - 程序化设置选中航点（高亮显示）
+   * - 列表与地图双向联动
+   * 
+   * @param options 预览选项
+   * @returns 包含实体和控制器的对象
+   * 
+   * @example
+   * ```typescript
+   * const { entity, controller } = pathManager.renderFlightPathPreview({
+   *   data: sinoflyData,
+   *   onWaypointClick: (index, waypoint) => {
+   *     console.log('点击了航点', index, waypoint);
+   *   },
+   *   initialSelectedIndex: 0
+   * });
+   * 
+   * // 程序化设置选中航点
+   * controller.setSelectedWaypoint(2);
+   * 
+   * // 销毁
+   * controller.destroy();
+   * ```
+   */
+  renderFlightPathPreview(options) {
+    return renderFlightPathPreview(this.CesiumNS, this.viewer, options);
+  }
   resolveEntity(entityOrId) {
     return typeof entityOrId === "string" ? this.viewer.entities.getById(entityOrId) : entityOrId;
   }
@@ -9368,6 +9769,20 @@ var CZMLManager = class {
   renderFlightPath(options) {
     return this.pathMgr.renderFlightPath(options);
   }
+  /**
+   * 预览模式渲染飞航路线：支持航点点击高亮
+   * 
+   * 与 renderFlightPath 不同，此方法返回一个控制器对象，支持：
+   * - 航点点击事件回调
+   * - 程序化设置选中航点（高亮显示）
+   * - 列表与地图双向联动
+   * 
+   * @param options 预览选项
+   * @returns 包含实体和控制器的对象
+   */
+  renderFlightPathPreview(options) {
+    return this.pathMgr.renderFlightPathPreview(options);
+  }
   addPathSample(entityOrId, sample) {
     return this.pathMgr.addPathSample(entityOrId, sample);
   }