@jorgmoritz/gis-manager 0.1.36 → 0.1.37

package/dist/index.cjs

@@ -2633,7 +2633,7 @@ var FrustumPyramid = class {
   showAt(apex, headingDeg, pitchDeg = 0, rollDeg = 0, fovDeg, lengthOverride) {
     if (this.destroyed) return;
     const C = this.CesiumNS;
-    const length = Math.max(1, lengthOverride ?? this.opts.length ?? 1e3);
+    const length = Math.max(1, lengthOverride ?? this.opts.length ?? 500);
     const lakeEdge = this.opts.color ?? C.Color.fromCssColorString("#1e90ff");
     const alpha = this.opts.fillAlpha ?? 0.25;
     const lakeFill = (this.opts.fillColor ?? C.Color.fromCssColorString("#1e90ff")).withAlpha(alpha);
@@ -2816,8 +2816,6 @@ var AirplaneCursor = class {
     __publicField(this, "angleStep");
     /** 加速倍率（按住 Shift 生效） */
     __publicField(this, "fastFactor");
-    /** 最小高度（米） */
-    __publicField(this, "minHeight");
     /** 外部传入的行为配置与回调 */
     __publicField(this, "opts");
     // 使用内联的 _FrustumPyramid
@@ -2845,7 +2843,6 @@ var AirplaneCursor = class {
     this.step = opts.stepMeters ?? 2;
     this.angleStep = opts.angleStepDeg ?? 1;
     this.fastFactor = opts.fastFactor ?? 5;
-    this.minHeight = opts.minHeight ?? 0;
     this.currentFOV = opts.fovDeg ?? 50;
     this.ensureEntity(opts.color ?? C.Color.CYAN.withAlpha(0.9));
     this.attachKeyboard(opts);
@@ -3070,11 +3067,8 @@ var AirplaneCursor = class {
       }
       if (this.keysPressed.has("z")) {
         const newPos = addVec(pose.position, C.Cartesian3.multiplyByScalar(u3, -step, new C.Cartesian3()));
-        const newCarto = C.Cartographic.fromCartesian(newPos);
-        if (newCarto && newCarto.height >= this.minHeight) {
-          setPos(newPos);
-          moved = true;
-        }
+        setPos(newPos);
+        moved = true;
       }
       if (this.keysPressed.has("q")) {
         pose.heading = clampDeg(pose.heading - ang);
@@ -3127,8 +3121,8 @@ var AirplaneCursor = class {
           this.viewer.dataSources.add(layer);
         }
         this.frustum = new FrustumPyramid(this.CesiumNS, layer, {
-          fov: this.opts.fovDeg ?? 50,
-          length: 500,
+          fov: this.opts.fovDeg ?? 40,
+          length: 80,
           color: this.opts.color,
           fillAlpha: 0.25,
           width: 2,
@@ -3136,14 +3130,17 @@ var AirplaneCursor = class {
           logAngles: false,
           logThrottleMs: 300
         });
+        const frustumFovScale = 0.6;
+        const frustumLengthScale = 0.1;
         this.frustum.showAtDynamic(
           () => this.pose.position,
           () => this.pose.heading,
           () => this.pose.pitch,
           () => this.pose.roll,
-          () => this.currentFOV,
-          // 使用动态更新的 currentFOV
-          () => 1e3
+          () => this.currentFOV * frustumFovScale,
+          // 缩小 FOV
+          () => 1e3 * frustumLengthScale
+          // 缩小深度（1000 -> 100）
         );
         try {
           this.heightMarker = new HeightMarker(this.CesiumNS, this.viewer, layer);
@@ -3659,7 +3656,7 @@ function calculatePathDistance(CesiumNS, positions, targetIndex, hiddenClimbInde
   if (targetIndex < 0 || targetIndex >= positions.length) return 0;
   const C = CesiumNS;
   let totalDistance = 0;
-  const startIndex = hiddenClimbIndex === 1 ? 2 : 1;
+  const startIndex = 1;
   if (targetIndex <= startIndex) return 0;
   for (let i = startIndex; i <= targetIndex; i++) {
     try {
@@ -3702,9 +3699,11 @@ var VertexInsertionHandler = class {
    * @param heightMarkers 高度标记数组（引用）
    * @param airplaneCursor 飞机游标（可选）
    * @param poseOrient 顶点姿态（可选）
+   * @param useGlobalHeightFlags 🆕 是否使用全局高度标志数组（引用，可选）
+   * @param altitudeModeOptions 🆕 高度模式选项（可选）
    * @returns 实际插入的索引
    */
-  insertVertex(insertAt, position, positions, handles, headings, pitches, rolls, fovs, editedIndices, vertexLabelManager, heightMarkers, airplaneCursor, poseOrient) {
+  insertVertex(insertAt, position, positions, handles, headings, pitches, rolls, fovs, editedIndices, vertexLabelManager, heightMarkers, airplaneCursor, poseOrient, useGlobalHeightFlags) {
     const C = this.CesiumNS;
     if (this.hiddenClimbIndex === 1 && insertAt <= 1) {
       insertAt = 2;
@@ -3739,6 +3738,12 @@ var VertexInsertionHandler = class {
     pitches.splice(insertAt, 0, pose.pitch);
     rolls.splice(insertAt, 0, pose.roll);
     fovs.splice(insertAt, 0, 50);
+    if (useGlobalHeightFlags) {
+      for (let i = useGlobalHeightFlags.length - 1; i >= insertAt; i--) {
+        useGlobalHeightFlags[i + 1] = useGlobalHeightFlags[i];
+      }
+      useGlobalHeightFlags[insertAt] = true;
+    }
     return insertAt;
   }
   /**
@@ -3947,7 +3952,6 @@ var VertexDragHandler = class {
     __publicField(this, "CesiumNS");
     __publicField(this, "viewer");
     __publicField(this, "hiddenClimbIndex");
-    __publicField(this, "minHeight");
     __publicField(this, "callbacks");
     __publicField(this, "dragState", null);
     __publicField(this, "canvas");
@@ -3956,7 +3960,6 @@ var VertexDragHandler = class {
     this.CesiumNS = options.CesiumNS;
     this.viewer = options.viewer;
     this.hiddenClimbIndex = options.hiddenClimbIndex;
-    this.minHeight = options.minHeight ?? 0;
     this.callbacks = callbacks;
     this.canvas = this.viewer.scene.canvas;
     this.setupKeyboardListeners();
@@ -4132,7 +4135,7 @@ var VertexDragHandler = class {
       const cameraHeight = this.viewer.camera.positionCartographic.height;
       const scaleFactor = Math.max(cameraHeight / 1e3, 0.5);
       const heightDelta = -deltaY * scaleFactor;
-      const newHeight = Math.max(this.minHeight, this.dragState.startHeight + heightDelta);
+      const newHeight = this.dragState.startHeight + heightDelta;
       const newPosition = C.Cartesian3.fromDegrees(
         this.dragState.startLonLat.lon,
         this.dragState.startLonLat.lat,
@@ -4217,6 +4220,83 @@ var VertexDragHandler = class {
   }
 };
 
+// src/core/path-manager/utils/TerrainHeightQuery.ts
+async function queryTerrainHeights(CesiumNS, viewer, positions) {
+  const C = CesiumNS;
+  if (!positions || positions.length === 0) {
+    return [];
+  }
+  const cartographics = positions.map((pos) => {
+    try {
+      return C.Cartographic.fromCartesian(pos);
+    } catch {
+      return new C.Cartographic(0, 0, 0);
+    }
+  });
+  const terrainProvider = viewer.terrainProvider;
+  if (!terrainProvider || !C.sampleTerrainMostDetailed) {
+    console.warn("[TerrainHeightQuery] \u65E0\u53EF\u7528\u5730\u5F62\u63D0\u4F9B\u8005\uFF0C\u4F7F\u7528\u540C\u6B65\u56DE\u9000\u65B9\u6848");
+    return positions.map((pos) => queryTerrainHeightSync(CesiumNS, viewer, pos));
+  }
+  try {
+    const sampledPositions = await C.sampleTerrainMostDetailed(
+      terrainProvider,
+      cartographics
+    );
+    return sampledPositions.map((carto) => {
+      const height = carto?.height;
+      return typeof height === "number" && !isNaN(height) ? height : 0;
+    });
+  } catch (error) {
+    console.warn("[TerrainHeightQuery] \u5F02\u6B65\u67E5\u8BE2\u5931\u8D25\uFF0C\u4F7F\u7528\u540C\u6B65\u56DE\u9000:", error);
+    return positions.map((pos) => queryTerrainHeightSync(CesiumNS, viewer, pos));
+  }
+}
+function queryTerrainHeightSync(CesiumNS, viewer, position) {
+  const C = CesiumNS;
+  try {
+    const cartographic = C.Cartographic.fromCartesian(position);
+    const globe = viewer.scene.globe;
+    if (globe && typeof globe.getHeight === "function") {
+      const height = globe.getHeight(cartographic);
+      if (typeof height === "number" && !isNaN(height)) {
+        return height;
+      }
+    }
+  } catch (error) {
+    console.warn("[TerrainHeightQuery] \u540C\u6B65\u67E5\u8BE2\u5931\u8D25:", error);
+  }
+  return 0;
+}
+async function queryTerrainHeightAsync(CesiumNS, viewer, position) {
+  const heights = await queryTerrainHeights(CesiumNS, viewer, [position]);
+  return heights[0] ?? 0;
+}
+function calculateAbsoluteHeight(altitudeMode, defaultAltitude, startPointAltitude, terrainHeight) {
+  switch (altitudeMode) {
+    case "absolute":
+      return defaultAltitude;
+    case "relativeToStart":
+      return startPointAltitude + defaultAltitude;
+    case "relativeToGround":
+      return terrainHeight + defaultAltitude;
+    default:
+      return defaultAltitude;
+  }
+}
+function calculateRelativeHeight(altitudeMode, absoluteHeight, startPointAltitude, terrainHeight) {
+  switch (altitudeMode) {
+    case "absolute":
+      return absoluteHeight;
+    case "relativeToStart":
+      return absoluteHeight - startPointAltitude;
+    case "relativeToGround":
+      return absoluteHeight - terrainHeight;
+    default:
+      return absoluteHeight;
+  }
+}
+
 // src/core/path-manager/editing/PathEditingEventHandler.ts
 var PathEditingEventHandler = class {
   constructor(options, callbacks) {
@@ -4239,8 +4319,7 @@ var PathEditingEventHandler = class {
       {
         CesiumNS: this.CesiumNS,
         viewer: this.viewer,
-        hiddenClimbIndex: this.hiddenClimbIndex,
-        minHeight: options.minHeight
+        hiddenClimbIndex: this.hiddenClimbIndex
       },
       {
         onDragStart: (index) => {
@@ -4475,23 +4554,14 @@ var PathEditingEventHandler = class {
   buildVertexContextMenuItems(vertexIndex) {
     const menuItems = [];
     const positions = this.callbacks.getPositions?.() || [];
-    const visibleVertexCount = positions.length - (this.hiddenClimbIndex === 1 ? 1 : 0);
-    const canDelete = visibleVertexCount > 1;
-    const isStartPoint = vertexIndex === 0 || this.hiddenClimbIndex === 1 && vertexIndex === 1;
-    if (canDelete && !isStartPoint) {
+    const canDelete = positions.length > 1;
+    if (canDelete) {
       menuItems.push({
         label: `\u5220\u9664\u822A\u70B9 ${this.getVertexDisplayNumber(vertexIndex)}`,
         action: () => {
           this.handleDeleteVertex(vertexIndex);
         }
       });
-    } else if (isStartPoint) {
-      menuItems.push({
-        label: "\u8D77\u70B9\u4E0D\u53EF\u5220\u9664",
-        action: () => {
-        },
-        disabled: true
-      });
     } else {
       menuItems.push({
         label: "\u81F3\u5C11\u4FDD\u7559\u4E00\u4E2A\u822A\u70B9",
@@ -4503,12 +4573,10 @@ var PathEditingEventHandler = class {
     return menuItems;
   }
   /**
-   * 获取顶点的显示编号（跳过隐藏爬升点）
+   * 获取顶点的显示编号
+   * 🆕 不再跳过隐藏爬升点，直接返回索引
    */
   getVertexDisplayNumber(index) {
-    if (this.hiddenClimbIndex === 1 && index > 1) {
-      return index - 1;
-    }
     return index;
   }
   /**
@@ -4540,18 +4608,17 @@ var PathEditingEventHandler = class {
       };
     }
     const totalVertices = positions.length;
-    const totalVisibleVertices = totalVertices - (this.hiddenClimbIndex === 1 ? 1 : 0);
-    const isStartPoint = index === 0 || this.hiddenClimbIndex === 1 && index === 1;
-    const isHiddenClimb = this.hiddenClimbIndex === 1 && index === 1;
-    const canDelete = totalVisibleVertices > 1 && !isStartPoint;
+    const totalVisibleVertices = totalVertices;
+    const isStartPoint = false;
+    const isHiddenClimb = false;
+    const canDelete = totalVertices > 1;
     let pathProperties;
     if (entity) {
       try {
         const props = entity.properties;
         pathProperties = {
           altitudeMode: props?._altitudeMode?.getValue?.() ?? props?._altitudeMode,
-          climbHeight: props?._climbHeight?.getValue?.() ?? props?._climbHeight,
-          hasHiddenClimb: props?._hasHiddenClimb?.getValue?.() ?? props?._hasHiddenClimb
+          climbHeight: props?._climbHeight?.getValue?.() ?? props?._climbHeight
         };
       } catch {
       }
@@ -4590,11 +4657,9 @@ var PathEditingEventHandler = class {
   }
   /**
    * 处理插入顶点
+   * 🆕 不再跳过隐藏爬升点
    */
   handleInsertVertex(insertAt, pose, type) {
-    if (this.hiddenClimbIndex === 1 && insertAt <= 1) {
-      insertAt = 2;
-    }
     if (this.callbacks.onInsertVertex) {
       this.callbacks.onInsertVertex(insertAt, pose.position, {
         heading: pose.heading,
@@ -4625,6 +4690,10 @@ var PathEditingEventHandler = class {
   }
   /**
    * 🆕 处理快速编辑模式的点击
+   * 根据 altitudeMode 计算航点高度：
+   * - absolute: 航点高度 = defaultAltitude
+   * - relativeToGround: 航点高度 = 地形高度 + defaultAltitude
+   * - relativeToStart: 航点高度 = 起飞点高度 + defaultAltitude
    */
   handleQuickEditClick(movement) {
     const position = this.getPositionFromMouse(movement);
@@ -4634,11 +4703,9 @@ var PathEditingEventHandler = class {
     }
     const quickEditOptions = this.callbacks.getQuickEditOptions?.();
     if (!quickEditOptions) return;
-    const { climbHeight, altitudeMode } = quickEditOptions;
+    const { defaultAltitude, altitudeMode } = quickEditOptions;
+    const newPosition = this.calculatePositionByAltitudeMode(position, defaultAltitude, altitudeMode);
     const C = this.CesiumNS;
-    const originalCarto = C.Cartographic.fromCartesian(position);
-    const originalHeight = originalCarto.height;
-    const newPosition = this.applyClimbHeight(position, climbHeight, altitudeMode);
     const newCarto = C.Cartographic.fromCartesian(newPosition);
     const newHeight = newCarto.height;
     const positions = this.callbacks.getPositions?.() || [];
@@ -4653,8 +4720,7 @@ var PathEditingEventHandler = class {
         insertAt,
         heading: heading.toFixed(2),
         altitudeMode,
-        climbHeight,
-        originalHeight: originalHeight.toFixed(2),
+        defaultAltitude,
         finalHeight: newHeight.toFixed(2)
       });
       this.callbacks.onInsertVertex(insertAt, newPosition, {
@@ -4666,21 +4732,35 @@ var PathEditingEventHandler = class {
     }
   }
   /**
-   * 🆕 应用爬升高度到位置
+   * 🆕 根据高度模式计算航点位置
+   * - absolute: 航点高度 = defaultAltitude
+   * - relativeToGround: 航点高度 = 地形高度 + defaultAltitude
+   * - relativeToStart: 航点高度 = 起飞点高度 + defaultAltitude
    */
-  applyClimbHeight(position, climbHeight, altitudeMode) {
+  calculatePositionByAltitudeMode(position, defaultAltitude, altitudeMode) {
     const C = this.CesiumNS;
     try {
       const cartographic = C.Cartographic.fromCartesian(position);
       const lon = C.Math.toDegrees(cartographic.longitude);
       const lat = C.Math.toDegrees(cartographic.latitude);
-      let height = cartographic.height;
-      if (altitudeMode === "relativeToGround" || altitudeMode === "relativeToStart") {
-        height += climbHeight;
-      } else if (altitudeMode === "absolute") {
-        height = climbHeight;
+      let finalHeight;
+      if (altitudeMode === "absolute") {
+        finalHeight = defaultAltitude;
+      } else if (altitudeMode === "relativeToGround") {
+        const terrainHeight = queryTerrainHeightSync(this.CesiumNS, this.viewer, position);
+        finalHeight = terrainHeight + defaultAltitude;
+      } else if (altitudeMode === "relativeToStart") {
+        const startPointAltitude = this.callbacks.getStartPointAltitude?.() ?? 0;
+        finalHeight = startPointAltitude + defaultAltitude;
+      } else {
+        finalHeight = defaultAltitude;
       }
-      return C.Cartesian3.fromDegrees(lon, lat, height);
+      console.log("[QuickEdit] \u9AD8\u5EA6\u8BA1\u7B97:", {
+        altitudeMode,
+        defaultAltitude,
+        finalHeight
+      });
+      return C.Cartesian3.fromDegrees(lon, lat, finalHeight);
     } catch (error) {
       console.error("[QuickEdit] \u9AD8\u5EA6\u8BA1\u7B97\u5931\u8D25:", error);
       return position;
@@ -4772,19 +4852,19 @@ var VertexHandleStyleManager = class {
     __publicField(this, "selectedStyle");
     const C = CesiumNS;
     this.normalStyle = {
-      pixelSize: options?.normal?.pixelSize ?? 10,
+      pixelSize: options?.normal?.pixelSize ?? 6,
       color: options?.normal?.color ?? C.Color.YELLOW,
       outlineColor: options?.normal?.outlineColor ?? C.Color.BLACK,
       outlineWidth: options?.normal?.outlineWidth ?? 1
     };
     this.editedStyle = {
-      pixelSize: options?.edited?.pixelSize ?? 10,
+      pixelSize: options?.edited?.pixelSize ?? 6,
       color: options?.edited?.color ?? C.Color.CYAN,
       outlineColor: options?.edited?.outlineColor ?? C.Color.BLACK,
       outlineWidth: options?.edited?.outlineWidth ?? 1
     };
     this.selectedStyle = {
-      pixelSize: options?.selected?.pixelSize ?? 14,
+      pixelSize: options?.selected?.pixelSize ?? 8,
       color: options?.selected?.color ?? C.Color.ORANGE,
       outlineColor: options?.selected?.outlineColor ?? C.Color.BLACK,
       outlineWidth: options?.selected?.outlineWidth ?? 2
@@ -4992,18 +5072,57 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   } catch {
     positions = [];
   }
-  let hiddenClimbIndex;
+  const hiddenClimbIndex = void 0;
+  let currentAltitudeMode = "absolute";
+  let currentDefaultAltitude = 100;
   try {
     const props = entity.properties;
-    const hFlag = props?._hasHiddenClimb?.getValue?.() ?? props?._hasHiddenClimb;
-    if (hFlag && positions.length >= 2) hiddenClimbIndex = 1;
+    const storedMode = props?._altitudeMode?.getValue?.() ?? props?._altitudeMode;
+    if (storedMode === "absolute" || storedMode === "relativeToGround" || storedMode === "relativeToStart") {
+      currentAltitudeMode = storedMode;
+    }
+    const storedDefaultAlt = props?._defaultAltitude?.getValue?.() ?? props?._defaultAltitude;
+    if (typeof storedDefaultAlt === "number") {
+      currentDefaultAltitude = storedDefaultAlt;
+    }
   } catch {
   }
+  if (options?.altitudeMode) {
+    currentAltitudeMode = options.altitudeMode;
+  }
+  if (options?.defaultAltitude !== void 0) {
+    currentDefaultAltitude = options.defaultAltitude;
+  }
+  let startPointAltitude = 0;
+  try {
+    if (positions.length > 0) {
+      const startCarto = C.Cartographic.fromCartesian(positions[0]);
+      startPointAltitude = startCarto.height ?? 0;
+    }
+  } catch {
+  }
+  const terrainHeightsCache = /* @__PURE__ */ new Map();
+  const useGlobalHeightFlags = [];
+  try {
+    const props = entity.properties;
+    const storedFlags = props?._useGlobalHeightFlags?.getValue?.() ?? props?._useGlobalHeightFlags;
+    if (Array.isArray(storedFlags)) {
+      storedFlags.forEach((flag, idx) => {
+        useGlobalHeightFlags[idx] = flag;
+      });
+    }
+  } catch {
+  }
+  while (useGlobalHeightFlags.length < positions.length) {
+    useGlobalHeightFlags.push(false);
+  }
   let quickEditEnabled = false;
   let quickEditOptions = {
     enabled: false,
-    climbHeight: 100,
-    altitudeMode: "absolute"
+    climbHeight: currentDefaultAltitude,
+    // 使用当前默认高度
+    altitudeMode: currentAltitudeMode
+    // 使用当前高度模式
   };
   if (options?.quickEdit) {
     if (typeof options.quickEdit === "boolean") {
@@ -5036,33 +5155,23 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   } catch {
   }
   const handles = positions.map((p, i) => {
-    if (hiddenClimbIndex === i) return void 0;
-    const isStartPoint = i === 0;
     const h = existing[i];
     if (h) {
       try {
         h.position = p;
-        if (!isStartPoint) {
-          h.point = h.point ?? { pixelSize: 10 };
-          h.point.pixelSize = 10;
-          h.point.color = C.Color.YELLOW;
-          h.point.outlineColor = C.Color.BLACK;
-          h.point.outlineWidth = 1;
-        }
+        h.point = h.point ?? { pixelSize: 6 };
+        h.point.pixelSize = 6;
+        h.point.color = C.Color.YELLOW;
+        h.point.outlineColor = C.Color.BLACK;
+        h.point.outlineWidth = 1;
         h.properties = { _type: "path-vertex", _ownerId: ownerId, _vertexIndex: i };
       } catch {
       }
       return h;
     }
-    if (isStartPoint) {
-      return layer.entities.add({
-        position: p,
-        properties: { _type: "path-vertex", _ownerId: ownerId, _vertexIndex: i }
-      });
-    }
     return layer.entities.add({
       position: p,
-      point: { pixelSize: 10, color: C.Color.YELLOW, outlineColor: C.Color.BLACK, outlineWidth: 1 },
+      point: { pixelSize: 6, color: C.Color.YELLOW, outlineColor: C.Color.BLACK, outlineWidth: 1 },
       properties: { _type: "path-vertex", _ownerId: ownerId, _vertexIndex: i }
     });
   });
@@ -5079,8 +5188,6 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   };
   const createOrUpdateMarkerForIndex = (idx) => {
     try {
-      if (hiddenClimbIndex === 1 && idx === 1) return;
-      if (idx === 0) return;
       const pos = positions[idx];
       if (!pos) return;
       const markerLayer = ensureMarkerLayer();
@@ -5162,7 +5269,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   };
   const getTotalDistance = () => {
     if (positions.length < 2) return 0;
-    return calculatePathDistance(CesiumNS, positions, positions.length - 1, hiddenClimbIndex);
+    return calculatePathDistance(CesiumNS, positions, positions.length - 1);
   };
   const vertexInsertionHandler = new VertexInsertionHandler({
     CesiumNS,
@@ -5171,7 +5278,40 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
     hiddenClimbIndex
   });
   let cursorStart = positions[positions.length - 1];
-  if (!cursorStart) cursorStart = positions[hiddenClimbIndex === 1 ? 1 : 0];
+  if (!cursorStart) cursorStart = positions[0];
+  if (!cursorStart) {
+    try {
+      const cameraPos = viewer.camera.positionCartographic;
+      if (cameraPos) {
+        let initialHeight = currentDefaultAltitude;
+        if (currentAltitudeMode === "relativeToGround") {
+          const terrainHeight = queryTerrainHeightSync(
+            CesiumNS,
+            viewer,
+            C.Cartesian3.fromRadians(cameraPos.longitude, cameraPos.latitude, 0)
+          );
+          initialHeight = terrainHeight + currentDefaultAltitude;
+          console.log("[PathEditing] relativeToGround \u6A21\u5F0F\uFF0C\u5730\u5F62\u9AD8\u5EA6:", terrainHeight, "\u521D\u59CB\u9AD8\u5EA6:", initialHeight);
+        } else if (currentAltitudeMode === "relativeToStart") {
+          initialHeight = currentDefaultAltitude;
+          console.log("[PathEditing] relativeToStart \u6A21\u5F0F\uFF08\u7A7A\u822A\u7EBF\uFF09\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u9AD8\u5EA6:", initialHeight);
+        }
+        cursorStart = C.Cartesian3.fromRadians(
+          cameraPos.longitude,
+          cameraPos.latitude,
+          initialHeight
+        );
+        console.log("[PathEditing] \u7A7A\u822A\u7EBF\uFF0C\u4F7F\u7528\u76F8\u673A\u4F4D\u7F6E\u521D\u59CB\u5316\u6E38\u6807:", {
+          lon: C.Math.toDegrees(cameraPos.longitude),
+          lat: C.Math.toDegrees(cameraPos.latitude),
+          height: initialHeight,
+          altitudeMode: currentAltitudeMode
+        });
+      }
+    } catch (error) {
+      console.warn("[PathEditing] \u65E0\u6CD5\u83B7\u53D6\u76F8\u673A\u4F4D\u7F6E:", error);
+    }
+  }
   let airplaneCursor;
   const insertVertex = (insertAt, p3, poseOrient) => {
     console.log("[PathEditing] \u63D2\u5165\u9876\u70B9\u524D positions \u957F\u5EA6:", positions.length, "insertAt:", insertAt);
@@ -5188,7 +5328,9 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       vertexLabelManager,
       heightMarkers,
       airplaneCursor,
-      poseOrient
+      poseOrient,
+      useGlobalHeightFlags
+      // 🆕 传递 useGlobalHeightFlags
     );
     console.log("[PathEditing] \u63D2\u5165\u9876\u70B9\u540E positions \u957F\u5EA6:", positions.length, "actualIndex:", actualIndex);
     entity.polyline.positions = new C.CallbackProperty(() => positions.slice(), false);
@@ -5197,16 +5339,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   };
   const deleteVertex = (deleteAt) => {
     try {
-      if (deleteAt === 0 || hiddenClimbIndex === 1 && deleteAt === 1) {
-        console.warn("Cannot delete start point");
-        return;
-      }
-      if (hiddenClimbIndex !== void 0 && deleteAt === hiddenClimbIndex) {
-        console.warn("Cannot delete hidden climb point");
-        return;
-      }
-      const visibleVertexCount = positions.length - (hiddenClimbIndex === 1 ? 1 : 0);
-      if (visibleVertexCount <= 1) {
+      if (positions.length <= 1) {
         console.warn("Cannot delete last vertex");
         return;
       }
@@ -5230,6 +5363,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       rolls.splice(deleteAt, 1);
       fovs.splice(deleteAt, 1);
       heightMarkers.splice(deleteAt, 1);
+      useGlobalHeightFlags.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();
@@ -5291,9 +5425,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
           }
         },
         // frustumLengthFactor: options?.preview?.lengthFactor ?? 0.3,
-        fovDeg: options?.preview?.fov ?? 50,
-        minHeight: options?.minHeight
-        // 传递最小高度限制
+        fovDeg: options?.preview?.fov ?? 50
       });
       if (options?.preview?.enabled !== false && airplaneCursor) {
         preview = new PathPreview(CesiumNS, viewer, {
@@ -5337,8 +5469,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
     {
       CesiumNS,
       viewer,
-      hiddenClimbIndex,
-      minHeight: options?.minHeight
+      hiddenClimbIndex
     },
     {
       onVertexSelect: (index) => setActiveIndex(index),
@@ -5369,7 +5500,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       },
       onDeleteVertex: (index) => {
         const totalBefore = positions.length;
-        const displayNumber = hiddenClimbIndex === 1 && index > 1 ? index - 1 : index;
+        const displayNumber = index;
         deleteVertex(index);
         if (options?.onVertexDeleteDetail) {
           try {
@@ -5422,7 +5553,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
               };
             } catch {
             }
-            const displayNumber = hiddenClimbIndex === 1 && index > 1 ? index - 1 : index;
+            const displayNumber = index;
             const dragMoveInfo = {
               index,
               displayNumber,
@@ -5439,6 +5570,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       onVertexDragEnd: (index, finalPosition) => {
         editedIndices.add(index);
         positions[index] = finalPosition;
+        useGlobalHeightFlags[index] = false;
         if (handles[index]) {
           handleStyleManager.applyStyle(handles[index], "edited");
         }
@@ -5485,10 +5617,29 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       getCursorPose: () => airplaneCursor?.getPose(),
       // 🆕 快速编辑回调
       getQuickEditEnabled: () => quickEditEnabled,
-      getQuickEditOptions: () => ({
-        climbHeight: quickEditOptions.climbHeight ?? 100,
-        altitudeMode: quickEditOptions.altitudeMode ?? "absolute"
-      })
+      getQuickEditOptions: () => {
+        let climbHeight = 0;
+        try {
+          const props = entity.properties;
+          climbHeight = props?._climbHeight?.getValue?.() ?? props?._climbHeight ?? 0;
+        } catch {
+        }
+        return {
+          climbHeight,
+          defaultAltitude: currentDefaultAltitude,
+          altitudeMode: currentAltitudeMode
+        };
+      },
+      // 🆕 高度模式相关回调
+      getStartPointAltitude: () => startPointAltitude,
+      getDefaultAltitude: () => currentDefaultAltitude,
+      // 🆕 useGlobalHeightFlags 相关回调
+      getUseGlobalHeightFlags: () => useGlobalHeightFlags,
+      setUseGlobalHeightFlag: (index, value) => {
+        if (index >= 0 && index < useGlobalHeightFlags.length) {
+          useGlobalHeightFlags[index] = value;
+        }
+      }
     }
   );
   const cleanupSession = () => {
@@ -5528,6 +5679,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   const buildVertexDetailInfo = (index) => {
     const position = positions[index];
     let coordinates = { longitude: 0, latitude: 0, height: 0 };
+    let ellipsoidHeight = 0;
     try {
       const cartographic = C.Cartographic.fromCartesian(position);
       coordinates = {
@@ -5535,8 +5687,16 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
         latitude: C.Math.toDegrees(cartographic.latitude),
         height: cartographic.height
       };
+      ellipsoidHeight = cartographic.height ?? 0;
     } catch {
     }
+    const terrainHeight = terrainHeightsCache.get(index) ?? 0;
+    const relativeHeight = calculateRelativeHeight(
+      currentAltitudeMode,
+      ellipsoidHeight,
+      startPointAltitude,
+      terrainHeight
+    );
     const pose = {
       heading: headings[index] ?? 0,
       pitch: pitches[index] ?? 0,
@@ -5544,18 +5704,17 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       fov: fovs[index] ?? 50
     };
     const totalVertices = positions.length;
-    const totalVisibleVertices = totalVertices - (hiddenClimbIndex === 1 ? 1 : 0);
-    const isStartPoint = index === 0 || hiddenClimbIndex === 1 && index === 1;
-    const isHiddenClimb = hiddenClimbIndex === 1 && index === 1;
-    const canDelete = totalVisibleVertices > 1 && !isStartPoint;
-    const displayNumber = hiddenClimbIndex === 1 && index > 1 ? index - 1 : index;
+    const totalVisibleVertices = totalVertices;
+    const isStartPoint = false;
+    const isHiddenClimb = false;
+    const canDelete = totalVertices > 1;
+    const displayNumber = index;
     let pathProperties;
     try {
       const props = entity.properties;
       pathProperties = {
         altitudeMode: props?._altitudeMode?.getValue?.() ?? props?._altitudeMode,
-        climbHeight: props?._climbHeight?.getValue?.() ?? props?._climbHeight,
-        hasHiddenClimb: props?._hasHiddenClimb?.getValue?.() ?? props?._hasHiddenClimb
+        climbHeight: props?._climbHeight?.getValue?.() ?? props?._climbHeight
       };
     } catch {
     }
@@ -5571,44 +5730,68 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       totalVisibleVertices,
       totalVertices,
       entity,
-      pathProperties
+      pathProperties,
+      useGlobalHeight: useGlobalHeightFlags[index] ?? false,
+      // 🆕 添加 useGlobalHeight
+      ellipsoidHeight,
+      // 🆕 添加椭球高度
+      relativeHeight
+      // 🆕 添加相对高度
     };
   };
   return {
     /** 保存并退出编辑模式 */
     saveAndStop: () => {
       stateManager.persistToEntity(positions, headings, pitches, rolls, fovs);
-      const startPoint = {
-        position: positions[0]
-      };
-      let altitudeMode;
+      try {
+        entity.properties._altitudeMode = currentAltitudeMode;
+        entity.properties._defaultAltitude = currentDefaultAltitude;
+        entity.properties._useGlobalHeightFlags = useGlobalHeightFlags.slice();
+      } catch {
+      }
+      let altitudeMode = currentAltitudeMode;
       let climbHeight;
-      let hasHiddenClimb;
       try {
         const props = entity.properties;
-        altitudeMode = props?._altitudeMode?.getValue?.() ?? props?._altitudeMode;
         climbHeight = props?._climbHeight?.getValue?.() ?? props?._climbHeight;
-        hasHiddenClimb = props?._hasHiddenClimb?.getValue?.() ?? props?._hasHiddenClimb;
       } catch {
       }
-      const waypointData = positions.map((position, index) => ({
-        position,
-        heading: headings[index] ?? 0,
-        pitch: pitches[index] ?? -10,
-        roll: rolls[index] ?? 0,
-        fov: fovs[index] ?? 50,
-        index,
-        distance: calculatePathDistance(CesiumNS, positions, index, hiddenClimbIndex)
-      })).filter((wp) => wp.index >= 2);
+      const waypointData = positions.map((position, index) => {
+        let ellipsoidHeight = 0;
+        try {
+          const carto = C.Cartographic.fromCartesian(position);
+          ellipsoidHeight = carto.height ?? 0;
+        } catch {
+        }
+        const terrainHeight = terrainHeightsCache.get(index) ?? 0;
+        const relativeHeight = calculateRelativeHeight(
+          currentAltitudeMode,
+          ellipsoidHeight,
+          startPointAltitude,
+          terrainHeight
+        );
+        return {
+          position,
+          heading: headings[index] ?? 0,
+          pitch: pitches[index] ?? -10,
+          roll: rolls[index] ?? 0,
+          fov: fovs[index] ?? 50,
+          index,
+          distance: calculatePathDistance(CesiumNS, positions, index),
+          ellipsoidHeight,
+          relativeHeight,
+          useGlobalHeight: useGlobalHeightFlags[index] ?? false
+          // 🆕 添加 useGlobalHeight
+        };
+      });
       cleanupSession();
       return {
         entity,
         positions: positions.slice(),
-        startPoint,
         climbHeight,
         waypointData,
         altitudeMode,
-        hasHiddenClimb
+        defaultAltitude: currentDefaultAltitude
       };
     },
     /** 不保存退出（回滚到进入编辑时的状态） */
@@ -5831,45 +6014,32 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
      */
     getCursorPose: () => airplaneCursor?.getPose(),
     /**
-     * 🆕 动态更新爬升高度（climbHeight）
-     * 更新隐藏爬升点（index 1）的高度，实现安全飞行高度的动态调节
-     * @param climbHeight 新的爬升高度（米）
+     * 🆕 更新爬升高度（climbHeight）
+     * 更新实体属性中的 _climbHeight 值
+     * @param newClimbHeight 新的爬升高度（米）
      * @returns 是否更新成功
      */
-    updateClimbHeight: function(climbHeight) {
-      if (hiddenClimbIndex !== 1 || positions.length < 2) {
-        console.warn("[updateClimbHeight] No hidden climb point exists");
-        return false;
-      }
+    updateClimbHeight: function(newClimbHeight) {
       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;
+        entity.properties._climbHeight = newClimbHeight;
+        console.log("[updateClimbHeight] \u2705 \u722C\u5347\u9AD8\u5EA6\u5DF2\u66F4\u65B0:", newClimbHeight, "\u7C73");
+        return true;
       } catch (error) {
         console.error("[updateClimbHeight] Error:", error);
         return false;
       }
     },
     /**
-     * 🆕 获取起飞点信息
-     * @returns 起飞点的经纬度和高度
+     * 🆕 获取第一个航点信息
+     * @returns 第一个航点的经纬度和高度
      */
     getStartPoint: () => {
       if (positions.length < 1) return null;
       try {
-        const startPos = positions[0];
-        const carto = C.Cartographic.fromCartesian(startPos);
+        const firstPos = positions[0];
+        const carto = C.Cartographic.fromCartesian(firstPos);
         return {
-          position: startPos,
+          position: firstPos,
           latitude: C.Math.toDegrees(carto.latitude),
           longitude: C.Math.toDegrees(carto.longitude),
           altitude: carto.height
@@ -5877,6 +6047,123 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       } catch {
         return null;
       }
+    },
+    /**
+     * 🆕 获取当前高度模式
+     */
+    getAltitudeMode: () => currentAltitudeMode,
+    /**
+     * 🆕 获取当前默认高度
+     */
+    getDefaultAltitude: () => currentDefaultAltitude,
+    /**
+     * 🆕 更新默认高度
+     */
+    updateDefaultAltitude: (altitude) => {
+      currentDefaultAltitude = altitude;
+      quickEditOptions.climbHeight = altitude;
+      try {
+        entity.properties._defaultAltitude = altitude;
+      } catch {
+      }
+      console.log("[updateDefaultAltitude] \u2705 \u9ED8\u8BA4\u9AD8\u5EA6\u5DF2\u66F4\u65B0:", altitude, "\u7C73");
+    },
+    /**
+     * 🆕 切换高度计算模式（异步，会重算所有航点高度）
+     * @param newMode 新的高度模式
+     * @param newDefaultAltitude 新的默认高度（可选）
+     * @param options 选项（terrainProvider, onProgress）
+     * @returns 切换结果 { success: boolean; error?: string }
+     */
+    changeAltitudeMode: async (newMode, newDefaultAltitude, options2) => {
+      try {
+        const onProgress = options2?.onProgress;
+        if (newMode === "relativeToGround") {
+          const terrainProvider = options2?.terrainProvider ?? viewer.terrainProvider;
+          const C_any = C;
+          if (!terrainProvider || C_any.EllipsoidTerrainProvider && terrainProvider instanceof C_any.EllipsoidTerrainProvider) {
+            console.error("[changeAltitudeMode] \u274C relativeToGround \u6A21\u5F0F\u9700\u8981\u6709\u6548\u7684 terrain \u56FE\u5C42");
+            onProgress?.("error");
+            return {
+              success: false,
+              error: "Terrain provider required for relativeToGround mode"
+            };
+          }
+        }
+        onProgress?.("loading");
+        const oldMode = currentAltitudeMode;
+        if (newDefaultAltitude !== void 0) {
+          currentDefaultAltitude = newDefaultAltitude;
+          quickEditOptions.climbHeight = newDefaultAltitude;
+        }
+        if (newMode === "relativeToGround" || oldMode === "relativeToGround") {
+          const terrainHeights = await queryTerrainHeights(CesiumNS, viewer, positions);
+          terrainHeights.forEach((height, index) => {
+            terrainHeightsCache.set(index, height);
+          });
+          console.log("[changeAltitudeMode] \u5DF2\u67E5\u8BE2\u5730\u5F62\u9AD8\u5EA6:", terrainHeights);
+        }
+        if (newMode !== oldMode) {
+          console.log("[changeAltitudeMode] \u5207\u6362\u9AD8\u5EA6\u6A21\u5F0F:", oldMode, "->", newMode);
+          for (let i = 0; i < positions.length; i++) {
+            const currentPos = positions[i];
+            const carto = C.Cartographic.fromCartesian(currentPos);
+            const currentAbsoluteHeight = carto.height ?? 0;
+            const oldTerrainHeight = terrainHeightsCache.get(i) ?? 0;
+            const relativeHeight = calculateRelativeHeight(
+              oldMode,
+              currentAbsoluteHeight,
+              startPointAltitude,
+              oldTerrainHeight
+            );
+            const newTerrainHeight = terrainHeightsCache.get(i) ?? 0;
+            const newAbsoluteHeight = calculateAbsoluteHeight(
+              newMode,
+              relativeHeight,
+              startPointAltitude,
+              newTerrainHeight
+            );
+            const newPosition = C.Cartesian3.fromRadians(
+              carto.longitude,
+              carto.latitude,
+              newAbsoluteHeight
+            );
+            positions[i] = newPosition;
+            if (handles[i]) {
+              try {
+                handles[i].position = newPosition;
+              } catch {
+              }
+            }
+            try {
+              vertexLabelManager.updateLabelPosition(i, newPosition);
+            } catch {
+            }
+            try {
+              createOrUpdateMarkerForIndex(i);
+            } catch {
+            }
+          }
+          currentAltitudeMode = newMode;
+          quickEditOptions.altitudeMode = newMode;
+          try {
+            entity.properties._altitudeMode = newMode;
+            entity.properties._defaultAltitude = currentDefaultAltitude;
+          } catch {
+          }
+          entity.polyline.positions = new C.CallbackProperty(() => positions.slice(), false);
+        }
+        console.log("[changeAltitudeMode] \u2705 \u9AD8\u5EA6\u6A21\u5F0F\u5207\u6362\u5B8C\u6210:", {
+          mode: newMode,
+          defaultAltitude: currentDefaultAltitude
+        });
+        onProgress?.("done");
+        return { success: true };
+      } catch (error) {
+        console.error("[changeAltitudeMode] Error:", error);
+        options2?.onProgress?.("error");
+        return { success: false, error: String(error) };
+      }
     }
   };
 }
@@ -5886,221 +6173,18 @@ function fovToFocalLength(fovDeg) {
   return sensorWidth / (2 * Math.tan(fovRad / 2));
 }
 
-// src/core/path-manager/ArrowShape.ts
-var ArrowShape = class {
-  constructor(CesiumNS, opts = {}) {
-    this.CesiumNS = CesiumNS;
-    __publicField(this, "height");
-    __publicField(this, "shaftHeight");
-    __publicField(this, "headHeight");
-    __publicField(this, "shaftRadius");
-    __publicField(this, "headRadius");
-    __publicField(this, "baseRadius");
-    __publicField(this, "color");
-    __publicField(this, "shaftAlpha");
-    __publicField(this, "headAlpha");
-    __publicField(this, "baseAlpha");
-    __publicField(this, "outline");
-    __publicField(this, "outlineColor");
-    // 动态缩放相关
-    __publicField(this, "dynamicScale");
-    __publicField(this, "viewer");
-    __publicField(this, "referenceDistance");
-    __publicField(this, "minScale");
-    __publicField(this, "maxScale");
-    __publicField(this, "cachedScaleFactor", 1);
-    const C = this.CesiumNS;
-    this.shaftHeight = opts.shaftHeight ?? 17;
-    this.headHeight = opts.headHeight ?? 8;
-    this.height = opts.height ?? this.shaftHeight + this.headHeight;
-    this.shaftRadius = opts.shaftRadius ?? 3;
-    this.headRadius = opts.headRadius ?? 6;
-    this.baseRadius = opts.baseRadius ?? 8;
-    this.color = opts.color ? C.Color.fromCssColorString(opts.color) : C.Color.fromCssColorString("#FFD700");
-    this.shaftAlpha = opts.shaftAlpha ?? 1;
-    this.headAlpha = opts.headAlpha ?? 1;
-    this.baseAlpha = opts.baseAlpha ?? 0.65;
-    this.outline = opts.outline ?? false;
-    this.outlineColor = opts.outlineColor ? C.Color.fromCssColorString(opts.outlineColor) : this.color.darken(0.3, new C.Color());
-    this.dynamicScale = opts.dynamicScale ?? false;
-    this.viewer = opts.viewer;
-    this.referenceDistance = opts.referenceDistance ?? 500;
-    this.minScale = opts.minScale ?? 0.3;
-    this.maxScale = opts.maxScale ?? 3;
-  }
-  /**
-   * Create arrow entities at given position
-   * Returns array of 3 entities: [shaft, head, base]
-   * 
-   * @param layer - Cesium CustomDataSource to add entities to
-   * @param position - Ground position (Cartesian3)
-   * @param baseHeight - Ground height in meters
-   * @param properties - Additional properties for entities
-   * @returns Array of created entities [shaft, head, base]
-   */
-  createEntities(layer, position, baseHeight, properties) {
-    const C = this.CesiumNS;
-    const entities = [];
-    const carto = C.Cartographic.fromCartesian(position);
-    const lon = C.Math.toDegrees(carto.longitude);
-    const lat = C.Math.toDegrees(carto.latitude);
-    const computeScaleFactor = () => {
-      if (!this.dynamicScale || !this.viewer) return 1;
-      try {
-        const cameraPos = this.viewer.camera.positionWC;
-        const distance = C.Cartesian3.distance(cameraPos, position);
-        const rawScale = distance / this.referenceDistance;
-        return Math.max(this.minScale, Math.min(this.maxScale, rawScale));
-      } catch {
-        return 1;
-      }
-    };
-    if (this.dynamicScale && this.viewer) {
-      this.viewer.scene.preRender.addEventListener(() => {
-        this.cachedScaleFactor = computeScaleFactor();
-      });
-    }
-    const hpr = new C.HeadingPitchRoll(0, 0, 0);
-    const baseOrientation = C.Transforms.headingPitchRollQuaternion(position, hpr);
-    const fixedOrientation = new C.ConstantProperty(baseOrientation);
-    const getShaftPosition = () => {
-      const scale = this.cachedScaleFactor;
-      return C.Cartesian3.fromDegrees(lon, lat, baseHeight + this.shaftHeight * scale / 2);
-    };
-    const getHeadPosition = () => {
-      const scale = this.cachedScaleFactor;
-      return C.Cartesian3.fromDegrees(lon, lat, baseHeight + this.shaftHeight * scale + this.headHeight * scale / 2);
-    };
-    const shaftEntity = layer.entities.add({
-      position: this.dynamicScale ? new C.CallbackProperty(getShaftPosition, false) : new C.ConstantPositionProperty(C.Cartesian3.fromDegrees(lon, lat, baseHeight + this.shaftHeight / 2)),
-      orientation: fixedOrientation,
-      cylinder: {
-        length: this.dynamicScale ? new C.CallbackProperty(() => this.shaftHeight * this.cachedScaleFactor, false) : this.shaftHeight,
-        topRadius: this.dynamicScale ? new C.CallbackProperty(() => this.shaftRadius * this.cachedScaleFactor, false) : this.shaftRadius,
-        bottomRadius: this.dynamicScale ? new C.CallbackProperty(() => this.shaftRadius * this.cachedScaleFactor, false) : this.shaftRadius,
-        material: this.color.withAlpha(this.shaftAlpha),
-        outline: this.outline,
-        outlineColor: this.outlineColor,
-        outlineWidth: 2
-      },
-      properties: {
-        ...properties,
-        _arrowPart: "shaft"
-      }
-    });
-    entities.push(shaftEntity);
-    const headEntity = layer.entities.add({
-      position: this.dynamicScale ? new C.CallbackProperty(getHeadPosition, false) : new C.ConstantPositionProperty(C.Cartesian3.fromDegrees(lon, lat, baseHeight + this.shaftHeight + this.headHeight / 2)),
-      orientation: fixedOrientation,
-      cylinder: {
-        length: this.dynamicScale ? new C.CallbackProperty(() => this.headHeight * this.cachedScaleFactor, false) : this.headHeight,
-        topRadius: 0,
-        // Creates cone shape
-        bottomRadius: this.dynamicScale ? new C.CallbackProperty(() => this.headRadius * this.cachedScaleFactor, false) : this.headRadius,
-        material: this.color.withAlpha(this.headAlpha),
-        outline: this.outline,
-        outlineColor: this.outlineColor,
-        outlineWidth: 2
-      },
-      properties: {
-        ...properties,
-        _arrowPart: "head"
-      }
-    });
-    entities.push(headEntity);
-    const baseEntity = layer.entities.add({
-      position,
-      ellipse: {
-        semiMajorAxis: this.dynamicScale ? new C.CallbackProperty(() => this.baseRadius * this.cachedScaleFactor, false) : this.baseRadius,
-        semiMinorAxis: this.dynamicScale ? new C.CallbackProperty(() => this.baseRadius * this.cachedScaleFactor, false) : this.baseRadius,
-        height: baseHeight,
-        material: this.color.withAlpha(this.baseAlpha),
-        outline: this.outline,
-        outlineColor: this.outlineColor,
-        outlineWidth: 2
-      },
-      properties: {
-        ...properties,
-        _arrowPart: "base"
-      }
-    });
-    entities.push(baseEntity);
-    return entities;
-  }
-  /**
-   * Get the color
-   */
-  getColor() {
-    return this.color;
-  }
-  /**
-   * Update arrow color
-   */
-  setColor(color) {
-    const C = this.CesiumNS;
-    this.color = C.Color.fromCssColorString(color);
-  }
-  /**
-   * Update dimensions
-   */
-  setDimensions(opts) {
-    if (opts.shaftHeight !== void 0) this.shaftHeight = opts.shaftHeight;
-    if (opts.headHeight !== void 0) this.headHeight = opts.headHeight;
-    if (opts.shaftRadius !== void 0) this.shaftRadius = opts.shaftRadius;
-    if (opts.headRadius !== void 0) this.headRadius = opts.headRadius;
-    if (opts.baseRadius !== void 0) this.baseRadius = opts.baseRadius;
-    this.height = this.shaftHeight + this.headHeight;
-  }
-  /**
-   * Update transparency
-   */
-  setAlpha(opts) {
-    if (opts.shaftAlpha !== void 0) this.shaftAlpha = opts.shaftAlpha;
-    if (opts.headAlpha !== void 0) this.headAlpha = opts.headAlpha;
-    if (opts.baseAlpha !== void 0) this.baseAlpha = opts.baseAlpha;
-  }
-  /**
-   * Get current dimensions
-   */
-  getDimensions() {
-    return {
-      height: this.height,
-      shaftHeight: this.shaftHeight,
-      headHeight: this.headHeight,
-      shaftRadius: this.shaftRadius,
-      headRadius: this.headRadius,
-      baseRadius: this.baseRadius
-    };
-  }
-  /**
-   * Get current alpha values
-   */
-  getAlpha() {
-    return {
-      shaftAlpha: this.shaftAlpha,
-      headAlpha: this.headAlpha,
-      baseAlpha: this.baseAlpha
-    };
-  }
-  /**
-   * Get total height
-   */
-  getHeight() {
-    return this.height;
-  }
-};
-
 // src/core/path-manager/startPathDrawing.ts
 function startPathDrawing(CesiumNS, viewer, options, onComplete) {
   const C = CesiumNS;
   const layer = options?.layer ?? new C.CustomDataSource("Paths");
   if (!options?.layer) viewer.dataSources.add(layer);
   const altitudeMode = options?.altitudeMode ?? "absolute";
-  const climbHeight = Number(options?.climbHeight) || 100;
-  const DEFAULT_MAIN_WIDTH = options?.width ?? 6;
-  let startCartographic;
-  let hasStart = false;
+  const climbHeight = Number(options?.climbHeight) || 0;
+  const defaultAltitude = options?.defaultAltitude ?? options?.defaultHeight ?? 100;
+  const DEFAULT_MAIN_WIDTH = options?.width ?? 3;
   let createdEntity = void 0;
+  let entityCreated = false;
+  let editSession = void 0;
   const getPositionFromMouse = (movement) => {
     const scene = viewer.scene;
     const winPos = movement?.position ?? movement?.endPosition ?? movement;
@@ -6116,129 +6200,54 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
     }
     return cart;
   };
-  const toCartographic = (cart) => {
-    try {
-      return C.Cartographic.fromCartesian(cart);
-    } catch {
-      return void 0;
-    }
-  };
   let handler;
-  const positions = [];
-  const tempHandles = [];
   handler = new C.ScreenSpaceEventHandler(viewer.scene.canvas);
   handler.setInputAction((movement) => {
-    if (hasStart) return;
     const picked = getPositionFromMouse(movement);
     if (!picked) return;
-    const carto = toCartographic(picked);
-    if (!carto) return;
-    startCartographic = new C.Cartographic(carto.longitude, carto.latitude, carto.height);
-    const groundPos = C.Cartesian3.fromDegrees(
-      C.Math.toDegrees(carto.longitude),
-      C.Math.toDegrees(carto.latitude),
-      startCartographic.height
-    );
-    positions.push(groundPos);
-    const arrowCarto = toCartographic(groundPos);
-    const baseHeight = arrowCarto ? arrowCarto.height : 0;
-    const arrowShape = new ArrowShape(CesiumNS, {
-      shaftHeight: 12,
-      headHeight: 12,
-      shaftRadius: 4,
-      headRadius: 8,
-      baseRadius: 12,
-      color: "#FFD700",
-      shaftAlpha: 1,
-      headAlpha: 1,
-      baseAlpha: 0.5,
-      // 启用动态缩放，和无人机模型一样根据相机距离调整大小
-      dynamicScale: true,
-      viewer,
-      referenceDistance: 300,
-      minScale: 0.3,
-      maxScale: 2
-    });
-    const arrowEntities = arrowShape.createEntities(
-      layer,
-      groundPos,
-      baseHeight,
-      { _type: "path-vertex", _vertexIndex: 0, _isStart: true }
-    );
-    tempHandles.push(...arrowEntities);
-    hasStart = true;
-    if (climbHeight > 0) {
-      const climbPos = C.Cartesian3.fromDegrees(
-        C.Math.toDegrees(startCartographic.longitude),
-        C.Math.toDegrees(startCartographic.latitude),
-        startCartographic.height + climbHeight
-      );
-      positions.push(climbPos);
-    }
-    let created;
-    try {
-      const id = `${options?.idPrefix ?? "path"}-${Date.now().toString(36)}`;
-      const pathPositions = new C.CallbackProperty(() => {
-        const p = created?.polyline?.positions;
-        if (p && typeof p.getValue === "function") {
-          try {
-            return p.getValue();
-          } catch {
-          }
-        }
-        return positions.slice();
-      }, false);
-      created = layer.entities.add({
-        id,
-        name: "Path",
-        polyline: {
-          positions: pathPositions,
-          width: DEFAULT_MAIN_WIDTH,
-          material: new C.PolylineOutlineMaterialProperty({
-            color: C.Color.LIME,
-            outlineColor: C.Color.WHITE,
-            outlineWidth: 2
-          }),
-          clampToGround: false
-        },
-        properties: {
-          _altitudeMode: altitudeMode,
-          _climbHeight: climbHeight,
-          _hasHiddenClimb: climbHeight > 0
-        }
-      });
-      createdEntity = created;
+    if (!entityCreated) {
+      entityCreated = true;
+      let created;
       try {
-        tempHandles.forEach((hh, idx) => {
-          try {
-            hh.properties = {
-              ...hh.properties,
-              _type: "path-vertex",
-              _ownerId: id,
-              _vertexIndex: idx,
-              _isStart: idx === 0
-            };
-          } catch {
+        const id = `${options?.idPrefix ?? "path"}-${Date.now().toString(36)}`;
+        const positions = [];
+        const pathPositions = new C.CallbackProperty(() => positions.slice(), false);
+        created = layer.entities.add({
+          id,
+          name: "Path",
+          polyline: {
+            positions: pathPositions,
+            width: DEFAULT_MAIN_WIDTH,
+            material: C.Color.fromCssColorString("#00E676"),
+            clampToGround: false
+          },
+          properties: {
+            _altitudeMode: altitudeMode,
+            _defaultAltitude: defaultAltitude,
+            _climbHeight: climbHeight,
+            _useGlobalHeightFlags: []
+            // 🆕 空数组，航点由编辑模式添加
           }
         });
-      } catch {
-      }
-    } finally {
-      try {
-        handler?.destroy();
-      } catch {
-      }
-      handler = void 0;
-    }
-    if (created) {
-      try {
-        onComplete?.(created);
-      } catch {
+        createdEntity = created;
+      } finally {
+        try {
+          handler?.destroy();
+        } catch {
+        }
+        handler = void 0;
       }
-      try {
-        const auto = options?.autoStartEditing;
-        if (auto) {
-          const editOptions = {};
+      if (created) {
+        try {
+          onComplete?.(created);
+        } catch {
+        }
+        try {
+          const auto = options?.autoStartEditing;
+          const editOptions = {
+            // 🔧 默认使用自由编辑模式（快速编辑和自由编辑互斥）
+            quickEdit: false
+          };
           if (typeof auto === "object" && auto.preview) {
             editOptions.preview = auto.preview;
           } else {
@@ -6260,30 +6269,35 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
           if (autoOpts.onVertexDeleteDetail) {
             editOptions.onVertexDeleteDetail = autoOpts.onVertexDeleteDetail;
           }
-          const editSession = startPathEditing(CesiumNS, viewer, created, editOptions);
+          editOptions.altitudeMode = altitudeMode;
+          editOptions.defaultAltitude = defaultAltitude;
+          editOptions.climbHeight = climbHeight;
+          editSession = startPathEditing(CesiumNS, viewer, created, editOptions);
+          console.log("[startPathDrawing] \u7F16\u8F91\u6A21\u5F0F\u5DF2\u542F\u52A8\uFF0C\u81EA\u7531\u7F16\u8F91\u6A21\u5F0F\uFF0C\u4F7F\u7528\u98DE\u673A\u6E38\u6807\u6DFB\u52A0\u822A\u70B9");
           if (editSession && options?.onEditingStarted) {
             try {
               options.onEditingStarted(editSession);
             } catch {
             }
           }
+        } catch (error) {
+          console.error("[startPathDrawing] \u8FDB\u5165\u7F16\u8F91\u6A21\u5F0F\u5931\u8D25:", error);
         }
-      } catch {
       }
     }
   }, C.ScreenSpaceEventType.LEFT_CLICK);
   return {
     stop: () => {
-      for (const h of tempHandles) {
-        try {
-          layer.entities.remove(h);
-        } catch {
-        }
-      }
       try {
         handler?.destroy();
       } catch {
       }
+      if (editSession) {
+        try {
+          editSession.stop();
+        } catch {
+        }
+      }
       if (createdEntity) {
         try {
           layer.entities.remove(createdEntity);
@@ -6342,102 +6356,31 @@ function parsePoseFromAction(action) {
       result.roll = parsed.roll;
     }
     if (result.fov === void 0 && typeof parsed.fov === "number") {
-      result.fov = parsed.fov;
-    }
-    return result;
-  } catch (error) {
-    const numbers = action.match(/-?\d+\.?\d*/g);
-    if (numbers && numbers.length >= 4) {
-      return {
-        heading: parseFloat(numbers[0]),
-        pitch: parseFloat(numbers[1]),
-        roll: parseFloat(numbers[2]),
-        fov: parseFloat(numbers[3])
-      };
-    }
-    return {};
-  }
-}
-function parseCoordinate(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const parsed = parseFloat(value);
-    return isNaN(parsed) ? 0 : parsed;
-  }
-  return 0;
-}
-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;
-    }
-    if (typeof parsed.longitude === "number") {
-      longitude = parsed.longitude;
-    } else if (typeof parsed.lon === "number") {
-      longitude = parsed.lon;
-    } else {
-      return null;
-    }
-    if (typeof parsed.latitude === "number") {
-      latitude = parsed.latitude;
-    } else if (typeof parsed.lat === "number") {
-      latitude = parsed.lat;
-    } else {
-      return null;
-    }
-    if (typeof parsed.height === "number") {
-      height = parsed.height;
-    } else {
-      height = takeOffSecurityHeight;
-    }
-    const startPosition = C.Cartesian3.fromDegrees(longitude, latitude, height);
-    const climbPosition = C.Cartesian3.fromDegrees(
-      longitude,
-      latitude,
-      height + takeOffSecurityHeight
-    );
-    return {
-      startPosition,
-      climbPosition
-    };
+      result.fov = parsed.fov;
+    }
+    return result;
   } catch (error) {
-    return null;
+    const numbers = action.match(/-?\d+\.?\d*/g);
+    if (numbers && numbers.length >= 4) {
+      return {
+        heading: parseFloat(numbers[0]),
+        pitch: parseFloat(numbers[1]),
+        roll: parseFloat(numbers[2]),
+        fov: parseFloat(numbers[3])
+      };
+    }
+    return {};
+  }
+}
+function parseCoordinate(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = parseFloat(value);
+    return isNaN(parsed) ? 0 : parsed;
   }
+  return 0;
 }
 function convertSinoflyWayline(data, options) {
   const {
@@ -6461,11 +6404,6 @@ function convertSinoflyWayline(data, options) {
   if (data.waylineId === void 0 || data.waylineId === null) {
     throw new Error("[sinoflyAdapter] waylineId \u4E0D\u80FD\u4E3A\u7A7A");
   }
-  const takeOffInfo = parseTakeOffRefPoint(
-    data.takeOffRefPoint,
-    data.takeOffSecurityHeight,
-    CesiumNS
-  );
   let waypoints = data.waypointInfo;
   if (filterWaypoint) {
     waypoints = waypoints.filter(filterWaypoint);
@@ -6473,31 +6411,6 @@ function convertSinoflyWayline(data, options) {
   if (sortByIndex) {
     waypoints = [...waypoints].sort((a, b) => a.index - b.index);
   }
-  const finalWaypointData = [];
-  if (takeOffInfo) {
-    finalWaypointData.push({
-      position: takeOffInfo.startPosition,
-      heading: defaultHeading,
-      pitch: defaultPitch,
-      roll: defaultRoll,
-      fov: defaultFov,
-      index: 0
-    });
-    finalWaypointData.push({
-      position: takeOffInfo.climbPosition,
-      heading: defaultHeading,
-      pitch: defaultPitch,
-      roll: defaultRoll,
-      fov: defaultFov,
-      index: 1
-    });
-  }
-  let waypointStartIndex;
-  if (takeOffInfo) {
-    waypointStartIndex = 2;
-  } else {
-    waypointStartIndex = 0;
-  }
   const convertedWaypoints = waypoints.map((wp, idx) => {
     try {
       if (!wp) {
@@ -6533,15 +6446,16 @@ function convertSinoflyWayline(data, options) {
         pitch,
         roll,
         fov,
-        index: waypointStartIndex + idx
-        // 重新分配 index，从 waypointStartIndex 开始
+        index: idx,
+        // 从 0 开始分配 index
+        useGlobalHeight: false
+        // 🆕 从服务端加载的航点默认使用实际高度
       };
     } catch (error) {
       throw new Error(`\u822A\u70B9 ${idx} \u8F6C\u6362\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
-  const waypointData = [...finalWaypointData, ...convertedWaypoints];
-  if (!Array.isArray(waypointData)) {
+  if (!Array.isArray(convertedWaypoints)) {
     throw new Error("[sinoflyAdapter] waypointData \u4E0D\u662F\u6570\u7EC4");
   }
   const metadata = {
@@ -6552,8 +6466,8 @@ function convertSinoflyWayline(data, options) {
     autoFlightSpeed: data.autoFlightSpeed,
     distance: data.distance,
     duration: data.duration,
-    takeOffSecurityHeight: data.takeOffSecurityHeight,
-    hasTakeOffRefPoint: !!takeOffInfo
+    climbHeight: data.takeOffSecurityHeight
+    // 使用 climbHeight 作为字段名
   };
   if (data.stationId !== void 0) metadata.stationId = data.stationId;
   if (data.subarrayId !== void 0) metadata.subarrayId = data.subarrayId;
@@ -6563,7 +6477,7 @@ function convertSinoflyWayline(data, options) {
     id: `wayline-${data.waylineId}`,
     name: data.waylineName || `\u822A\u7EBF-${data.waylineId}`,
     description: `\u822A\u7EBFID: ${data.waylineId}, \u7C7B\u578B: ${data.waylineType}, \u822A\u70B9\u6570: ${data.waypointNumber}`,
-    waypointData,
+    waypointData: convertedWaypoints,
     metadata
   };
 }
@@ -6594,7 +6508,6 @@ function renderFlightPath(CesiumNS, viewer, options) {
   let entityId;
   let entityName;
   let entityDescription;
-  let hasHiddenClimb;
   let altitudeMode;
   let climbHeight;
   try {
@@ -6610,12 +6523,8 @@ function renderFlightPath(CesiumNS, viewer, options) {
     entityId = options.id ?? converted.id ?? `wayline-${sinoflyData.waylineId}`;
     entityName = options.name ?? converted.name;
     entityDescription = options.description ?? converted.description;
-    const sortedWaypoints2 = [...waypointData].sort((a, b) => a.index - b.index);
-    const hasIndex1 = sortedWaypoints2.some((wp) => wp.index === 1);
-    const hasTakeOffRefPoint = converted.metadata?.hasTakeOffRefPoint ?? !!sinoflyData.takeOffRefPoint;
-    hasHiddenClimb = options.hasHiddenClimb ?? (hasTakeOffRefPoint && hasIndex1);
     altitudeMode = options.altitudeMode ?? converted.metadata?.altitudeMode;
-    climbHeight = options.climbHeight ?? converted.metadata?.climbHeight ?? converted.metadata?.takeOffSecurityHeight;
+    climbHeight = options.climbHeight ?? converted.metadata?.climbHeight;
   } catch (error) {
     console.error("[renderFlightPath] Sinofly \u6570\u636E\u8F6C\u6362\u5931\u8D25:", error);
     throw new Error(`Sinofly \u6570\u636E\u8F6C\u6362\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`);
@@ -6637,66 +6546,25 @@ function renderFlightPath(CesiumNS, viewer, options) {
     layer = new C.CustomDataSource(`flight-path-datasource-${Date.now()}`);
     viewer.dataSources.add(layer);
   }
-  const hiddenClimbIndex = hasHiddenClimb && positions.length >= 2 ? 1 : void 0;
-  const hasStartPoint = positions.length > 0 && sortedWaypoints.some((wp) => wp.index === 0);
+  const hiddenClimbIndex = void 0;
+  const useGlobalHeightFlags = sortedWaypoints.map((wp) => wp.useGlobalHeight ?? false);
   const entity = layer.entities.add({
     id: entityId,
     name: entityName,
     description: entityDescription,
     polyline: {
       positions: positions.slice(),
-      width: options.style?.width ?? 8,
-      material: options.style?.material ?? options.style?.color ?? new C.PolylineOutlineMaterialProperty({
-        color: C.Color.GREEN,
-        outlineColor: C.Color.WHITE,
-        outlineWidth: 3
-      }),
+      width: options.style?.width ?? 3,
+      material: options.style?.material ?? options.style?.color ?? C.Color.fromCssColorString("#00E676"),
       clampToGround: false
     },
     properties: {
       _altitudeMode: altitudeMode,
       _climbHeight: climbHeight,
-      _hasHiddenClimb: hasHiddenClimb
+      _useGlobalHeightFlags: useGlobalHeightFlags
+      // 🆕 保存 useGlobalHeightFlags
     }
   });
-  const shouldShowArrow = hasStartPoint && hasHiddenClimb;
-  if (shouldShowArrow) {
-    try {
-      const startPosition = positions[0];
-      const carto = C.Cartographic.fromCartesian(startPosition);
-      const baseHeight = carto ? carto.height : 0;
-      const arrowShape = new ArrowShape(CesiumNS, {
-        shaftHeight: 12,
-        headHeight: 12,
-        shaftRadius: 4,
-        headRadius: 8,
-        baseRadius: 12,
-        color: "#FFD700",
-        shaftAlpha: 0.98,
-        headAlpha: 0.98,
-        baseAlpha: 0.65,
-        // 启用动态缩放
-        dynamicScale: true,
-        viewer,
-        referenceDistance: 300,
-        minScale: 0.3,
-        maxScale: 2
-      });
-      arrowShape.createEntities(
-        layer,
-        startPosition,
-        baseHeight,
-        {
-          _type: "path-vertex",
-          _ownerId: entityId,
-          _vertexIndex: 0,
-          _isStart: true
-        }
-      );
-    } catch (error) {
-      console.error("Failed to create start arrow:", error);
-    }
-  }
   try {
     const vertexLabelManager = new VertexLabelManager(
       CesiumNS,
@@ -6737,8 +6605,6 @@ function renderFlightPathPreview(CesiumNS, viewer, options) {
   } 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();
@@ -6758,14 +6624,7 @@ function renderFlightPathPreview(CesiumNS, viewer, options) {
         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;
-          }
+          const displayIndex = vertexIndex;
           selectedWaypointIndex = vertexIndex;
           updateWaypointHighlight(selectedWaypointIndex);
           if (options.onWaypointClick) {
@@ -6783,18 +6642,10 @@ function renderFlightPathPreview(CesiumNS, viewer, options) {
         updateWaypointHighlight(null);
         return;
       }
-      let actualIndex = index;
-      if (hiddenClimbIndex === 1) {
-        actualIndex = index + 2;
-      }
-      selectedWaypointIndex = actualIndex;
+      selectedWaypointIndex = index;
       updateWaypointHighlight(selectedWaypointIndex);
     },
     getSelectedWaypoint: () => {
-      if (selectedWaypointIndex === null) return null;
-      if (hiddenClimbIndex === 1) {
-        return selectedWaypointIndex >= 2 ? selectedWaypointIndex - 2 : null;
-      }
       return selectedWaypointIndex;
     },
     destroy: () => {
@@ -6804,6 +6655,299 @@ function renderFlightPathPreview(CesiumNS, viewer, options) {
   return { entity, controller };
 }
 
+// src/core/path-manager/FlightSimulator.ts
+var FlightSimulator = class {
+  constructor(CesiumNS, viewer, options) {
+    __publicField(this, "CesiumNS");
+    __publicField(this, "viewer");
+    __publicField(this, "options");
+    __publicField(this, "state", "idle");
+    __publicField(this, "progress", 0);
+    __publicField(this, "waypoints", []);
+    __publicField(this, "totalDistance", 0);
+    __publicField(this, "currentDistance", 0);
+    __publicField(this, "airplaneCursor");
+    __publicField(this, "trackEntity");
+    __publicField(this, "passedTrackEntity");
+    __publicField(this, "animationFrameId");
+    __publicField(this, "lastTimestamp");
+    __publicField(this, "onStateChange", new Emitter());
+    /**
+     * 动画循环
+     */
+    __publicField(this, "animate", (timestamp) => {
+      if (this.state !== "playing") return;
+      if (this.lastTimestamp === void 0) {
+        this.lastTimestamp = timestamp;
+      }
+      const deltaTime = (timestamp - this.lastTimestamp) / 1e3;
+      this.lastTimestamp = timestamp;
+      this.currentDistance += this.options.speed * deltaTime;
+      if (this.currentDistance >= this.totalDistance) {
+        if (this.options.loop) {
+          this.currentDistance = 0;
+        } else {
+          this.currentDistance = this.totalDistance;
+          this.setState("stopped");
+          return;
+        }
+      }
+      this.progress = this.totalDistance > 0 ? this.currentDistance / this.totalDistance : 0;
+      if (this.airplaneCursor) {
+        const position = this.getCurrentPosition();
+        const { heading, pitch, roll } = this.getCurrentPose();
+        this.airplaneCursor.setPose(position, heading, pitch, roll);
+      }
+      this.viewer.scene.requestRender();
+      this.animationFrameId = requestAnimationFrame(this.animate);
+    });
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    this.options = {
+      waylineData: options.waylineData,
+      speed: options.speed ?? 10,
+      loop: options.loop ?? false,
+      showFrustum: options.showFrustum ?? true,
+      layer: options.layer,
+      trackHighlight: options.trackHighlight
+    };
+    this.initWaypoints();
+    this.createEntities();
+  }
+  /**
+   * 初始化航点数据
+   */
+  initWaypoints() {
+    const C = this.CesiumNS;
+    const converted = convertSinoflyWayline(this.options.waylineData, { CesiumNS: this.CesiumNS });
+    if (!converted.waypointData || converted.waypointData.length < 2) {
+      console.warn("[FlightSimulator] \u822A\u70B9\u6570\u91CF\u4E0D\u8DB3");
+      return;
+    }
+    const tempWaypoints = converted.waypointData.map((wp) => ({
+      cartesian: wp.position,
+      heading: wp.heading ?? 0,
+      pitch: wp.pitch ?? 0,
+      roll: wp.roll ?? 0,
+      cumulativeDistance: 0
+    }));
+    let cumulativeDistance = 0;
+    for (let i = 0; i < tempWaypoints.length; i++) {
+      if (i > 0) {
+        const prevCartesian = tempWaypoints[i - 1].cartesian;
+        const currCartesian = tempWaypoints[i].cartesian;
+        cumulativeDistance += C.Cartesian3.distance(prevCartesian, currCartesian);
+      }
+      tempWaypoints[i].cumulativeDistance = cumulativeDistance;
+    }
+    this.waypoints = tempWaypoints;
+    this.totalDistance = cumulativeDistance;
+  }
+  /**
+   * 创建可视化实体
+   */
+  createEntities() {
+    if (this.waypoints.length === 0) return;
+    const firstWaypoint = this.waypoints[0];
+    this.airplaneCursor = new AirplaneCursor(
+      this.CesiumNS,
+      this.viewer,
+      firstWaypoint.cartesian,
+      {
+        // 禁用键盘控制（仿真模式下不需要手动控制）
+        stepMeters: 0,
+        angleStepDeg: 0,
+        fovDeg: 50
+      }
+    );
+    this.airplaneCursor.setPose(
+      firstWaypoint.cartesian,
+      firstWaypoint.heading,
+      firstWaypoint.pitch,
+      firstWaypoint.roll
+    );
+    if (this.options.trackHighlight?.enabled) {
+      this.createTrackHighlight();
+    }
+  }
+  /**
+   * 创建航迹高亮
+   */
+  createTrackHighlight() {
+    const C = this.CesiumNS;
+    const entities = this.options.layer?.entities ?? this.viewer.entities;
+    const highlightOpts = this.options.trackHighlight;
+    const allPositions = this.waypoints.map((wp) => wp.cartesian);
+    this.trackEntity = entities.add({
+      id: `flight-simulator-track-${Date.now()}`,
+      polyline: {
+        positions: allPositions,
+        width: highlightOpts.width ?? 4,
+        material: (highlightOpts.color ?? C.Color.CYAN).withAlpha(0.3),
+        clampToGround: false
+      },
+      properties: {
+        _type: "flight-simulator-track"
+      }
+    });
+    this.passedTrackEntity = entities.add({
+      id: `flight-simulator-passed-track-${Date.now()}`,
+      polyline: {
+        positions: new C.CallbackProperty(() => this.getPassedPositions(), false),
+        width: (highlightOpts.width ?? 4) + 2,
+        material: highlightOpts.color ?? C.Color.CYAN,
+        clampToGround: false
+      },
+      properties: {
+        _type: "flight-simulator-passed-track"
+      }
+    });
+  }
+  /**
+   * 获取当前位置
+   */
+  getCurrentPosition() {
+    if (this.waypoints.length === 0) {
+      return this.CesiumNS.Cartesian3.ZERO;
+    }
+    const C = this.CesiumNS;
+    for (let i = 1; i < this.waypoints.length; i++) {
+      const prev = this.waypoints[i - 1];
+      const curr = this.waypoints[i];
+      if (this.currentDistance <= curr.cumulativeDistance) {
+        const segmentStart = prev.cumulativeDistance;
+        const segmentEnd = curr.cumulativeDistance;
+        const segmentLength = segmentEnd - segmentStart;
+        if (segmentLength <= 0) {
+          return prev.cartesian;
+        }
+        const t = (this.currentDistance - segmentStart) / segmentLength;
+        return C.Cartesian3.lerp(prev.cartesian, curr.cartesian, t, new C.Cartesian3());
+      }
+    }
+    return this.waypoints[this.waypoints.length - 1].cartesian;
+  }
+  /**
+   * 获取当前姿态（用于更新 AirplaneCursor）
+   */
+  getCurrentPose() {
+    const C = this.CesiumNS;
+    let heading = 0;
+    let pitch = 0;
+    let roll = 0;
+    for (let i = 1; i < this.waypoints.length; i++) {
+      const prev = this.waypoints[i - 1];
+      const curr = this.waypoints[i];
+      if (this.currentDistance <= curr.cumulativeDistance) {
+        const segmentStart = prev.cumulativeDistance;
+        const segmentEnd = curr.cumulativeDistance;
+        const segmentLength = segmentEnd - segmentStart;
+        if (segmentLength > 0) {
+          const t = (this.currentDistance - segmentStart) / segmentLength;
+          heading = C.Math.lerp(prev.heading, curr.heading, t);
+          pitch = C.Math.lerp(prev.pitch, curr.pitch, t);
+          roll = C.Math.lerp(prev.roll, curr.roll, t);
+        } else {
+          heading = prev.heading;
+          pitch = prev.pitch;
+          roll = prev.roll;
+        }
+        break;
+      }
+    }
+    return { heading, pitch, roll };
+  }
+  /**
+   * 获取已飞过的位置数组
+   */
+  getPassedPositions() {
+    const positions = [];
+    for (let i = 0; i < this.waypoints.length; i++) {
+      const wp = this.waypoints[i];
+      if (wp.cumulativeDistance <= this.currentDistance) {
+        positions.push(wp.cartesian);
+      } else {
+        positions.push(this.getCurrentPosition());
+        break;
+      }
+    }
+    return positions;
+  }
+  /**
+   * 设置状态并发射事件
+   */
+  setState(newState) {
+    if (this.state === newState) return;
+    this.state = newState;
+    this.onStateChange.emit({ state: newState, progress: this.progress });
+  }
+  // ==================== 公共方法 ====================
+  start() {
+    if (this.waypoints.length < 2) {
+      console.warn("[FlightSimulator] \u822A\u70B9\u6570\u91CF\u4E0D\u8DB3\uFF0C\u65E0\u6CD5\u5F00\u59CB\u4EFF\u771F");
+      return;
+    }
+    this.currentDistance = 0;
+    this.progress = 0;
+    this.lastTimestamp = void 0;
+    this.setState("playing");
+    this.animationFrameId = requestAnimationFrame(this.animate);
+  }
+  pause() {
+    if (this.state !== "playing") return;
+    if (this.animationFrameId !== void 0) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = void 0;
+    }
+    this.lastTimestamp = void 0;
+    this.setState("paused");
+  }
+  resume() {
+    if (this.state !== "paused") return;
+    this.lastTimestamp = void 0;
+    this.setState("playing");
+    this.animationFrameId = requestAnimationFrame(this.animate);
+  }
+  stop() {
+    if (this.animationFrameId !== void 0) {
+      cancelAnimationFrame(this.animationFrameId);
+      this.animationFrameId = void 0;
+    }
+    this.currentDistance = 0;
+    this.progress = 0;
+    this.lastTimestamp = void 0;
+    this.setState("stopped");
+    this.viewer.scene.requestRender();
+  }
+  destroy() {
+    this.stop();
+    const entities = this.options.layer?.entities ?? this.viewer.entities;
+    if (this.airplaneCursor) {
+      this.airplaneCursor.destroy();
+      this.airplaneCursor = void 0;
+    }
+    if (this.trackEntity) {
+      entities.remove(this.trackEntity);
+      this.trackEntity = void 0;
+    }
+    if (this.passedTrackEntity) {
+      entities.remove(this.passedTrackEntity);
+      this.passedTrackEntity = void 0;
+    }
+    this.waypoints = [];
+    this.setState("idle");
+  }
+  setSpeed(speed) {
+    this.options.speed = Math.max(0.1, speed);
+  }
+  getState() {
+    return this.state;
+  }
+  getProgress() {
+    return this.progress;
+  }
+};
+
 // src/core/CZMLPathManager.ts
 var _CZMLPathManager = class _CZMLPathManager {
   constructor(CesiumNS, viewer) {
@@ -7080,6 +7224,20 @@ var _CZMLPathManager = class _CZMLPathManager {
       options
     );
   }
+  /**
+   * Start flight simulation/preview for a wayline.
+   * Animates an aircraft model along the wayline path with controls for play/pause/stop.
+   * @param options - Configuration for the flight simulator
+   * @returns A controller object with start/pause/resume/stop/destroy methods
+   */
+  startFlightPreview(options) {
+    const simulator = new FlightSimulator(
+      this.CesiumNS,
+      this.viewer,
+      options
+    );
+    return simulator;
+  }
   // ensureLayerForEntity moved into path-editing module
 };
 __publicField(_CZMLPathManager, "SAMPLES_KEY", "__czmlPathSamples__");
@@ -10731,6 +10889,226 @@ var Selector = class {
   }
 };
 
+// src/core/PointCloudPicker.ts
+var PointCloudPicker = class {
+  constructor(CesiumNS, viewer) {
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    __publicField(this, "handler");
+    __publicField(this, "markerEntity");
+    __publicField(this, "isPaused", false);
+  }
+  /**
+   * 在指定屏幕位置进行一次点云拾取
+   * @param windowPosition 屏幕坐标 { x, y }
+   * @param options 拾取选项
+   * @returns 拾取结果
+   */
+  pickAt(windowPosition, options) {
+    const C = this.CesiumNS;
+    const scene = this.viewer.scene;
+    const fetchProperties = options?.fetchProperties ?? true;
+    const pointCloudOnly = options?.pointCloudOnly ?? true;
+    const picked = scene.pick(windowPosition);
+    let tileset;
+    let content;
+    let featureId;
+    if (picked) {
+      if (picked.primitive instanceof C.Cesium3DTileset) {
+        tileset = picked.primitive;
+      } else if (picked.tileset instanceof C.Cesium3DTileset) {
+        tileset = picked.tileset;
+      }
+      if (picked.content) {
+        content = picked.content;
+      }
+      if (typeof picked.featureId === "number") {
+        featureId = picked.featureId;
+      }
+    }
+    if (pointCloudOnly && !tileset) {
+      return { success: false, screenPosition: windowPosition };
+    }
+    let position;
+    if (scene.pickPositionSupported) {
+      try {
+        position = scene.pickPosition(windowPosition);
+      } catch {
+      }
+    }
+    if (!position || !C.defined(position)) {
+      try {
+        const ray = this.viewer.camera.getPickRay(windowPosition);
+        if (ray) {
+          position = scene.globe?.pick(ray, scene);
+        }
+      } catch {
+      }
+    }
+    if (!position || !C.defined(position)) {
+      return { success: false, screenPosition: windowPosition, tileset };
+    }
+    let coordinates;
+    try {
+      const cartographic = C.Cartographic.fromCartesian(position);
+      coordinates = {
+        longitude: C.Math.toDegrees(cartographic.longitude),
+        latitude: C.Math.toDegrees(cartographic.latitude),
+        height: cartographic.height
+      };
+    } catch {
+    }
+    let properties;
+    let color;
+    if (fetchProperties && content && featureId !== void 0) {
+      try {
+        const feature = content.getFeature?.(featureId);
+        if (feature) {
+          properties = {};
+          const propertyIds = feature.getPropertyIds?.() ?? [];
+          for (const propId of propertyIds) {
+            try {
+              properties[propId] = feature.getProperty(propId);
+            } catch {
+            }
+          }
+          try {
+            const c = feature.color;
+            if (c) {
+              color = {
+                red: c.red,
+                green: c.green,
+                blue: c.blue,
+                alpha: c.alpha
+              };
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      position,
+      coordinates,
+      tileset,
+      content,
+      featureId,
+      properties,
+      color,
+      screenPosition: windowPosition
+    };
+  }
+  /**
+   * 开启点云拾取会话
+   * @param onPick 拾取回调函数
+   * @param options 拾取选项
+   * @returns 拾取会话对象
+   */
+  startPicking(onPick, options) {
+    const C = this.CesiumNS;
+    const canvas = this.viewer.scene.canvas;
+    const prevCursor = canvas?.style?.cursor;
+    const cursor = options?.cursor ?? "crosshair";
+    if (canvas) canvas.style.cursor = cursor;
+    this.handler = new C.ScreenSpaceEventHandler(canvas);
+    this.isPaused = false;
+    const showMarker = options?.showMarker ?? true;
+    const markerColor = options?.markerColor ?? C.Color.YELLOW;
+    const markerSize = options?.markerSize ?? 10;
+    const handler = this.handler;
+    if (handler) {
+      handler.setInputAction(
+        (movement) => {
+          if (this.isPaused) return;
+          const result = this.pickAt(movement.position, {
+            fetchProperties: options?.fetchProperties ?? true,
+            pointCloudOnly: options?.pointCloudOnly ?? true
+          });
+          if (showMarker && result.success && result.position) {
+            this.showMarker(result.position, markerColor, markerSize);
+          }
+          onPick(result);
+        },
+        C.ScreenSpaceEventType.LEFT_CLICK
+      );
+    }
+    return {
+      stop: () => {
+        this.stopPicking();
+        if (canvas) canvas.style.cursor = prevCursor ?? "";
+      },
+      pause: () => {
+        this.isPaused = true;
+      },
+      resume: () => {
+        this.isPaused = false;
+      },
+      isPaused: () => this.isPaused
+    };
+  }
+  /**
+   * 停止拾取会话
+   */
+  stopPicking() {
+    try {
+      this.handler?.destroy();
+    } catch {
+    }
+    this.handler = void 0;
+    this.removeMarker();
+  }
+  /**
+   * 显示标记点
+   */
+  showMarker(position, color, size) {
+    const C = this.CesiumNS;
+    this.removeMarker();
+    this.markerEntity = this.viewer.entities.add({
+      position,
+      point: {
+        pixelSize: size,
+        color,
+        outlineColor: C.Color.WHITE,
+        outlineWidth: 2,
+        disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        heightReference: C.HeightReference.NONE
+      }
+    });
+  }
+  /**
+   * 移除标记点
+   */
+  removeMarker() {
+    if (this.markerEntity) {
+      try {
+        this.viewer.entities.remove(this.markerEntity);
+      } catch {
+      }
+      this.markerEntity = void 0;
+    }
+  }
+  /**
+   * 获取当前标记点位置
+   */
+  getMarkerPosition() {
+    if (!this.markerEntity) return void 0;
+    const pos = this.markerEntity.position;
+    if (typeof pos?.getValue === "function") {
+      return pos.getValue(this.CesiumNS.JulianDate.now());
+    }
+    return pos;
+  }
+  /**
+   * 销毁拾取器
+   */
+  destroy() {
+    this.stopPicking();
+    this.removeMarker();
+  }
+};
+
 // src/utils/pathToSinoflyAdapter.ts
 function convertCartesian3ToLatLonHeight(CesiumNS, position) {
   const C = CesiumNS;
@@ -10809,23 +11187,6 @@ function convertPoseToActionGroup(heading, pitch, roll, fov, waypointIndex) {
     return "{}";
   }
 }
-function convertStartPointToTakeOffRefPoint(CesiumNS, position) {
-  const C = CesiumNS;
-  try {
-    const cartographic = C.Cartographic.fromCartesian(position);
-    const longitude = C.Math.toDegrees(cartographic.longitude);
-    const latitude = C.Math.toDegrees(cartographic.latitude);
-    const height = cartographic.height;
-    return JSON.stringify({
-      longitude,
-      latitude,
-      height
-    });
-  } catch (error) {
-    console.error("[pathToSinoflyAdapter] takeOffRefPoint \u751F\u6210\u5931\u8D25:", error);
-    return "";
-  }
-}
 function convertPathToSinofly(data, options) {
   const {
     CesiumNS,
@@ -10869,10 +11230,6 @@ function convertPathToSinofly(data, options) {
   }
   const distance = data.waypointData[data.waypointData.length - 1]?.distance ?? 0;
   const takeOffSecurityHeight = data.climbHeight ?? 0;
-  let takeOffRefPoint;
-  if (data.hasHiddenClimb && data.startPoint?.position) {
-    takeOffRefPoint = convertStartPointToTakeOffRefPoint(CesiumNS, data.startPoint.position);
-  }
   const waypointInfo = data.waypointData.map((wp, idx) => {
     const newIndex = idx;
     const { latitude, longitude, altitude } = convertCartesian3ToLatLonHeight(
@@ -10889,7 +11246,11 @@ function convertPathToSinofly(data, options) {
       longitude,
       altitude,
       action,
-      noReturn: defaultNoReturn
+      noReturn: defaultNoReturn,
+      // 🆕 添加高度相关字段
+      ellipsoidHeight: wp.ellipsoidHeight,
+      relativeHeight: wp.relativeHeight,
+      useGlobalHeight: wp.useGlobalHeight
     };
     if (waypointCreateUserId) waypoint.createUserId = waypointCreateUserId;
     if (waypointCreateTime) waypoint.createTime = waypointCreateTime;
@@ -10917,7 +11278,6 @@ function convertPathToSinofly(data, options) {
     photoNumber,
     waypointInfo
   };
-  if (takeOffRefPoint) sinoflyData.takeOffRefPoint = takeOffRefPoint;
   if (thumbnailFileId !== void 0) sinoflyData.thumbnailFileId = thumbnailFileId;
   if (stationId !== void 0) sinoflyData.stationId = stationId;
   if (subarrayId !== void 0) sinoflyData.subarrayId = subarrayId;
@@ -11321,14 +11681,18 @@ exports.CameraEventBus = CameraEventBus;
 exports.CameraFOVController = CameraFOVController;
 exports.CameraManager = CameraManager;
 exports.Emitter = Emitter;
+exports.FlightSimulator = FlightSimulator;
 exports.FrustumPyramid = FrustumPyramid;
 exports.LayerManager = LayerManager;
 exports.PathSafetyChecker = PathSafetyChecker;
+exports.PointCloudPicker = PointCloudPicker;
 exports.PolygonEditor = PolygonEditor;
 exports.SceneManager = SceneManager;
 exports.Selector = Selector;
 exports.StateManager = StateManager;
 exports.assertCesiumAssetsConfigured = assertCesiumAssetsConfigured;
+exports.calculateAbsoluteHeight = calculateAbsoluteHeight;
+exports.calculateRelativeHeight = calculateRelativeHeight;
 exports.configureCesiumAssets = configureCesiumAssets;
 exports.configureCesiumIonToken = configureCesiumIonToken;
 exports.convertPathToSinofly = convertPathToSinofly;
@@ -11340,6 +11704,9 @@ exports.getCesiumIonToken = getCesiumIonToken;
 exports.globalCameraEventBus = globalCameraEventBus;
 exports.globalState = globalState;
 exports.placeholder = placeholder;
+exports.queryTerrainHeightAsync = queryTerrainHeightAsync;
+exports.queryTerrainHeightSync = queryTerrainHeightSync;
+exports.queryTerrainHeights = queryTerrainHeights;
 exports.renderFlightPath = renderFlightPath;
 exports.renderFlightPathPreview = renderFlightPathPreview;
 exports.toggle2D3D = toggle2D3D;