@jorgmoritz/gis-manager 0.1.41 → 0.1.42

package/dist/vue/index.cjs

@@ -373,6 +373,287 @@ var LayerManager = class {
   getTileset(id) {
     return this.tilesetIdMap.get(id);
   }
+  /**
+   * 从配置加载地图图层（正射影像、中文注记、地形）
+   * @param config 地图图层配置
+   * @param options 可选配置
+   * @returns 加载结果
+   */
+  async loadMapLayersFromConfig(config, options) {
+    const result = {
+      success: true,
+      errors: []
+    };
+    const {
+      tiandituToken = "f44fcec420c3eb1c56656e9a22dabb17",
+      subdomains = ["0", "1", "2", "3", "4", "5", "6", "7"],
+      maximumLevel = 18
+    } = options || {};
+    const C = this.CesiumNS;
+    const { imgUrl, ciaUrl, terrUrl } = config;
+    if (imgUrl) {
+      try {
+        const imageryProvider = this.createImageryProviderFromUrl(imgUrl, {
+          tiandituToken,
+          subdomains,
+          maximumLevel
+        });
+        if (imageryProvider) {
+          result.imageryLayer = this.viewer.imageryLayers.addImageryProvider(imageryProvider);
+          console.log("[LayerManager] \u6B63\u5C04\u5F71\u50CF\u52A0\u8F7D\u6210\u529F:", imgUrl);
+        }
+      } catch (error) {
+        const errMsg = `\u6B63\u5C04\u5F71\u50CF\u52A0\u8F7D\u5931\u8D25: ${error}`;
+        console.error("[LayerManager]", errMsg);
+        result.errors.push(errMsg);
+      }
+    }
+    if (ciaUrl) {
+      try {
+        const ciaProvider = this.createImageryProviderFromUrl(ciaUrl, {
+          tiandituToken,
+          subdomains,
+          maximumLevel
+        });
+        if (ciaProvider) {
+          result.annotationLayer = this.viewer.imageryLayers.addImageryProvider(ciaProvider);
+          console.log("[LayerManager] \u4E2D\u6587\u6CE8\u8BB0\u52A0\u8F7D\u6210\u529F:", ciaUrl);
+        }
+      } catch (error) {
+        const errMsg = `\u4E2D\u6587\u6CE8\u8BB0\u52A0\u8F7D\u5931\u8D25: ${error}`;
+        console.error("[LayerManager]", errMsg);
+        result.errors.push(errMsg);
+      }
+    }
+    if (terrUrl) {
+      try {
+        const terrainProvider = await C.CesiumTerrainProvider.fromUrl(terrUrl);
+        this.viewer.terrainProvider = terrainProvider;
+        result.terrainProvider = terrainProvider;
+        console.log("[LayerManager] \u5730\u5F62\u6570\u636E\u52A0\u8F7D\u6210\u529F:", terrUrl);
+      } catch (error) {
+        const errMsg = `\u5730\u5F62\u6570\u636E\u52A0\u8F7D\u5931\u8D25: ${error}`;
+        console.warn("[LayerManager]", errMsg);
+        result.errors.push(errMsg);
+      }
+    }
+    result.success = result.errors.length === 0;
+    return result;
+  }
+  /**
+   * 根据 URL 格式自动创建合适的 ImageryProvider
+   * @param url 影像 URL
+   * @param options 配置选项
+   */
+  createImageryProviderFromUrl(url, options) {
+    const C = this.CesiumNS;
+    const { tiandituToken, subdomains, maximumLevel } = options;
+    if (url.includes("{z}") || url.includes("{TileMatrix}")) {
+      return new C.UrlTemplateImageryProvider({
+        url,
+        subdomains,
+        tilingScheme: new C.WebMercatorTilingScheme(),
+        maximumLevel
+      });
+    }
+    if (url.includes("wmts")) {
+      const tkMatch = url.match(/tk=([^&]+)/);
+      const tk = tkMatch ? tkMatch[1] : tiandituToken;
+      return new C.WebMapTileServiceImageryProvider({
+        url: `https://t{s}.tianditu.gov.cn/img_w/wmts?tk=${tk}`,
+        subdomains,
+        layer: "img",
+        style: "default",
+        tileMatrixSetID: "w",
+        format: "image/jpeg",
+        tilingScheme: new C.WebMercatorTilingScheme(),
+        maximumLevel
+      });
+    }
+    return new C.UrlTemplateImageryProvider({
+      url,
+      subdomains,
+      tilingScheme: new C.WebMercatorTilingScheme(),
+      maximumLevel
+    });
+  }
+  /**
+   * 从 SliceJson 配置加载 TIF 切片数据（DOM 正射影像或 Terrain 地形）
+   * @param sliceJsonData JSON 字符串或已解析的对象
+   * @param options 加载选项
+   * @returns 加载结果
+   */
+  async loadFromSliceJson(sliceJsonData, options) {
+    const { layerId, flyTo = true, flyDuration = 2, opacity = 1 } = options || {};
+    let data;
+    try {
+      data = typeof sliceJsonData === "string" ? JSON.parse(sliceJsonData) : sliceJsonData;
+    } catch (error) {
+      return {
+        success: false,
+        type: "dom",
+        data: {},
+        error: `JSON \u89E3\u6790\u5931\u8D25: ${error}`
+      };
+    }
+    if (!data || !data.type || !data.urlroot) {
+      return {
+        success: false,
+        type: data?.type || "dom",
+        data: data || {},
+        error: "\u65E0\u6548\u7684 SliceJson \u6570\u636E\uFF1A\u7F3A\u5C11 type \u6216 urlroot"
+      };
+    }
+    if (data.type === "dom") {
+      return this.loadDomFromSliceJson(data, { layerId, flyTo, flyDuration, opacity });
+    } else if (data.type === "terrain") {
+      return this.loadTerrainFromSliceJson(data, { flyTo, flyDuration });
+    } else {
+      return {
+        success: false,
+        type: data.type,
+        data,
+        error: `\u4E0D\u652F\u6301\u7684\u6570\u636E\u7C7B\u578B: ${data.type}`
+      };
+    }
+  }
+  /**
+   * 加载 DOM 正射影像
+   */
+  async loadDomFromSliceJson(data, options) {
+    const { layerId, flyTo, flyDuration, opacity } = options;
+    const C = this.CesiumNS;
+    try {
+      const url = `${data.urlroot}/{z}/{x}/{reverseY}.png`;
+      let bounds = data.bounds;
+      if (bounds && bounds.length >= 4) {
+        if (Math.abs(bounds[1]) > 90 && Math.abs(bounds[2]) <= 90) {
+          bounds = [bounds[0], bounds[2], bounds[1], bounds[3]];
+        }
+      }
+      const rectangle = bounds ? C.Rectangle.fromDegrees(bounds[0], bounds[1], bounds[2], bounds[3]) : void 0;
+      const provider = new C.UrlTemplateImageryProvider({
+        url,
+        minimumLevel: data.minZoom,
+        maximumLevel: data.maxZoom,
+        rectangle
+      });
+      const layer = this.viewer.imageryLayers.addImageryProvider(provider);
+      layer.alpha = opacity;
+      const id = layerId || `slice_dom_${++layerIdSeq}`;
+      layer._customId = id;
+      this.imageryIdMap.set(id, layer);
+      const handle = { id, type: "imagery", dispose: () => this.remove(id) };
+      this.events.emit({ added: handle });
+      console.log("[LayerManager] DOM \u6B63\u5C04\u5F71\u50CF\u52A0\u8F7D\u6210\u529F:", data.urlroot);
+      if (flyTo) {
+        await this.flyToSliceJsonTarget(data, flyDuration);
+      }
+      return {
+        success: true,
+        type: "dom",
+        handle,
+        imageryLayer: layer,
+        data
+      };
+    } catch (error) {
+      const errMsg = `DOM \u52A0\u8F7D\u5931\u8D25: ${error}`;
+      console.error("[LayerManager]", errMsg);
+      return {
+        success: false,
+        type: "dom",
+        data,
+        error: errMsg
+      };
+    }
+  }
+  /**
+   * 加载 Terrain 地形数据
+   */
+  async loadTerrainFromSliceJson(data, options) {
+    const { flyTo, flyDuration } = options;
+    const C = this.CesiumNS;
+    try {
+      const timestamp = Date.now();
+      const terrainUrl = `${data.urlroot}?t=${timestamp}`;
+      const terrainProvider = await C.CesiumTerrainProvider.fromUrl(terrainUrl, {
+        requestVertexNormals: true,
+        requestWaterMask: true
+      });
+      this.viewer.terrainProvider = terrainProvider;
+      this.terrainId = `slice_ter_${++layerIdSeq}`;
+      console.log("[LayerManager] Terrain \u5730\u5F62\u52A0\u8F7D\u6210\u529F:", data.urlroot);
+      if (flyTo) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        await this.flyToSliceJsonTarget(data, flyDuration, true);
+      }
+      return {
+        success: true,
+        type: "terrain",
+        terrainProvider,
+        data
+      };
+    } catch (error) {
+      const errMsg = `Terrain \u52A0\u8F7D\u5931\u8D25: ${error}`;
+      console.error("[LayerManager]", errMsg);
+      return {
+        success: false,
+        type: "terrain",
+        data,
+        error: errMsg
+      };
+    }
+  }
+  /**
+   * 飞行到 SliceJson 数据的目标位置
+   */
+  async flyToSliceJsonTarget(data, duration, isVertical = false) {
+    const C = this.CesiumNS;
+    let centerLon;
+    let centerLat;
+    let cameraHeight = 2e3;
+    if (data.center && data.center.length >= 2 && (data.center[0] !== 0 || data.center[1] !== 0)) {
+      centerLon = data.center[0];
+      centerLat = data.center[1];
+    }
+    if (data.bounds && data.bounds.length >= 4) {
+      const bounds = data.bounds;
+      if (centerLon === void 0 || centerLat === void 0) {
+        centerLon = (bounds[0] + bounds[2]) / 2;
+        centerLat = (bounds[1] + bounds[3]) / 2;
+      }
+      const lonSpan = Math.abs(bounds[2] - bounds[0]);
+      const latSpan = Math.abs(bounds[3] - bounds[1]);
+      const maxSpan = Math.max(lonSpan, latSpan);
+      const heightMultiplier = isVertical ? 2 : 0.8;
+      cameraHeight = Math.max(maxSpan * 111e3 * heightMultiplier, 500);
+    }
+    if (centerLon === void 0 || centerLat === void 0) {
+      console.warn("[LayerManager] \u65E0\u6CD5\u83B7\u53D6\u6709\u6548\u7684\u4E2D\u5FC3\u70B9");
+      return;
+    }
+    let terrainHeight = 0;
+    try {
+      const terrainProvider = this.viewer.terrainProvider;
+      if (terrainProvider && !(terrainProvider instanceof C.EllipsoidTerrainProvider)) {
+        const positions = [C.Cartographic.fromDegrees(centerLon, centerLat)];
+        const sampledPositions = await C.sampleTerrainMostDetailed(terrainProvider, positions);
+        terrainHeight = sampledPositions[0]?.height || 0;
+      }
+    } catch (error) {
+      console.warn("[LayerManager] \u5730\u5F62\u91C7\u6837\u5931\u8D25:", error);
+    }
+    const finalHeight = terrainHeight + cameraHeight;
+    this.viewer.camera.flyTo({
+      destination: C.Cartesian3.fromDegrees(centerLon, centerLat, finalHeight),
+      orientation: {
+        heading: C.Math.toRadians(0),
+        pitch: C.Math.toRadians(isVertical ? -90 : -45),
+        roll: 0
+      },
+      duration
+    });
+  }
 };
 
 // src/core/toggle2D3D.ts
