@jorgmoritz/gis-manager 0.1.21 → 0.1.27

package/dist/vue/index.js

@@ -60,6 +60,8 @@ var CameraEventBus = class {
     __publicField(this, "onPoseChange", new Emitter());
     /** 视锥体形状变化事件 */
     __publicField(this, "onFrustumShapeChange", new Emitter());
+    /** 飞机游标姿态变化事件 */
+    __publicField(this, "onCursorPoseChange", new Emitter());
   }
   /**
    * 清理所有监听器
@@ -68,9 +70,20 @@ var CameraEventBus = class {
     this.onFOVChange.clear();
     this.onPoseChange.clear();
     this.onFrustumShapeChange.clear();
+    this.onCursorPoseChange.clear();
   }
 };
-var globalCameraEventBus = new CameraEventBus();
+var GLOBAL_KEY = "__gisManager_globalCameraEventBus__";
+function getGlobalEventBus() {
+  if (typeof window !== "undefined") {
+    if (!window[GLOBAL_KEY]) {
+      window[GLOBAL_KEY] = new CameraEventBus();
+    }
+    return window[GLOBAL_KEY];
+  }
+  return new CameraEventBus();
+}
+var globalCameraEventBus = getGlobalEventBus();
 
 // src/core/LayerManager.ts
 var layerIdSeq = 0;
@@ -1078,7 +1091,9 @@ var SceneManager = class {
           depth: true,
           stencil: true,
           antialias: true,
-          powerPreference: "high-performance"
+          powerPreference: "high-performance",
+          preserveDrawingBuffer: true
+          // 必需：允许 canvas.toDataURL() 截图
         }
       },
       ...viewerOptions
@@ -1516,8 +1531,8 @@ var CameraFOVController = class {
       if (!this.sliderEl) return;
       const sliderValue = parseFloat(this.sliderEl.value);
       const sliderIndex = this.focalLengthPresets.length - 1 - sliderValue;
-      const zoomMultiplier = this.interpolateZoomMultiplier(sliderIndex);
-      const fov = this.zoomMultiplierToFOV(zoomMultiplier);
+      const focalLength = this.interpolateFocalLength(sliderIndex);
+      const fov = this.focalLengthToFOV(focalLength);
       this.currentFOV = fov;
       this.updateDisplay();
       this.emitChange();
@@ -1525,24 +1540,35 @@ var CameraFOVController = class {
     this.sensorWidth = opts.sensorWidth ?? 36;
     this.focalLengthPresets = opts.focalLengthPresets ?? [112, 56, 14, 7, 3, 1];
     if (opts.minFOV === void 0 || opts.maxFOV === void 0) {
-      const minZoom = Math.min(...this.focalLengthPresets);
-      const maxZoom = Math.max(...this.focalLengthPresets);
-      this.maxFOV = this.zoomMultiplierToFOVDirect(minZoom);
-      this.minFOV = this.zoomMultiplierToFOVDirect(maxZoom);
+      const minFocalLength = Math.min(...this.focalLengthPresets);
+      const maxFocalLength = Math.max(...this.focalLengthPresets);
+      this.maxFOV = this.focalLengthToFOVDirect(minFocalLength);
+      this.minFOV = this.focalLengthToFOVDirect(maxFocalLength);
     } else {
       this.minFOV = opts.minFOV;
       this.maxFOV = opts.maxFOV;
     }
-    this.currentFOV = opts.initialFOV ?? this.zoomMultiplierToFOVDirect(3);
+    this.currentFOV = opts.initialFOV ?? this.focalLengthToFOVDirect(56);
     this.useGlobalEventBus = opts.useGlobalEventBus ?? true;
     this.createUI();
+    this.setupExternalFOVListener();
   }
   /**
-   * 变焦倍数转换为 FOV（度）- 直接计算版本
+   * 🆕 监听外部 FOV 变化事件（来自 UI 面板等），同步更新滑块位置
    */
