@jorgmoritz/gis-manager 0.1.43 → 0.1.45

package/dist/index.cjs

@@ -13,7 +13,7 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // package.json
 var package_default = {
   name: "@jorgmoritz/gis-manager",
-  version: "0.1.42"};
+  version: "0.1.44"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -2004,14 +2004,15 @@ var HeightMarker = class {
       polyline: {
         positions: [C.Cartesian3.ZERO, C.Cartesian3.ZERO],
         width: this.opts.width ?? 2,
-        material: color,
+        material: C.Color.YELLOW.withAlpha(0.4),
+        // 黄色半透明垂直线
         clampToGround: false
         // vertical line in 3D space
       },
       ellipse: {
-        semiMajorAxis: this.opts.circleRadius ?? 5,
-        semiMinorAxis: this.opts.circleRadius ?? 5,
-        material: color.withAlpha ? color.withAlpha(0.65) : color,
+        semiMajorAxis: this.opts.circleRadius ?? 3,
+        semiMinorAxis: this.opts.circleRadius ?? 3,
+        material: color.withAlpha ? color.withAlpha(0.45) : color,
         outline: true,
         outlineColor: color,
         heightReference: C.HeightReference.CLAMP_TO_GROUND
@@ -2022,12 +2023,13 @@ var HeightMarker = class {
       position: C.Cartesian3.ZERO,
       label: {
         text: "",
-        font: "14px sans-serif",
+        font: "10px sans-serif",
+        // 字体改小
         style: C.LabelStyle.FILL_AND_OUTLINE,
         fillColor: C.Color.BLACK,
         outlineColor: C.Color.WHITE,
-        outlineWidth: 3,
-        pixelOffset: new C.Cartesian2(0, -6),
+        outlineWidth: 2,
+        pixelOffset: new C.Cartesian2(0, -4),
         showBackground: false,
         horizontalOrigin: C.HorizontalOrigin.CENTER,
         verticalOrigin: C.VerticalOrigin.BOTTOM,
@@ -3553,6 +3555,10 @@ var AirplaneCursor = class {
     __publicField(this, "cachedScaleFactor", 1);
     // 相机变化事件监听器
     __publicField(this, "cameraChangedListener");
+    /** 飞机游标模型可见性，默认 false */
+    __publicField(this, "visible", false);
+    /** 是否显示视锥体，默认 true */
+    __publicField(this, "showFrustum", true);
     const C = this.CesiumNS;
     this.opts = opts;
     this.pose = { position: startPosition, heading: 0, pitch: -10, roll: 0 };
@@ -3560,6 +3566,8 @@ var AirplaneCursor = class {
     this.angleStep = opts.angleStepDeg ?? 1;
     this.fastFactor = opts.fastFactor ?? 5;
     this.currentFOV = opts.fovDeg ?? DEFAULT_FOV;
+    this.visible = opts.visible ?? false;
+    this.showFrustum = opts.showFrustum ?? true;
     this.ensureEntity(opts.color ?? C.Color.CYAN.withAlpha(0.9));
     this.attachKeyboard(opts);
     this.setupFOVListener();
@@ -3614,6 +3622,8 @@ var AirplaneCursor = class {
         runAnimations: true,
         clampAnimations: false
       },
+      show: this.visible,
+      // 根据 visible 设置初始显示状态
       properties: { _type: "airplane-cursor" }
     });
     this.entity = this.modelEntity;
@@ -3791,6 +3801,7 @@ var AirplaneCursor = class {
    * - 后续只依赖回调读取 pose 与 currentFOV 即可自动更新
    */
   updateFrustum() {
+    if (!this.showFrustum) return;
     try {
       if (!this.frustum) {
         let layer = this.viewer.dataSources?._dataSources?.[0];
@@ -3841,6 +3852,18 @@ var AirplaneCursor = class {
       altitude
     };
   }
+  /** 设置飞机游标可见性 */
+  setVisible(visible) {
+    this.visible = visible;
+    if (this.modelEntity) {
+      this.modelEntity.show = visible;
+    }
+    this.viewer.scene?.requestRender?.();
+  }
+  /** 获取当前可见性状态 */
+  isVisible() {
+    return this.visible;
+  }
   /** 获取内部实体（用于拾取识别） */
   getEntity() {
     return this.entity;
@@ -5070,6 +5093,44 @@ function calculateRelativeHeight(altitudeMode, absoluteHeight, startPointAltitud
   }
 }
 
+// src/utils/geometryUtils.ts
+function calculateDistanceAndMidpoint(CesiumNS, point1, point2) {
+  const C = CesiumNS;
+  const distance = C.Cartesian3.distance(point1, point2);
+  const midpoint = new C.Cartesian3();
+  C.Cartesian3.midpoint(point1, point2, midpoint);
+  return { distance, midpoint };
+}
+function calculateDistance(CesiumNS, point1, point2) {
+  const C = CesiumNS;
+  return C.Cartesian3.distance(point1, point2);
+}
+function calculateMidpoint(CesiumNS, point1, point2) {
+  const C = CesiumNS;
+  const midpoint = new C.Cartesian3();
+  C.Cartesian3.midpoint(point1, point2, midpoint);
+  return midpoint;
+}
+function calculateHeadingBetweenPoints(CesiumNS, point1, point2) {
+  const C = CesiumNS;
+  try {
+    const fromCarto = C.Cartographic.fromCartesian(point1);
+    const toCarto = C.Cartographic.fromCartesian(point2);
+    const deltaLon = toCarto.longitude - fromCarto.longitude;
+    let heading = Math.atan2(
+      Math.sin(deltaLon) * Math.cos(toCarto.latitude),
+      Math.cos(fromCarto.latitude) * Math.sin(toCarto.latitude) - Math.sin(fromCarto.latitude) * Math.cos(toCarto.latitude) * Math.cos(deltaLon)
+    );
+    heading = C.Math.toDegrees(heading);
+    if (heading > 180) heading -= 360;
+    if (heading < -180) heading += 360;
+    return heading;
+  } catch (error) {
+    console.error("[calculateHeadingBetweenPoints] Error:", error);
+    return 0;
+  }
+}
+
 // src/core/path-manager/editing/PathEditingEventHandler.ts
 var PathEditingEventHandler = class {
   constructor(options, callbacks) {
@@ -5130,36 +5191,14 @@ var PathEditingEventHandler = class {
         if (typeof index === "number") {
           if (currentActiveIndex === index) {
             this.vertexDragHandler.startDrag(index, movement.position);
-          } else {
-            if (this.callbacks.onVertexSelect) {
-              this.callbacks.onVertexSelect(index);
-            }
-            console.log("[PathEditingEventHandler] \u9876\u70B9\u88AB\u70B9\u51FB\uFF0C\u7D22\u5F15:", index, "\u56DE\u8C03\u5B58\u5728:", !!this.callbacks.onVertexSelectDetail);
-            if (this.callbacks.onVertexSelectDetail) {
-              try {
-                const detailInfo = this.buildVertexDetailInfo(index);
-                console.log("[PathEditingEventHandler] \u8C03\u7528 onVertexSelectDetail \u56DE\u8C03");
-                this.callbacks.onVertexSelectDetail(detailInfo);
-              } catch (error) {
-                console.error("[PathEditingEventHandler] Error building vertex detail info:", error);
-              }
-            }
           }
           return;
         }
       }
       const idx = pickVertexIndex(this.viewer, movement.position, this.hiddenClimbIndex);
       if (typeof idx === "number") {
-        if (this.callbacks.onVertexSelect) {
-          this.callbacks.onVertexSelect(idx);
-        }
-        if (this.callbacks.onVertexSelectDetail) {
-          try {
-            const detailInfo = this.buildVertexDetailInfo(idx);
-            this.callbacks.onVertexSelectDetail(detailInfo);
-          } catch (error) {
-            console.error("Error building vertex detail info:", error);
-          }
+        if (currentActiveIndex === idx) {
+          this.vertexDragHandler.startDrag(idx, movement.position);
         }
       }
     }, C.ScreenSpaceEventType.LEFT_DOWN);
@@ -5178,6 +5217,26 @@ var PathEditingEventHandler = class {
       if (this.vertexDragHandler.isDragging()) {
         return;
       }
+      const scene = this.viewer.scene;
+      const picked = scene.pick?.(movement.position);
+      const entity = picked?.id;
+      if (entity?.properties?._type?.getValue?.() === "vertex-label") {
+        const labelIndex = entity.properties._vertexIndex?.getValue?.();
+        if (typeof labelIndex === "number") {
+          if (this.callbacks.onVertexSelect) {
+            this.callbacks.onVertexSelect(labelIndex);
+          }
+          if (this.callbacks.onVertexSelectDetail) {
+            try {
+              const detailInfo = this.buildVertexDetailInfo(labelIndex);
+              this.callbacks.onVertexSelectDetail(detailInfo);
+            } catch (error) {
+              console.error("Error building vertex detail info:", error);
+            }
+          }
+          return;
+        }
+      }
       const idx = pickVertexIndex(this.viewer, movement.position, this.hiddenClimbIndex);
       if (typeof idx === "number") {
         if (this.callbacks.onVertexSelect) {
@@ -5193,6 +5252,45 @@ var PathEditingEventHandler = class {
         }
         return;
       }
+      const CLICK_THRESHOLD_PIXELS = 25;
+      const positions = this.callbacks.getPositions?.() || [];
+      if (positions.length > 0) {
+        const clickPos = movement.position;
+        let minDistance = Infinity;
+        let nearestIndex = -1;
+        for (let i = 0; i < positions.length; i++) {
+          try {
+            const screenPos = C.SceneTransforms.wgs84ToWindowCoordinates(
+              scene,
+              positions[i]
+            );
+            if (screenPos) {
+              const dx = screenPos.x - clickPos.x;
+              const dy = screenPos.y - clickPos.y;
+              const distance = Math.sqrt(dx * dx + dy * dy);
+              if (distance < minDistance) {
+                minDistance = distance;
+                nearestIndex = i;
+              }
+            }
+          } catch {
+          }
+        }
+        if (minDistance < CLICK_THRESHOLD_PIXELS && nearestIndex >= 0) {
+          if (this.callbacks.onVertexSelect) {
+            this.callbacks.onVertexSelect(nearestIndex);
+          }
+          if (this.callbacks.onVertexSelectDetail) {
+            try {
+              const detailInfo = this.buildVertexDetailInfo(nearestIndex);
+              this.callbacks.onVertexSelectDetail(detailInfo);
+            } catch (error) {
+              console.error("Error building vertex detail info:", error);
+            }
+          }
+          return;
+        }
+      }
       const quickEditEnabled = this.callbacks.getQuickEditEnabled?.();
       if (quickEditEnabled) {
         this.handleQuickEditClick(movement);
@@ -5296,6 +5394,14 @@ var PathEditingEventHandler = class {
           this.handleInsertVertex(activeIndex + 1, pose, "after");
         }
       });
+      if (activeIndex < positions.length - 1) {
+        menuItems.push({
+          label: "\u5728\u4E2D\u95F4\u63D2\u5165\u822A\u70B9",
+          action: () => {
+            this.handleInsertMidpoint(activeIndex);
+          }
+        });
+      }
     } else if (pose && visibleVertexCount <= 1) {
       menuItems.push({
         label: "\u6DFB\u52A0\u7B2C\u4E00\u4E2A\u822A\u70B9",
@@ -5442,6 +5548,27 @@ var PathEditingEventHandler = class {
       });
     }
   }
+  /**
+   * 🆕 在选中航点和下一个航点中间插入新航点
+   */
+  handleInsertMidpoint(activeIndex) {
+    const positions = this.callbacks.getPositions?.() || [];
+    const poseData = this.callbacks.getPoseData?.();
+    if (activeIndex >= positions.length - 1) {
+      console.warn("[handleInsertMidpoint] \u9009\u4E2D\u822A\u70B9\u662F\u6700\u540E\u4E00\u4E2A\uFF0C\u65E0\u6CD5\u63D2\u5165\u4E2D\u70B9");
+      return;
+    }
+    const point1 = positions[activeIndex];
+    const point2 = positions[activeIndex + 1];
+    const { midpoint } = calculateDistanceAndMidpoint(this.CesiumNS, point1, point2);
+    const heading = calculateHeadingBetweenPoints(this.CesiumNS, point1, point2);
+    const pitch = poseData?.pitches[activeIndex] ?? -10;
+    const roll = poseData?.rolls[activeIndex] ?? 0;
+    console.log("[handleInsertMidpoint] \u5728\u7D22\u5F15", activeIndex, "\u548C", activeIndex + 1, "\u4E4B\u95F4\u63D2\u5165\u4E2D\u70B9");
+    if (this.callbacks.onInsertVertex) {
+      this.callbacks.onInsertVertex(activeIndex + 1, midpoint, { heading, pitch, roll });
+    }
+  }
   /**
    * 处理删除顶点
    */
@@ -5890,23 +6017,37 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   while (useGlobalHeightFlags.length < positions.length) {
     useGlobalHeightFlags.push(false);
   }
-  let quickEditEnabled = false;
+  const waypointIds = [];
+  if (options?.waypointIds && Array.isArray(options.waypointIds)) {
+    const offset = 0;
+    for (let i = 0; i < offset; i++) {
+      waypointIds[i] = void 0;
+    }
+    options.waypointIds.forEach((id, idx) => {
+      waypointIds[offset + idx] = id;
+    });
+  }
+  while (waypointIds.length < positions.length) {
+    waypointIds.push(void 0);
+  }
+  let quickEditEnabled = true;
   let quickEditOptions = {
-    enabled: false,
+    enabled: true,
     climbHeight: currentDefaultAltitude,
     // 使用当前默认高度
     altitudeMode: currentAltitudeMode
     // 使用当前高度模式
   };
-  if (options?.quickEdit) {
+  if (options?.quickEdit !== void 0) {
     if (typeof options.quickEdit === "boolean") {
       quickEditEnabled = options.quickEdit;
       quickEditOptions.enabled = options.quickEdit;
     } else {
-      quickEditEnabled = options.quickEdit.enabled ?? false;
+      quickEditEnabled = options.quickEdit.enabled ?? true;
       quickEditOptions = {
         ...quickEditOptions,
-        ...options.quickEdit
+        ...options.quickEdit,
+        enabled: options.quickEdit.enabled ?? true
       };
     }
   }
@@ -6001,6 +6142,8 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
   const stateManager = new PathStateManager(entity, positions, headings, pitches, rolls, fovs);
   let activeIndex;
   let editedIndices = /* @__PURE__ */ new Set();
+  let isUpdatingFromCursor = false;
+  let isUpdatingFromDrag = false;
   const handleStyleManager = new VertexHandleStyleManager(CesiumNS);
   const setActiveIndex = (idx) => {
     if (activeIndex !== void 0 && handles[activeIndex]) {
@@ -6106,6 +6249,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       useGlobalHeightFlags
       // 🆕 传递 useGlobalHeightFlags
     );
+    waypointIds.splice(actualIndex, 0, void 0);
     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);
@@ -6138,6 +6282,7 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       fovs.splice(deleteAt, 1);
       heightMarkers.splice(deleteAt, 1);
       useGlobalHeightFlags.splice(deleteAt, 1);
+      waypointIds.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();
@@ -6224,12 +6369,36 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
         }
         airplaneCursor.updateOptions({
           onPose: (pose) => {
+            if (isUpdatingFromDrag) return;
             try {
               if (preview) {
                 preview.setPose(pose.position, pose.heading, pose.pitch, pose.roll, 50);
               }
             } catch {
             }
+            if (activeIndex !== void 0 && !isUpdatingFromCursor) {
+              isUpdatingFromCursor = true;
+              try {
+                positions[activeIndex] = pose.position;
+                headings[activeIndex] = pose.heading;
+                pitches[activeIndex] = pose.pitch;
+                rolls[activeIndex] = pose.roll;
+                if (handles[activeIndex]) {
+                  handles[activeIndex].position = pose.position;
+                }
+                vertexLabelManager.updateLabelPosition(activeIndex, pose.position);
+                createOrUpdateMarkerForIndex(activeIndex);
+                editedIndices.add(activeIndex);
+                useGlobalHeightFlags[activeIndex] = false;
+                try {
+                  entity.polyline.positions = positions.slice();
+                } catch {
+                }
+                viewer.scene?.requestRender?.();
+              } finally {
+                isUpdatingFromCursor = false;
+              }
+            }
           }
         });
       }
@@ -6305,24 +6474,38 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       },
       onVertexDragMove: (index, newPosition) => {
         console.log("[PathEditing] onVertexDragMove \u88AB\u8C03\u7528, index:", index);
-        positions[index] = newPosition;
-        if (handles[index]) {
+        if (isUpdatingFromCursor) return;
+        isUpdatingFromDrag = true;
+        try {
+          positions[index] = newPosition;
+          if (handles[index]) {
+            try {
+              handles[index].position = newPosition;
+            } catch {
+            }
+          }
           try {
-            handles[index].position = newPosition;
+            vertexLabelManager.updateLabelPosition(index, newPosition);
           } catch {
           }
-        }
-        try {
-          vertexLabelManager.updateLabelPosition(index, newPosition);
-        } catch {
-        }
-        try {
-          entity.polyline.positions = positions.slice();
-        } catch {
-        }
-        try {
-          viewer.scene.requestRender();
-        } catch {
+          try {
+            entity.polyline.positions = positions.slice();
+          } catch {
+          }
+          try {
+            viewer.scene.requestRender();
+          } catch {
+          }
+          if (airplaneCursor && index === activeIndex) {
+            airplaneCursor.setPose(
+              newPosition,
+              headings[index] ?? 0,
+              pitches[index] ?? -10,
+              rolls[index] ?? 0
+            );
+          }
+        } finally {
+          isUpdatingFromDrag = false;
         }
         if (options?.onVertexDragMoveDetail) {
           try {
@@ -6526,6 +6709,55 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
       // 🆕 添加相对高度
     };
   };
+  if (options?.initialClickPosition && positions.length === 0) {
+    console.log("[PathEditing] \u5904\u7406\u521D\u59CB\u70B9\u51FB\u4F4D\u7F6E\uFF0C\u7ACB\u5373\u6DFB\u52A0\u7B2C\u4E00\u4E2A\u822A\u70B9");
+    let finalPosition = options.initialClickPosition;
+    try {
+      const cartographic = C.Cartographic.fromCartesian(options.initialClickPosition);
+      const lon = C.Math.toDegrees(cartographic.longitude);
+      const lat = C.Math.toDegrees(cartographic.latitude);
+      let finalHeight;
+      if (currentAltitudeMode === "absolute") {
+        finalHeight = currentDefaultAltitude;
+      } else if (currentAltitudeMode === "relativeToGround") {
+        const terrainHeight = queryTerrainHeightSync(CesiumNS, viewer, options.initialClickPosition);
+        finalHeight = terrainHeight + currentDefaultAltitude;
+      } else if (currentAltitudeMode === "relativeToStart") {
+        finalHeight = currentDefaultAltitude;
+      } else {
+        finalHeight = currentDefaultAltitude;
+      }
+      finalPosition = C.Cartesian3.fromDegrees(lon, lat, finalHeight);
+      console.log("[PathEditing] \u521D\u59CB\u822A\u70B9\u9AD8\u5EA6\u8BA1\u7B97:", {
+        altitudeMode: currentAltitudeMode,
+        defaultAltitude: currentDefaultAltitude,
+        finalHeight
+      });
+    } catch (error) {
+      console.warn("[PathEditing] \u8BA1\u7B97\u521D\u59CB\u822A\u70B9\u9AD8\u5EA6\u5931\u8D25:", error);
+    }
+    const totalBefore = positions.length;
+    insertVertex(0, finalPosition, { heading: 0, pitch: -10, roll: 0 });
+    if (options?.onVertexInsertDetail) {
+      try {
+        const totalAfter = positions.length;
+        const newVertex = buildVertexDetailInfo(0);
+        const operationInfo = {
+          type: "insert",
+          index: 0,
+          displayNumber: newVertex.displayNumber,
+          totalVerticesBefore: totalBefore,
+          totalVerticesAfter: totalAfter,
+          newVertex,
+          timestamp: /* @__PURE__ */ new Date(),
+          totalDistance: getTotalDistance()
+        };
+        options.onVertexInsertDetail(operationInfo);
+      } catch (error) {
+        console.error("[PathEditing] \u89E6\u53D1 onVertexInsertDetail \u56DE\u8C03\u5931\u8D25:", error);
+      }
+    }
+  }
   return {
     /** 保存并退出编辑模式 */
     saveAndStop: () => {
@@ -6567,8 +6799,10 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
           distance: calculatePathDistance(CesiumNS, positions, index),
           ellipsoidHeight,
           relativeHeight,
-          useGlobalHeight: useGlobalHeightFlags[index] ?? false
+          useGlobalHeight: useGlobalHeightFlags[index] ?? false,
           // 🆕 添加 useGlobalHeight
+          waypointId: waypointIds[index]
+          // 🆕 添加 waypointId（原有航点保留ID，新插入航点为 undefined）
         };
       });
       cleanupSession();
@@ -6951,6 +7185,67 @@ function startPathEditing(CesiumNS, viewer, entityOrId, options) {
         options2?.onProgress?.("error");
         return { success: false, error: String(error) };
       }
+    },
+    /**
+     * 🆕 获取当前选中航点索引
+     * @returns 当前选中的航点索引，如果没有选中则返回 undefined
+     */
+    getActiveIndex: () => {
+      return activeIndex;
+    },
+    /**
+     * 🆕 在选中航点和下一个航点中间插入新航点
+     * @param index 选中航点的索引（如果不传则使用当前选中的航点）
+     * @returns 是否插入成功
+     */
+    insertMidpoint: (index) => {
+      const targetIndex = index ?? activeIndex;
+      if (targetIndex === void 0) {
+        console.warn("[insertMidpoint] \u6CA1\u6709\u9009\u4E2D\u822A\u70B9");
+        return false;
+      }
+      if (targetIndex >= positions.length - 1) {
+        console.warn("[insertMidpoint] \u9009\u4E2D\u822A\u70B9\u662F\u6700\u540E\u4E00\u4E2A\uFF0C\u65E0\u6CD5\u63D2\u5165\u4E2D\u70B9");
+        return false;
+      }
+      const point1 = positions[targetIndex];
+      const point2 = positions[targetIndex + 1];
+      const midpoint = C.Cartesian3.midpoint(point1, point2, new C.Cartesian3());
+      const carto1 = C.Cartographic.fromCartesian(point1);
+      const carto2 = C.Cartographic.fromCartesian(point2);
+      const deltaLon = carto2.longitude - carto1.longitude;
+      let heading = Math.atan2(
+        Math.sin(deltaLon) * Math.cos(carto2.latitude),
+        Math.cos(carto1.latitude) * Math.sin(carto2.latitude) - Math.sin(carto1.latitude) * Math.cos(carto2.latitude) * Math.cos(deltaLon)
+      );
+      heading = C.Math.toDegrees(heading);
+      if (heading > 180) heading -= 360;
+      if (heading < -180) heading += 360;
+      const pitch = pitches[targetIndex] ?? -10;
+      const roll = rolls[targetIndex] ?? 0;
+      console.log("[insertMidpoint] \u5728\u7D22\u5F15", targetIndex, "\u548C", targetIndex + 1, "\u4E4B\u95F4\u63D2\u5165\u4E2D\u70B9");
+      const totalBefore = positions.length;
+      insertVertex(targetIndex + 1, midpoint, { heading, pitch, roll });
+      if (options?.onVertexInsertDetail) {
+        try {
+          const totalAfter = positions.length;
+          const newVertex = buildVertexDetailInfo(targetIndex + 1);
+          const operationInfo = {
+            type: "insert",
+            index: targetIndex + 1,
+            displayNumber: newVertex.displayNumber,
+            totalVerticesBefore: totalBefore,
+            totalVerticesAfter: totalAfter,
+            newVertex,
+            timestamp: /* @__PURE__ */ new Date(),
+            totalDistance: getTotalDistance()
+          };
+          options.onVertexInsertDetail(operationInfo);
+        } catch (error) {
+          console.error("Error in onVertexInsertDetail:", error);
+        }
+      }
+      return true;
     }
   };
 }
@@ -7032,8 +7327,8 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
         try {
           const auto = options?.autoStartEditing;
           const editOptions = {
-            // 默认使用自由编辑模式（快速编辑和自由编辑互斥）
-            quickEdit: false
+            // 🔧 修复：默认使用快速编辑模式，用户点击地图即可添加航点
+            quickEdit: true
           };
           if (typeof auto === "object" && auto.preview) {
             editOptions.preview = auto.preview;
@@ -7059,8 +7354,9 @@ function startPathDrawing(CesiumNS, viewer, options, onComplete) {
           editOptions.altitudeMode = altitudeMode;
           editOptions.defaultAltitude = defaultAltitude;
           editOptions.climbHeight = climbHeight;
+          editOptions.initialClickPosition = picked;
           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");
+          console.log("[startPathDrawing] \u7F16\u8F91\u6A21\u5F0F\u5DF2\u542F\u52A8\uFF0C\u5FEB\u901F\u7F16\u8F91\u6A21\u5F0F\uFF0C\u70B9\u51FB\u5730\u56FE\u6DFB\u52A0\u822A\u70B9");
           if (editSession && options?.onEditingStarted) {
             try {
               options.onEditingStarted(editSession);
@@ -11934,6 +12230,171 @@ var PointCloudPicker = class {
   }
 };
 
+// src/core/path-manager/RealtimeFlightTracker.ts
+var RealtimeFlightTracker = class {
+  constructor(CesiumNS, viewer, options) {
+    __publicField(this, "CesiumNS");
+    __publicField(this, "viewer");
+    __publicField(this, "options");
+    __publicField(this, "airplaneCursor");
+    __publicField(this, "trackEntity");
+    __publicField(this, "trackPositions", []);
+    __publicField(this, "isInitialized", false);
+    this.CesiumNS = CesiumNS;
+    this.viewer = viewer;
+    const C = CesiumNS;
+    this.options = {
+      showTrack: options?.showTrack ?? true,
+      fovDeg: options?.fovDeg ?? 50,
+      layer: options?.layer,
+      trackStyle: {
+        color: options?.trackStyle?.color ?? C.Color.CYAN,
+        width: options?.trackStyle?.width ?? 3,
+        clampToGround: options?.trackStyle?.clampToGround ?? false,
+        maxPoints: options?.trackStyle?.maxPoints ?? 1e3
+      }
+    };
+  }
+  /**
+   * 更新飞机位置（接收新航点）
+   * @param waypoint 实时航点数据
+   */
+  updatePosition(waypoint) {
+    const C = this.CesiumNS;
+    const position = C.Cartesian3.fromDegrees(
+      waypoint.longitude,
+      waypoint.latitude,
+      waypoint.altitude
+    );
+    if (!this.isInitialized) {
+      this.initialize(position);
+      this.isInitialized = true;
+    }
+    if (this.airplaneCursor) {
+      this.airplaneCursor.setPose(
+        position,
+        waypoint.heading ?? 0,
+        waypoint.pitch ?? 0,
+        waypoint.roll ?? 0
+      );
+    }
+    if (this.options.showTrack) {
+      this.addTrackPoint(position);
+    }
+    this.viewer.scene.requestRender();
+  }
+  /**
+   * 初始化飞机和轨迹实体
+   */
+  initialize(initialPosition) {
+    this.airplaneCursor = new AirplaneCursor(
+      this.CesiumNS,
+      this.viewer,
+      initialPosition,
+      {
+        stepMeters: 0,
+        // 禁用键盘控制
+        angleStepDeg: 0,
+        fovDeg: this.options.fovDeg,
+        visible: true,
+        showFrustum: false
+        // 实时飞行追踪不显示视锥体
+      }
+    );
+    if (this.options.showTrack) {
+      this.createTrackEntity();
+    }
+  }
+  /**
+   * 创建轨迹实体
+   */
+  createTrackEntity() {
+    const C = this.CesiumNS;
+    const entities = this.options.layer?.entities ?? this.viewer.entities;
+    const style = this.options.trackStyle;
+    this.trackEntity = entities.add({
+      id: `realtime-flight-track-${Date.now()}`,
+      polyline: {
+        // 使用 CallbackProperty 实现动态更新
+        positions: new C.CallbackProperty(() => {
+          return this.trackPositions.slice();
+        }, false),
+        width: style.width,
+        material: style.color,
+        clampToGround: style.clampToGround
+      },
+      properties: {
+        _type: "realtime-flight-track"
+      }
+    });
+  }
+  /**
+   * 添加轨迹点
+   */
+  addTrackPoint(position) {
+    this.trackPositions.push(position);
+    const maxPoints = this.options.trackStyle.maxPoints;
+    if (this.trackPositions.length > maxPoints) {
+      this.trackPositions = this.trackPositions.slice(-maxPoints);
+    }
+  }
+  /**
+   * 清除轨迹
+   */
+  clearTrack() {
+    this.trackPositions = [];
+    this.viewer.scene.requestRender();
+  }
+  /**
+   * 获取当前轨迹点数
+   */
+  getTrackPointCount() {
+    return this.trackPositions.length;
+  }
+  /**
+   * 设置轨迹可见性
+   */
+  setTrackVisible(visible) {
+    if (this.trackEntity) {
+      this.trackEntity.show = visible;
+      this.viewer.scene.requestRender();
+    }
+  }
+  /**
+   * 飞到当前飞机位置
+   */
+  flyToAirplane(options) {
+    if (this.trackPositions.length === 0) return;
+    const C = this.CesiumNS;
+    const lastPosition = this.trackPositions[this.trackPositions.length - 1];
+    const carto = C.Cartographic.fromCartesian(lastPosition);
+    this.viewer.camera.flyTo({
+      destination: C.Cartesian3.fromRadians(
+        carto.longitude,
+        carto.latitude,
+        (options?.height ?? 500) + carto.height
+      ),
+      duration: options?.duration ?? 1.5
+    });
+  }
+  /**
+   * 销毁并清理资源
+   */
+  destroy() {
+    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;
+    }
+    this.trackPositions = [];
+    this.isInitialized = false;
+  }
+};
+
 // src/utils/pathToSinoflyAdapter.ts
 function convertCartesian3ToLatLonHeight(CesiumNS, position) {
   const C = CesiumNS;
@@ -12063,8 +12524,8 @@ function convertPathToSinofly(data, options) {
     );
     const action = convertPoseToActionGroup(wp.heading, wp.pitch, wp.roll, wp.fov, newIndex);
     const waypoint = {
-      waypointId: "",
-      // 由服务器自动生成
+      waypointId: wp.waypointId ?? "",
+      // 🆕 使用传入的 waypointId，新航点为空字符串
       waylineId,
       index: newIndex,
       latitude,
@@ -12513,13 +12974,18 @@ exports.LayerManager = LayerManager;
 exports.PathSafetyChecker = PathSafetyChecker;
 exports.PointCloudPicker = PointCloudPicker;
 exports.PolygonEditor = PolygonEditor;
+exports.RealtimeFlightTracker = RealtimeFlightTracker;
 exports.SceneManager = SceneManager;
 exports.Selector = Selector;
 exports.StateManager = StateManager;
 exports.assertCesiumAssetsConfigured = assertCesiumAssetsConfigured;
 exports.calculateAbsoluteHeight = calculateAbsoluteHeight;
 exports.calculateBoundsDiagonal = calculateBoundsDiagonal;
+exports.calculateDistance = calculateDistance;
+exports.calculateDistanceAndMidpoint = calculateDistanceAndMidpoint;
 exports.calculateGeoBounds = calculateGeoBounds;
+exports.calculateHeadingBetweenPoints = calculateHeadingBetweenPoints;
+exports.calculateMidpoint = calculateMidpoint;
 exports.calculateRelativeHeight = calculateRelativeHeight;
 exports.configureCesiumAssets = configureCesiumAssets;
 exports.configureCesiumIonToken = configureCesiumIonToken;