@@ -537,6 +818,65 @@ function toggle2D3D(ctx, options) {
   scene.requestRender?.();
 }
 
+// src/utils/GeoBounds.ts
+function calculateGeoBounds(points) {
+  if (!points || points.length === 0) {
+    return null;
+  }
+  let minLon = Infinity;
+  let maxLon = -Infinity;
+  let minLat = Infinity;
+  let maxLat = -Infinity;
+  let minAlt;
+  let maxAlt;
+  points.forEach((point) => {
+    minLon = Math.min(minLon, point.lon);
+    maxLon = Math.max(maxLon, point.lon);
+    minLat = Math.min(minLat, point.lat);
+    maxLat = Math.max(maxLat, point.lat);
+    if (point.alt !== void 0) {
+      if (minAlt === void 0 || point.alt < minAlt) {
+        minAlt = point.alt;
+      }
+      if (maxAlt === void 0 || point.alt > maxAlt) {
+        maxAlt = point.alt;
+      }
+    }
+  });
+  return {
+    west: minLon,
+    east: maxLon,
+    south: minLat,
+    north: maxLat,
+    centerLon: (minLon + maxLon) / 2,
+    centerLat: (minLat + maxLat) / 2,
+    width: maxLon - minLon,
+    height: maxLat - minLat,
+    minAlt,
+    maxAlt
+  };
+}
+function expandBounds(bounds, padding = 0.1) {
+  const lonPadding = bounds.width * padding;
+  const latPadding = bounds.height * padding;
+  const west = bounds.west - lonPadding;
+  const east = bounds.east + lonPadding;
+  const south = bounds.south - latPadding;
+  const north = bounds.north + latPadding;
+  return {
+    west,
+    east,
+    south,
+    north,
+    centerLon: (west + east) / 2,
+    centerLat: (south + north) / 2,
+    width: east - west,
+    height: north - south,
+    minAlt: bounds.minAlt,
+    maxAlt: bounds.maxAlt
+  };
+}
+
 // src/core/CameraManager.ts
 var CameraManager = class {
   constructor(CesiumNS, viewer) {
@@ -625,12 +965,6 @@ var CameraManager = class {
       options
     );
   }
-  /**
-   * @deprecated Use toggle2D3D instead.
-   */
-  toggleBirdsEye3D(options) {
-    this.toggle2D3D(options);
-  }
   /**
    * 切换鸟瞰视角（垂直俯视）
    * 在当前3D场景中切换到垂直向下的俯视角度，并可选择使用正交投影
@@ -829,26 +1163,6 @@ var CameraManager = class {
     const { destination, heading = 0, pitch = -Math.PI / 4, roll = 0 } = view;
     this.viewer.camera.setView({ destination, orientation: { heading, pitch, roll } });
   }
-  // Debug helper: move camera to Chengdu, Sichuan
-  moveToChengdu() {
-    const lon = 104.0665;
-    const lat = 30.5728;
-    const height = 2e3;
-    const dest = this.CesiumNS.Cartesian3.fromDegrees(lon, lat, height);
-    this.viewer.trackedEntity = void 0;
-    this.viewer.camera.lookAtTransform(this.CesiumNS.Matrix4.IDENTITY);
-    this.viewer.camera.setView({
-      destination: dest,
-      orientation: { heading: 0, pitch: -0.8, roll: 0 }
-    });
-  }
-  isitwork() {
-    console.log("isitwork!!!!!!!!", this.viewer);
-    console.log("isitwork cesium!!!!!!!!", this.CesiumNS);
-    this.viewer.camera.setView({
-      destination: this.CesiumNS.Cartesian3.fromDegrees(-117.16, 32.71, 15e3)
-    });
-  }
   setViewEasy(args) {
     const parsed = this.parseLonLat(args.destination);
     const lon = parsed.lon;
@@ -1051,6 +1365,241 @@ var CameraManager = class {
       });
     });
   }
+  // ==================== 截图相关方法 ====================
+  /**
+   * 飞行到边界框位置（用于截图）
+   * 根据航点计算边界框，并将相机移动到合适位置以覆盖整个区域
+   *
+   * @param waypoints 航点数组
+   * @param options 配置选项
+   * @returns 计算出的相机高度
+   *
+   * @example
+   * ```typescript
+   * const waypoints = [
+   *   { lon: 104.0, lat: 30.5 },
+   *   { lon: 104.1, lat: 30.6 },
+   * ];
+   * await cameraManager.flyToBoundsForScreenshot(waypoints, { topDown: true });
+   * ```
+   */
+  flyToBoundsForScreenshot(waypoints, options) {
+    const bounds = calculateGeoBounds(waypoints);
+    if (!bounds) return null;
+    const {
+      padding = 0.3,
+      topDown = true,
+      duration = 0,
+      heightMultiplier = 1.05
+    } = options || {};
+    const C = this.CesiumNS;
+    const camera = this.viewer.camera;
+    const scene = this.viewer.scene;
+    const expandedBounds = expandBounds(bounds, padding);
+    const rectangle = C.Rectangle.fromDegrees(
+      expandedBounds.west,
+      expandedBounds.south,
+      expandedBounds.east,
+      expandedBounds.north
+    );
+    const cartographicCenter = C.Rectangle.center(rectangle);
+    const canvas = scene.canvas;
+    const aspectRatio = canvas.width / canvas.height;
+    const earthRadius = 6371e3;
+    const rectWidth = rectangle.width * earthRadius * Math.cos(cartographicCenter.latitude);
+    const rectHeight = rectangle.height * earthRadius;
+    const frustum = camera.frustum;
+    const fovy = frustum.fovy || frustum.fov || C.Math.toRadians(60);
+    const fovx = 2 * Math.atan(Math.tan(fovy / 2) * aspectRatio);
+    const altitudeForHeight = rectHeight / 2 / Math.tan(fovy / 2);
+    const altitudeForWidth = rectWidth / 2 / Math.tan(fovx / 2);
+    const relativeAltitude = Math.max(altitudeForHeight, altitudeForWidth, 500) * heightMultiplier;
+    const maxWaypointAlt = bounds.maxAlt ?? 0;
+    const finalAltitude = maxWaypointAlt + relativeAltitude;
+    console.log("[CameraManager] \u822A\u70B9\u6700\u5927\u6D77\u62D4:", maxWaypointAlt, "\u76F8\u5BF9\u9AD8\u5EA6:", relativeAltitude, "\u6700\u7EC8\u76F8\u673A\u9AD8\u5EA6:", finalAltitude);
+    const destination = C.Cartesian3.fromRadians(
+      cartographicCenter.longitude,
+      cartographicCenter.latitude,
+      finalAltitude
+    );
+    const orientation = topDown ? { heading: 0, pitch: C.Math.toRadians(-90), roll: 0 } : { heading: 0, pitch: C.Math.toRadians(-45), roll: 0 };
+    if (duration > 0) {
+      camera.flyTo({ destination, orientation, duration });
+    } else {
+      camera.setView({ destination, orientation });
+    }
+    return finalAltitude;
+  }
+  /**
+   * 对当前 Cesium 场景进行截图
+   *
+   * @param options 截图选项
+   * @returns 截图结果，包含 dataUrl、blob、file
+   *
+   * @example
+   * ```typescript
+   * const result = cameraManager.captureScreenshot();
+   * console.log(result.dataUrl); // base64 图片
+   * ```
+   */
+  captureScreenshot(options) {
+    const { format = "image/png", quality = 0.92, fileName } = options || {};
+    if (!this.viewer?.canvas) {
+      throw new Error("\u65E0\u6548\u7684 Cesium Viewer \u5B9E\u4F8B\u6216 canvas \u4E0D\u5B58\u5728");
+    }
+    this.viewer.render();
+    const canvas = this.viewer.canvas;
+    const dataUrl = canvas.toDataURL(format, quality);
+    const blob = this.dataURLtoBlob(dataUrl);
+    const finalFileName = fileName || this.generateScreenshotFileName(format);
+    const file = new File([blob], finalFileName, { type: format });
+    return { dataUrl, blob, file };
+  }
+  /**
+   * 调整视角并截图（异步）
+   * 根据航点自动调整相机位置，等待渲染完成后截图
+   *
+   * @param options 截图选项
+   * @returns 截图结果
+   *
+   * @example
+   * ```typescript
+   * const waypoints = [
+   *   { lon: 104.0, lat: 30.5 },
+   *   { lon: 104.1, lat: 30.6 },
+   * ];
+   * const result = await cameraManager.captureScreenshotWithView({
+   *   waypoints,
+   *   topDown: true,
+   *   padding: 0.3,
+   * });
+   * ```
+   */
+  async captureScreenshotWithView(options) {
+    const {
+      format = "image/png",
+      quality = 0.92,
+      fileName,
+      waypoints,
+      topDown = true,
+      padding = 0.3,
+      restoreCamera = true,
+      renderDelay = 2e3
+    } = options || {};
+    if (!this.viewer?.scene) {
+      throw new Error("\u65E0\u6548\u7684 Cesium Viewer \u5B9E\u4F8B");
+    }
+    const scene = this.viewer.scene;
+    const camera = this.viewer.camera;
+    const originalPosition = camera.position.clone();
+    const originalHeading = camera.heading;
+    const originalPitch = camera.pitch;
+    const originalRoll = camera.roll;
+    try {
+      if (waypoints && waypoints.length > 0) {
+        console.log("[CameraManager] \u5F00\u59CB\u8C03\u6574\u76F8\u673A\u4F4D\u7F6E\uFF0C\u822A\u70B9\u6570\u91CF:", waypoints.length);
+        const altitude = this.flyToBoundsForScreenshot(waypoints, { padding, topDown, duration: 0 });
+        console.log("[CameraManager] \u8BA1\u7B97\u7684\u76F8\u673A\u9AD8\u5EA6:", altitude);
+        scene.requestRender();
+        await this.waitForAnimationFrame();
+        console.log("[CameraManager] \u7B49\u5F85\u74E6\u7247\u52A0\u8F7D (" + renderDelay + "ms)...");
+        await this.delay(renderDelay);
+        for (let i = 0; i < 20; i++) {
+          scene.requestRender();
+          await this.waitForAnimationFrame();
+          if (i % 5 === 4) {
+            await this.delay(100);
+          }
+        }
+        console.log("[CameraManager] \u7B49\u5F85\u5B8C\u6210\uFF0C\u51C6\u5907\u622A\u56FE");
+      }
+      console.log("[CameraManager] \u5F00\u59CB\u622A\u56FE...");
+      const result = await this.captureAfterRender({ format, quality, fileName });
+      console.log("[CameraManager] \u622A\u56FE\u5B8C\u6210");
+      if (restoreCamera && waypoints && waypoints.length > 0) {
+        camera.setView({
+          destination: originalPosition,
+          orientation: {
+            heading: originalHeading,
+            pitch: originalPitch,
+            roll: originalRoll
+          }
+        });
+      }
+      return result;
+    } catch (error) {
+      console.error("[CameraManager] \u622A\u56FE\u5931\u8D25:", error);
+      if (restoreCamera) {
+        camera.setView({
+          destination: originalPosition,
+          orientation: {
+            heading: originalHeading,
+            pitch: originalPitch,
+            roll: originalRoll
+          }
+        });
+      }
+      throw error;
+    }
+  }
+  /**
+   * 等待渲染完成后截图
+   */
+  captureAfterRender(options) {
+    return new Promise((resolve, reject) => {
+      const { format = "image/png", quality = 0.92, fileName } = options;
+      const scene = this.viewer.scene;
+      const removeCallback = scene.postRender.addEventListener(() => {
+        removeCallback();
+        try {
+          const canvas = scene.canvas;
+          const dataUrl = canvas.toDataURL(format, quality);
+          const blob = this.dataURLtoBlob(dataUrl);
+          const finalFileName = fileName || this.generateScreenshotFileName(format);
+          const file = new File([blob], finalFileName, { type: format });
+          resolve({ dataUrl, blob, file });
+        } catch (error) {
+          reject(error);
+        }
+      });
+      scene.requestRender();
+    });
+  }
+  /**
+   * 将 Base64 DataURL 转换为 Blob
+   */
+  dataURLtoBlob(dataUrl) {
+    const arr = dataUrl.split(",");
+    const mimeMatch = arr[0].match(/:(.*?);/);
+    const mime = mimeMatch ? mimeMatch[1] : "image/png";
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+    return new Blob([u8arr], { type: mime });
+  }
+  /**
+   * 生成截图文件名
+   */
+  generateScreenshotFileName(format) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const ext = format === "image/jpeg" ? "jpg" : format === "image/webp" ? "webp" : "png";
+    return `screenshot_${timestamp}.${ext}`;
+  }
+  /**
+   * 延迟工具函数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 等待下一个动画帧
+   */
+  waitForAnimationFrame() {
+    return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+  }
 };
 
 // src/core/SceneManager.ts