-  zoomMultiplierToFOVDirect(zoomMultiplier) {
-    const focalLength = zoomMultiplier * this.sensorWidth;
-    const fovRad = 2 * Math.atan(this.sensorWidth / (2 * focalLength));
+  setupExternalFOVListener() {
+    if (!this.useGlobalEventBus) return;
+    globalCameraEventBus.onFOVChange.on((event) => {
+      if (event.source !== "controller") {
+        this.setFOVSilent(event.fov);
+      }
+    });
+  }
+  /**
+   * 焦距转换为 FOV（度）- 直接计算版本
+   */
+  focalLengthToFOVDirect(focalLengthMm) {
+    const fovRad = 2 * Math.atan(this.sensorWidth / (2 * focalLengthMm));
     return fovRad * 180 / Math.PI;
   }
   /**
@@ -1666,7 +1692,7 @@ var CameraFOVController = class {
       `;
       this.focalLengthPresets.forEach((fl) => {
         const marker = document.createElement("div");
-        marker.textContent = `${fl}x`;
+        marker.textContent = `${fl}`;
         marker.style.cssText = `
           cursor: pointer;
           padding: 2px 4px;
@@ -1681,7 +1707,7 @@ var CameraFOVController = class {
           marker.style.background = "transparent";
         });
         marker.addEventListener("click", () => {
-          this.setZoomMultiplier(fl);
+          this.setFocalLength(fl);
         });
         markersContainer.appendChild(marker);
       });
@@ -1694,38 +1720,38 @@ var CameraFOVController = class {
     this.emitChange();
   }
   /**
-   * 根据索引插值计算变焦倍数
+   * 根据索引插值计算焦距值
    */
-  interpolateZoomMultiplier(index) {
+  interpolateFocalLength(index) {
     const clampedIndex = Math.max(0, Math.min(this.focalLengthPresets.length - 1, index));
     if (Number.isInteger(clampedIndex)) {
       return this.focalLengthPresets[clampedIndex];
     }
     const lowerIndex = Math.floor(clampedIndex);
     const upperIndex = Math.ceil(clampedIndex);
-    const lowerZoom = this.focalLengthPresets[lowerIndex];
-    const upperZoom = this.focalLengthPresets[upperIndex];
+    const lowerFL = this.focalLengthPresets[lowerIndex];
+    const upperFL = this.focalLengthPresets[upperIndex];
     const fraction = clampedIndex - lowerIndex;
-    return lowerZoom + (upperZoom - lowerZoom) * fraction;
+    return lowerFL + (upperFL - lowerFL) * fraction;
   }
   /**
-   * 根据变焦倍数计算对应的索引（可以是小数）
+   * 根据焦距值计算对应的索引（可以是小数）
    */
-  getZoomMultiplierIndex(zoomMultiplier) {
-    const minZoom = Math.min(...this.focalLengthPresets);
-    const maxZoom = Math.max(...this.focalLengthPresets);
-    const clampedZoom = Math.max(minZoom, Math.min(maxZoom, zoomMultiplier));
+  getFocalLengthIndex(focalLength) {
+    const minFL = Math.min(...this.focalLengthPresets);
+    const maxFL = Math.max(...this.focalLengthPresets);
+    const clampedFL = Math.max(minFL, Math.min(maxFL, focalLength));
     for (let i = 0; i < this.focalLengthPresets.length - 1; i++) {
       const current = this.focalLengthPresets[i];
       const next = this.focalLengthPresets[i + 1];
-      if (current <= clampedZoom && clampedZoom <= next || current >= clampedZoom && clampedZoom >= next) {
-        const fraction = (clampedZoom - current) / (next - current);
+      if (current <= clampedFL && clampedFL <= next || current >= clampedFL && clampedFL >= next) {
+        const fraction = (clampedFL - current) / (next - current);
         return i + fraction;
       }
     }
     return this.focalLengthPresets.indexOf(
       this.focalLengthPresets.reduce(
-        (prev, curr) => Math.abs(curr - clampedZoom) < Math.abs(prev - clampedZoom) ? curr : prev
+        (prev, curr) => Math.abs(curr - clampedFL) < Math.abs(prev - clampedFL) ? curr : prev
       )
     );
   }
@@ -1734,8 +1760,7 @@ var CameraFOVController = class {
    */
   getClosestPresetIndex(fov) {
     const focalLength = this.fovToFocalLength(fov);
-    const zoomMultiplier = focalLength / this.sensorWidth;
-    const index = this.getZoomMultiplierIndex(zoomMultiplier);
+    const index = this.getFocalLengthIndex(focalLength);
     return this.focalLengthPresets.length - 1 - index;
   }
   /**
@@ -1743,9 +1768,8 @@ var CameraFOVController = class {
    */
   updateDisplay() {
     const focalLength = this.fovToFocalLength(this.currentFOV);
-    const zoomMultiplier = focalLength / this.sensorWidth;
     if (this.labelEl) {
-      this.labelEl.textContent = `\u53D8\u7126 ${zoomMultiplier.toFixed(1)}X`;
+      this.labelEl.textContent = `\u7126\u8DDD ${Math.round(focalLength)}`;
     }
   }
   /**
@@ -1816,6 +1840,18 @@ var CameraFOVController = class {
     this.updateDisplay();
     this.emitChange();
   }
+  /**
+   * 🆕 静默设置 FOV（度）- 只更新滑块位置，不广播事件
+   * 用于响应外部 FOV 变化事件，避免循环广播
+   */
+  setFOVSilent(fovDeg) {
+    this.currentFOV = Math.max(this.minFOV, Math.min(this.maxFOV, fovDeg));
+    if (this.sliderEl) {
+      const index = this.getClosestPresetIndex(this.currentFOV);
+      this.sliderEl.value = String(index);
+    }
+    this.updateDisplay();
+  }
   /**
    * 获取当前 FOV
    */
@@ -2854,11 +2890,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;
       }
@@ -2882,6 +2918,7 @@ var AirplaneCursor = class {
         this.opts?.onPose?.({ ...pose });
         this.viewer.scene?.requestRender?.();
         this.updateFrustum();
+        this.broadcastPoseChange();
       }
       requestAnimationFrame(update);
     };
@@ -2939,9 +2976,15 @@ var AirplaneCursor = class {
     } catch {
     }
   }
-  /** 获取当前姿态（注意：返回的是引用对象，不要在外部直接修改其字段） */
+  /** 获取当前姿态（包含高度信息） */
   getPose() {
-    return this.pose;
+    const C = this.CesiumNS;
+    const cartographic = C.Cartographic.fromCartesian(this.pose.position);
+    const altitude = cartographic ? cartographic.height : 0;
+    return {
+      ...this.pose,
+      altitude
+    };
   }
   /** 获取内部实体（用于拾取识别） */
   getEntity() {
@@ -3001,8 +3044,58 @@ var AirplaneCursor = class {
     } catch {
     }
     this.updateFrustum();
+    this.broadcastPoseChange();
     this.viewer.scene?.requestRender?.();
   }
+  /**
+   * 广播游标姿态变化事件到全局事件总线
+   */
+  broadcastPoseChange() {
+    try {
+      const C = this.CesiumNS;
+      const cartographic = C.Cartographic.fromCartesian(this.pose.position);
+      const altitude = cartographic ? cartographic.height : 0;
+      console.log("[AirplaneCursor] \u{1F4E1} \u5E7F\u64AD\u59FF\u6001\u53D8\u5316:", {
+        heading: this.pose.heading,
+        pitch: this.pose.pitch,
+        altitude
+      });
+      globalCameraEventBus.onCursorPoseChange.emit({
+        position: this.pose.position,
+        heading: this.pose.heading,
+        pitch: this.pose.pitch,
+        roll: this.pose.roll,
+        altitude,
+        source: "cursor"
+      });
+    } catch (e) {
+    }
+  }
+  /**
+   * 模拟按键按下（用于虚拟控制器）
+   * @param key 按键名称 (w/a/s/d/q/e/c/z)
+   * @param duration 按键持续时间（毫秒），默认 100ms
+   */
+  simulateKeyPress(key, duration = 100) {
+    const lowerKey = key.toLowerCase();
+    const keyMap = {
+      "c": "c",
+      // 上升
+      "z": "z"
+      // 下降
+    };
+    const mappedKey = keyMap[lowerKey] || lowerKey;
+    console.log("[AirplaneCursor] \u{1F3AE} simulateKeyPress:", mappedKey, "duration:", duration);
+    console.log("[AirplaneCursor] \u{1F3AE} updateLoopRunning:", this.updateLoopRunning);
+    this.keysPressed.add(mappedKey);
+    if (!this.updateLoopRunning) {
+      console.log("[AirplaneCursor] \u{1F3AE} \u542F\u52A8 updateLoop");
+      this.startUpdateLoop();
+    }
+    setTimeout(() => {
+      this.keysPressed.delete(mappedKey);
+    }, duration);
+  }
   destroy() {
     if (this.destroyed) return;
     this.destroyed = true;
@@ -4832,6 +4925,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,
@@ -4842,6 +4939,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,
@@ -4857,6 +4955,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);
   };
@@ -4887,6 +4987,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);
@@ -4894,6 +4995,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) {
@@ -5016,7 +5119,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) {
@@ -5037,7 +5142,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) {
@@ -5065,6 +5172,31 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
           vertexLabelManager.updateLabelPosition(index, newPosition);
         } catch {
         }
+        if (options?.onVertexDragMoveDetail) {
+          try {
+            let coordinates = { longitude: 0, latitude: 0, height: 0 };
+            try {
+              const cartographic = C.Cartographic.fromCartesian(newPosition);
+              coordinates = {
+                longitude: C.Math.toDegrees(cartographic.longitude),
+                latitude: C.Math.toDegrees(cartographic.latitude),
+                height: cartographic.height
+              };
+            } catch {
+            }
+            const displayNumber = hiddenClimbIndex === 1 && index > 1 ? index - 1 : index;
+            const dragMoveInfo = {
+              index,
+              displayNumber,
+              position: newPosition,
+              coordinates,
+              timestamp: /* @__PURE__ */ new Date()
+            };
+            options.onVertexDragMoveDetail(dragMoveInfo);
+          } catch (error) {
+            console.error("Error in onVertexDragMoveDetail:", error);
+          }
+        }
       },
       onVertexDragEnd: (index, finalPosition) => {
         editedIndices.add(index);
@@ -5092,7 +5224,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) {
@@ -5105,6 +5239,12 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       getAirplaneCursor: () => airplaneCursor,
       getPoseData: () => ({ headings, pitches, rolls, fovs }),
       getEntity: () => entity,
+      /** 模拟按键控制飞机游标（用于虚拟控制器） */
+      simulateKeyPress: (key, duration) => {
+        airplaneCursor?.simulateKeyPress(key, duration);
+      },
+      /** 获取游标当前姿态（包含高度） */
+      getCursorPose: () => airplaneCursor?.getPose(),
       // 🆕 快速编辑回调
       getQuickEditEnabled: () => quickEditEnabled,
       getQuickEditOptions: () => ({
@@ -5115,6 +5255,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 {
@@ -5287,9 +5439,214 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
     /** 🆕 检查快速编辑模式是否启用 */
     isQuickEditEnabled: () => {
       return quickEditEnabled;
+    },
+    // ========================
+    // 🆕 程序化更新方法
+    // ========================
+    /**
+     * 🆕 程序化更新指定航点
+     * @param index 航点索引
+     * @param updates 需要更新的字段
+     * @returns 是否更新成功
+     */
+    updateWaypoint: (index, updates) => {
+      if (index < 0 || index >= positions.length) {
+        console.warn(`[updateWaypoint] Invalid index: ${index}, valid range: 0-${positions.length - 1}`);
+        return false;
+      }
+      try {
+        let positionUpdated = false;
+        if (updates.position) {
+          positions[index] = updates.position;
+          positionUpdated = true;
+        }
+        if (updates.altitude !== void 0 && !updates.position) {
+          const currentPos = positions[index];
+          const cartographic = C.Cartographic.fromCartesian(currentPos);
+          const newPos = C.Cartesian3.fromRadians(
+            cartographic.longitude,
+            cartographic.latitude,
+            updates.altitude
+          );
+          positions[index] = newPos;
+          positionUpdated = true;
+        }
+        if (positionUpdated) {
+          const newPos = positions[index];
+          if (handles[index]) {
+            try {
+              handles[index].position = newPos;
+            } catch {
+            }
+          }
+          try {
+            vertexLabelManager.updateLabelPosition(index, newPos);
+          } catch {
+          }
+          try {
+            createOrUpdateMarkerForIndex(index);
+          } catch {
+          }
+        }
+        if (updates.heading !== void 0) headings[index] = updates.heading;
+        if (updates.pitch !== void 0) pitches[index] = updates.pitch;
+        if (updates.roll !== void 0) rolls[index] = updates.roll;
+        if (updates.fov !== void 0) {
+          fovs[index] = updates.fov;
+          if (index === activeIndex) {
+            globalCameraEventBus.onFOVChange.emit({
+              fov: updates.fov,
+              focalLength: fovToFocalLength(updates.fov),
+              source: "user"
+            });
+          }
+        }
+        if (index === activeIndex && airplaneCursor) {
+          try {
+            airplaneCursor.setPose(
+              positions[index],
+              headings[index] ?? 0,
+              pitches[index] ?? -10,
+              rolls[index] ?? 0
+            );
+          } catch {
+          }
+        }
+        stateManager.persistToEntity(positions, headings, pitches, rolls, fovs);
+        return true;
+      } catch (error) {
+        console.error("[updateWaypoint] Error:", error);
+        return false;
+      }
+    },
+    /**
+     * 🆕 更新航点位置
+     */
+    updateWaypointPosition: function(index, position) {
+      return this.updateWaypoint(index, { position });
+    },
+    /**
+     * 🆕 更新航点高度（仅垂直方向，保持经纬度不变）
+     */
+    updateWaypointAltitude: function(index, altitude) {
+      return this.updateWaypoint(index, { altitude });
+    },
+    /**
+     * 🆕 更新航点偏航角
+     */
+    updateWaypointHeading: function(index, heading) {
+      return this.updateWaypoint(index, { heading });
+    },
+    /**
+     * 🆕 更新航点俯仰角
+     */
+    updateWaypointPitch: function(index, pitch) {
+      return this.updateWaypoint(index, { pitch });
+    },
+    /**
+     * 🆕 更新航点视野角
+     */
+    updateWaypointFov: function(index, fov) {
+      return this.updateWaypoint(index, { fov });
+    },
+    /**
+     * 🆕 批量更新多个航点
+     */
+    batchUpdateWaypoints: function(updates) {
+      let allSuccess = true;
+      for (const { index, data } of updates) {
+        if (!this.updateWaypoint(index, data)) {
+          allSuccess = false;
+        }
+      }
+      return allSuccess;
+    },
+    /**
+     * 🆕 程序化选中指定航点
+     * 将飞机游标移动到指定航点位置，更新选中状态
+     * @param index 航点索引
+     * @returns 是否选中成功
+     */
+    selectVertex: (index) => {
+      if (index < 0 || index >= positions.length) {
+        console.warn(`[selectVertex] Invalid index: ${index}, valid range: 0-${positions.length - 1}`);
+        return false;
+      }
+      try {
+        setActiveIndex(index);
+        return true;
+      } catch (e) {
+        console.error("[selectVertex] Failed to select vertex:", e);
+        return false;
+      }
+    },
+    /**
+     * 🆕 模拟按键控制飞机游标（用于虚拟控制器）
+     * @param key 按键名称 (w/a/s/d/q/e/c/z)
+     * @param duration 按键持续时间（毫秒）
+     */
+    simulateKeyPress: (key, duration) => {
+      airplaneCursor?.simulateKeyPress(key, duration);
+    },
+    /**
+     * 🆕 获取游标当前姿态（包含高度）
+     */
+    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) {
+  const sensorWidth = 36;
+  const fovRad = fovDeg * Math.PI / 180;
+  return sensorWidth / (2 * Math.tan(fovRad / 2));
+}
 
 // src/core/path-manager/ArrowShape.ts
 var ArrowShape = class {
@@ -5458,6 +5815,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;
@@ -5558,6 +5916,7 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
           _hasHiddenClimb: climbHeight > 0
         }
       });
+      createdEntity = created;
       try {
         tempHandles.forEach((hh, idx) => {
           try {
@@ -5594,8 +5953,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) {
@@ -5621,6 +5993,12 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
         handler?.destroy();
       } catch {
       }
+      if (createdEntity) {
+        try {
+          layer.entities.remove(createdEntity);
+        } catch {
+        }
+      }
     }
   };
 }
@@ -5686,7 +6064,6 @@ function parsePoseFromAction(action) {
         fov: parseFloat(numbers[3])
       };
     }