@@ -3535,6 +4084,28 @@ var VertexLabelManager = class {
       }
       if (this.labels[index]) {
         this.layer.entities.remove(this.labels[index]);
+        this.labels[index] = void 0;
+      }
+      try {
+        const entitiesToRemove = [];
+        const allEntities = this.layer.entities.values;
+        for (let i = 0; i < allEntities.length; i++) {
+          const entity = allEntities[i];
+          try {
+            const props = entity.properties;
+            const type = props?._type?.getValue?.() ?? props?._type;
+            const ownerId = props?._ownerId?.getValue?.() ?? props?._ownerId;
+            const vertexIndex = props?._vertexIndex?.getValue?.() ?? props?._vertexIndex;
+            if (type === "vertex-label" && ownerId === this.ownerId && vertexIndex === index) {
+              entitiesToRemove.push(entity);
+            }
+          } catch {
+          }
+        }
+        for (const entity of entitiesToRemove) {
+          this.layer.entities.remove(entity);
+        }
+      } catch {
       }
       this.labels[index] = this.createLabel(position, index, state);
     } catch (e) {
@@ -3552,8 +4123,8 @@ var VertexLabelManager = class {
         return;
       }
       const label = this.labels[index];
-      if (label && label.position) {
-        label.position.setValue(position);
+      if (label) {
+        label.position = position;
       }
     } catch (e) {
       console.error("Failed to update vertex label position:", e);
@@ -3561,12 +4132,11 @@ var VertexLabelManager = class {
   }
   /**
    * 插入新标签（在指定索引处）
+   * 注意：此方法只更新内部数组，调用方需要随后调用 recreateAllLabels() 来重建所有标签
    */
   insertLabel(insertAt, position, state = "normal") {
     try {
-      const newLabel = this.createLabel(position, insertAt, state);
-      this.labels.splice(insertAt, 0, newLabel);
-      this.recreateAllLabels();
+      this.labels.splice(insertAt, 0, void 0);
     } catch (e) {
       console.error("Failed to insert vertex label:", e);
     }
@@ -3596,6 +4166,27 @@ var VertexLabelManager = class {
           this.layer.entities.remove(this.labels[i]);
         }
       }
+      try {
+        const entitiesToRemove = [];
+        const allEntities = this.layer.entities.values;
+        for (let i = 0; i < allEntities.length; i++) {
+          const entity = allEntities[i];
+          try {
+            const props = entity.properties;
+            const type = props?._type?.getValue?.() ?? props?._type;
+            const ownerId = props?._ownerId?.getValue?.() ?? props?._ownerId;
+            if (type === "vertex-label" && ownerId === this.ownerId) {
+              entitiesToRemove.push(entity);
+            }
+          } catch {
+          }
+        }
+        for (const entity of entitiesToRemove) {
+          this.layer.entities.remove(entity);
+        }
+      } catch {
+      }
+      this.labels = [];
       if (positions) {
         for (let i = 0; i < positions.length; i++) {
           const isEdited = editedIndices?.has(i) ?? false;
@@ -3624,6 +4215,26 @@ var VertexLabelManager = class {
           this.layer.entities.remove(label);
         }
       });
+      try {
+        const entitiesToRemove = [];
+        const allEntities = this.layer.entities.values;
+        for (let i = 0; i < allEntities.length; i++) {
+          const entity = allEntities[i];
+          try {
+            const props = entity.properties;
+            const type = props?._type?.getValue?.() ?? props?._type;
+            const ownerId = props?._ownerId?.getValue?.() ?? props?._ownerId;
+            if (type === "vertex-label" && ownerId === this.ownerId) {
+              entitiesToRemove.push(entity);
+            }
+          } catch {
+          }
+        }
+        for (const entity of entitiesToRemove) {
+          this.layer.entities.remove(entity);
+        }
+      } catch {
+      }
       this.labels = [];
     } catch (e) {
       console.error("Failed to destroy vertex labels:", e);
@@ -4254,7 +4865,7 @@ var VertexDragHandler = class {
   }
 };
 
-// src/core/path-manager/utils/TerrainHeightQuery.ts
+// src/utils/TerrainHeightQuery.ts
 async function queryTerrainHeights(CesiumNS, viewer, positions) {
   const C = CesiumNS;
   if (!positions || positions.length === 0) {
@@ -6179,15 +6790,15 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
               } catch {
               }
             }
-            try {
-              vertexLabelManager.updateLabelPosition(i, newPosition);
-            } catch {
-            }
             try {
               createOrUpdateMarkerForIndex(i);
             } catch {
             }
           }
+          try {
+            vertexLabelManager.recreateAllLabels(positions, editedIndices, activeIndex);
+          } catch {
+          }
           currentAltitudeMode = newMode;
           quickEditOptions.altitudeMode = newMode;
           try {