-    console.warn("[sinoflyAdapter] \u65E0\u6CD5\u89E3\u6790 action \u5B57\u6BB5:", action, error);
     return {};
   }
 }
@@ -5704,15 +6081,40 @@ function parseTakeOffRefPoint(takeOffRefPoint, takeOffSecurityHeight, CesiumNS)
   if (!takeOffRefPoint || typeof takeOffRefPoint !== "string" || takeOffRefPoint.trim() === "") {
     return null;
   }
+  const C = CesiumNS;
+  let longitude;
+  let latitude;
+  let height;
+  const trimmed = takeOffRefPoint.trim();
+  if (trimmed.includes(",")) {
+    try {
+      const parts = trimmed.split(",").map((p) => p.trim());
+      if (parts.length >= 2) {
+        latitude = parseFloat(parts[0]);
+        longitude = parseFloat(parts[1]);
+        height = parts.length >= 3 ? parseFloat(parts[2]) : takeOffSecurityHeight;
+        if (isNaN(latitude) || isNaN(longitude) || isNaN(height)) {
+          throw new Error("\u65E0\u6CD5\u89E3\u6790\u9017\u53F7\u5206\u9694\u7684\u5750\u6807\u503C");
+        }
+        const startPosition = C.Cartesian3.fromDegrees(longitude, latitude, height);
+        const climbPosition = C.Cartesian3.fromDegrees(
+          longitude,
+          latitude,
+          height + takeOffSecurityHeight
+        );
+        return {
+          startPosition,
+          climbPosition
+        };
+      }
+    } catch (error) {
+    }
+  }
   try {
     const parsed = JSON.parse(takeOffRefPoint);
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
-    const C = CesiumNS;
-    let longitude;
-    let latitude;
-    let height;
     if (typeof parsed.longitude === "number") {
       longitude = parsed.longitude;
     } else if (typeof parsed.lon === "number") {
@@ -5743,7 +6145,6 @@ function parseTakeOffRefPoint(takeOffRefPoint, takeOffSecurityHeight, CesiumNS)
       climbPosition
     };
   } catch (error) {
-    console.warn("[sinoflyAdapter] \u65E0\u6CD5\u89E3\u6790 takeOffRefPoint:", takeOffRefPoint, error);
     return null;
   }
 }
@@ -5765,16 +6166,10 @@ function convertSinoflyWayline(data, options) {
   if (!data.waypointInfo || !Array.isArray(data.waypointInfo)) {
     throw new Error("[sinoflyAdapter] waypointInfo \u5FC5\u987B\u662F\u6570\u7EC4");
   }
-  if (data.waypointInfo.length === 0) {
-    console.warn("[sinoflyAdapter] waypointInfo \u6570\u7EC4\u4E3A\u7A7A\uFF0C\u5C06\u8FD4\u56DE\u7A7A\u7684\u822A\u70B9\u6570\u636E");
-  }
+  if (data.waypointInfo.length === 0) ;
   if (data.waylineId === void 0 || data.waylineId === null) {
     throw new Error("[sinoflyAdapter] waylineId \u4E0D\u80FD\u4E3A\u7A7A");
   }
-  console.log(`[sinoflyAdapter] \u5F00\u59CB\u8F6C\u6362\u822A\u7EBF ${data.waylineId}\uFF0C\u5305\u542B ${data.waypointInfo.length} \u4E2A\u822A\u70B9`);
-  if (data.takeOffRefPoint) {
-    console.log(`[sinoflyAdapter] \u68C0\u6D4B\u5230 takeOffRefPoint: ${data.takeOffRefPoint}`);
-  }
   const takeOffInfo = parseTakeOffRefPoint(
     data.takeOffRefPoint,
     data.takeOffSecurityHeight,
@@ -5839,7 +6234,6 @@ function convertSinoflyWayline(data, options) {
           if (poseFromAction.roll !== void 0) roll = poseFromAction.roll;
           if (poseFromAction.fov !== void 0) fov = poseFromAction.fov;
         } catch (actionError) {
-          console.warn(`[sinoflyAdapter] \u822A\u70B9 ${idx} action \u89E3\u6790\u5931\u8D25:`, actionError);
         }
       }
       return {
@@ -5852,7 +6246,6 @@ function convertSinoflyWayline(data, options) {
         // 重新分配 index，从 waypointStartIndex 开始
       };
     } catch (error) {
-      console.error(`[sinoflyAdapter] \u822A\u70B9 ${idx} \u8F6C\u6362\u5931\u8D25:`, error);
       throw new Error(`\u822A\u70B9 ${idx} \u8F6C\u6362\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
@@ -5860,7 +6253,6 @@ function convertSinoflyWayline(data, options) {
   if (!Array.isArray(waypointData)) {
     throw new Error("[sinoflyAdapter] waypointData \u4E0D\u662F\u6570\u7EC4");
   }
-  console.log(`[sinoflyAdapter] \u8F6C\u6362\u5B8C\u6210\uFF0C\u5171\u751F\u6210 ${waypointData.length} \u4E2A\u822A\u70B9`);
   const metadata = {
     waylineId: data.waylineId,
     waylineType: data.waylineType,