@jorgmoritz/gis-manager 0.1.53 → 0.1.55

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.53"};
+  version: "0.1.54"};
 
 // src/utils/version.ts
 var version = package_default.version;
@@ -2702,6 +2702,8 @@ var StateManager = class {
     __publicField(this, "editing", false);
     __publicField(this, "editingTarget");
     __publicField(this, "previousView");
+    // MassPolygonManager 注册表（用于编辑模式隔离）
+    __publicField(this, "massPolygonManagers", /* @__PURE__ */ new Set());
     // Emitters
     __publicField(this, "onSelectionChange", new Emitter());
     __publicField(this, "onEditingChange", new Emitter());
@@ -2752,6 +2754,26 @@ var StateManager = class {
   getPreviousCameraView() {
     return this.previousView;
   }
+  // MassPolygonManager 注册管理
+  /**
+   * 注册 MassPolygonManager 实例
+   * 用于编辑模式下统一管理所有图层的交互状态
+   */
+  registerMassPolygonManager(manager) {
+    this.massPolygonManagers.add(manager);
+  }
+  /**
+   * 注销 MassPolygonManager 实例
+   */
+  unregisterMassPolygonManager(manager) {
+    this.massPolygonManagers.delete(manager);
+  }
+  /**
+   * 获取所有已注册的 MassPolygonManager 实例
+   */
+  getAllMassPolygonManagers() {
+    return Array.from(this.massPolygonManagers);
+  }
 };
 var globalState = new StateManager();
 
@@ -4311,14 +4333,16 @@ var TriangleShape = class {
    * @param positionCallback - Callback function that returns current position
    * @param headingCallback - Callback function that returns current heading in degrees
    * @param properties - Additional properties for entities
+   * @param scaleCallback - Optional callback function that returns current scale factor (default 1)
    * @returns Array of created entities [bottom faces, side faces]
    */
-  createEntities(layer, positionCallback, headingCallback, properties) {
+  createEntities(layer, positionCallback, headingCallback, properties, scaleCallback) {
     const C = this.CesiumNS;
     const entities = [];
     const computeVertices = () => {
       const position = positionCallback();
       const heading = headingCallback();
+      const scale = scaleCallback?.() ?? 1;
       const enu = C.Transforms.eastNorthUpToFixedFrame(position);
       const east4 = C.Matrix4.getColumn(enu, 0, new C.Cartesian4());
       const north4 = C.Matrix4.getColumn(enu, 1, new C.Cartesian4());
@@ -4330,9 +4354,12 @@ var TriangleShape = class {
       const sin = Math.sin(theta);
       const cos = Math.cos(theta);
       const toWorld = (x, y, z) => {
-        const ex = C.Cartesian3.multiplyByScalar(east, x * cos + y * sin, new C.Cartesian3());
-        const ny = C.Cartesian3.multiplyByScalar(north, -x * sin + y * cos, new C.Cartesian3());
-        const uz = C.Cartesian3.multiplyByScalar(up, z, new C.Cartesian3());
+        const sx = x * scale;
+        const sy = y * scale;
+        const sz = z * scale;
+        const ex = C.Cartesian3.multiplyByScalar(east, sx * cos + sy * sin, new C.Cartesian3());
+        const ny = C.Cartesian3.multiplyByScalar(north, -sx * sin + sy * cos, new C.Cartesian3());
+        const uz = C.Cartesian3.multiplyByScalar(up, sz, new C.Cartesian3());
         const offset = C.Cartesian3.add(ex, ny, new C.Cartesian3());
         C.Cartesian3.add(offset, uz, offset);
         return C.Cartesian3.add(position, offset, new C.Cartesian3());
@@ -4613,6 +4640,28 @@ var AirplaneCursor = class {
    * 创建三角形标记游标
    */
   createTriangleCursor(_color) {
+    const C = this.CesiumNS;
+    const baseScale = 1;
+    const minScale = 0.1;
+    const maxScale = 3;
+    const referenceDistance = 800;
+    const computeScaleFactor = () => {
+      try {
+        const cameraPos = this.viewer.camera.positionWC;
+        const modelPos = this.pose.position;
+        const distance = C.Cartesian3.distance(cameraPos, modelPos);
+        const rawScale = baseScale * (distance / referenceDistance);
+        const clampedScale = Math.max(minScale, Math.min(maxScale, rawScale));
+        return clampedScale / baseScale;
+      } catch {
+        return 1;
+      }
+    };
+    this.cachedScaleFactor = computeScaleFactor();
+    this.cameraChangedListener = this.viewer.camera.changed.addEventListener(() => {
+      this.cachedScaleFactor = computeScaleFactor();
+      this.viewer.scene?.requestRender?.();
+    });
     this.triangleShape = new TriangleShape(this.CesiumNS, {
       baseSize: 15,
       pyramidHeight: 25,
@@ -4622,7 +4671,9 @@ var AirplaneCursor = class {
       this.pyramidLayer,
       () => this.pose.position,
       () => this.pose.heading,
-      { _type: "airplane-cursor" }
+      { _type: "airplane-cursor" },
+      () => this.cachedScaleFactor
+      // 传入缩放因子回调
     );
     triangleEntities.forEach((entity) => {
       entity.show = this.visible;
@@ -5423,7 +5474,7 @@ function calculatePathDistance(CesiumNS, positions, targetIndex, hiddenClimbInde
   const C = CesiumNS;
   let totalDistance = 0;
   const startIndex = 1;
-  if (targetIndex <= startIndex) return 0;
+  if (targetIndex < startIndex) return 0;
   for (let i = startIndex; i <= targetIndex; i++) {
     try {
       const prevPos = positions[i - 1];
@@ -9989,7 +10040,7 @@ var PolygonEditor = class {
     this.editHandles = positions.map(
       (p, i) => layer.entities.add({
         position: p,
-        point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
+        point: { pixelSize: 12, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 2 },
         properties: { _vertexIndex: i }
       })
     );
@@ -10071,29 +10122,120 @@ var PolygonEditor = class {
         return void 0;
       }
     };
-    const highlightHandle = (index) => {
+    let hoveredIndex = void 0;
+    const getHighlightColors = () => {
+      if (layer.name === "inverter") {
+        return {
+          hoverColor: C.Color.fromCssColorString("rgba(150, 255, 150, 1)"),
+          // 浅绿色
+          hoverOutline: C.Color.fromCssColorString("rgba(0, 150, 0, 1)"),
+          // 深绿色
+          selectColor: C.Color.fromCssColorString("rgba(100, 255, 100, 1)"),
+          // 亮绿色
+          selectOutline: C.Color.fromCssColorString("rgba(0, 100, 0, 1)")
+          // 深绿色
+        };
+      } else {
+        return {
+          hoverColor: C.Color.fromCssColorString("rgba(255, 150, 150, 1)"),
+          // 浅红色
+          hoverOutline: C.Color.fromCssColorString("rgba(200, 0, 0, 1)"),
+          // 深红色
+          selectColor: C.Color.fromCssColorString("rgba(255, 100, 100, 1)"),
+          // 亮红色
+          selectOutline: C.Color.fromCssColorString("rgba(150, 0, 0, 1)")
+          // 深红色
+        };
+      }
+    };
+    const highlightColors = getHighlightColors();
+    const hoverHandle = (index) => {
       const handle = this.editHandles[index];
       if (handle && handle.point) {
-        handle.point.pixelSize = 10;
-        handle.point.color = C.Color.YELLOW;
-        handle.point.outlineColor = C.Color.RED;
+        handle.point.pixelSize = 18;
+        handle.point.color = highlightColors.hoverColor;
+        handle.point.outlineColor = highlightColors.hoverOutline;
+        handle.point.outlineWidth = 3;
+      }
+    };
+    const unhoverHandle = (index) => {
+      const handle = this.editHandles[index];
+      if (handle && handle.point) {
+        handle.point.pixelSize = 12;
+        handle.point.color = point_color;
+        handle.point.outlineColor = C.Color.BLACK;
         handle.point.outlineWidth = 2;
       }
     };
+    const highlightHandle = (index) => {
+      const handle = this.editHandles[index];
+      if (handle && handle.point) {
+        handle.point.pixelSize = 16;
+        handle.point.color = highlightColors.selectColor;
+        handle.point.outlineColor = highlightColors.selectOutline;
+        handle.point.outlineWidth = 3;
+      }
+    };
     const unhighlightHandle = (index) => {
       const handle = this.editHandles[index];
       if (handle && handle.point) {
-        handle.point.pixelSize = 7;
+        handle.point.pixelSize = 12;
         handle.point.color = point_color;
         handle.point.outlineColor = C.Color.BLACK;
-        handle.point.outlineWidth = 1;
+        handle.point.outlineWidth = 2;
+      }
+    };
+    const VERTEX_PICK_RADIUS = 30;
+    const findNearestVertexByScreenDistance = (screenPos) => {
+      if (!screenPos || typeof screenPos.x !== "number" || typeof screenPos.y !== "number") {
+        return void 0;
+      }
+      const scene = this.viewer.scene;
+      const ST = this.CesiumNS.SceneTransforms;
+      let nearestIdx;
+      let nearestDist = VERTEX_PICK_RADIUS;
+      for (let i = 0; i < positions.length; i++) {
+        const worldPos = positions[i];
+        if (!worldPos) continue;
+        let screenCoord;
+        try {
+          screenCoord = ST.wgs84ToWindowCoordinates?.(scene, worldPos);
+        } catch {
+        }
+        if (!screenCoord) {
+          try {
+            screenCoord = ST.worldToWindowCoordinates?.(scene, worldPos);
+          } catch {
+          }
+        }
+        if (!screenCoord && scene.cartesianToCanvasCoordinates) {
+          try {
+            const canvasCoord = scene.cartesianToCanvasCoordinates(worldPos);
+            if (canvasCoord) {
+              screenCoord = { x: canvasCoord.x, y: canvasCoord.y };
+            }
+          } catch {
+          }
+        }
+        if (!screenCoord) continue;
+        const dx = screenPos.x - screenCoord.x;
+        const dy = screenPos.y - screenCoord.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+        if (dist < nearestDist) {
+          nearestDist = dist;
+          nearestIdx = i;
+        }
       }
+      return nearestIdx;
     };
     this.handler && this.handler.setInputAction(
       (movement) => {
+        const screenPos = movement.position;
+        const nearestVertexIdx = findNearestVertexByScreenDistance(screenPos);
         const picked = this.viewer.scene.pick?.(movement.position);
         const entity = picked?.id;
-        const idx = entity?.properties?._vertexIndex?.getValue?.() ?? entity?.properties?._vertexIndex;
+        const pickedIdx = entity?.properties?._vertexIndex?.getValue?.() ?? entity?.properties?._vertexIndex;
+        const idx = nearestVertexIdx ?? (typeof pickedIdx === "number" ? pickedIdx : void 0);
         if (this.draggingIndex === void 0) {
           if (typeof idx === "number") {
             this.draggingIndex = idx;
@@ -10127,7 +10269,7 @@ var PolygonEditor = class {
             positions.splice(insertIndex, 0, insertPoint);
             const newHandle = layer.entities.add({
               position: insertPoint,
-              point: { pixelSize: 7, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 1 },
+              point: { pixelSize: 12, color: point_color, outlineColor: C.Color.BLACK, outlineWidth: 2 },
               properties: { _vertexIndex: insertIndex }
             });
             this.editHandles.splice(insertIndex, 0, newHandle);
@@ -10186,10 +10328,46 @@ var PolygonEditor = class {
             }
             this.insertPreviewHandle = void 0;
           }
+          if (hoveredIndex !== void 0) {
+            unhoverHandle(hoveredIndex);
+            hoveredIndex = void 0;
+          }
           return;
         }
+        const winPos = movement?.endPosition ?? movement?.position ?? movement;
+        if (winPos) {
+          const nearestVertexIdx = findNearestVertexByScreenDistance(winPos);
+          if (nearestVertexIdx !== void 0) {
+            if (hoveredIndex !== nearestVertexIdx) {
+              if (hoveredIndex !== void 0) {
+                unhoverHandle(hoveredIndex);
+              }
+              hoveredIndex = nearestVertexIdx;
+              hoverHandle(hoveredIndex);
+            }
+            if (this.segmentHighlight) {
+              try {
+                layer.entities.remove(this.segmentHighlight);
+              } catch {
+              }
+              this.segmentHighlight = void 0;
+            }
+            if (this.insertPreviewHandle) {
+              try {
+                layer.entities.remove(this.insertPreviewHandle);
+              } catch {
+              }
+              this.insertPreviewHandle = void 0;
+            }
+            return;
+          } else {
+            if (hoveredIndex !== void 0) {
+              unhoverHandle(hoveredIndex);
+              hoveredIndex = void 0;
+            }
+          }
+        }
         try {
-          const winPos = movement?.endPosition ?? movement?.position ?? movement;
           if (!winPos) return;
           const ST = this.CesiumNS.SceneTransforms;
           const threshold = 8;
@@ -12195,6 +12373,8 @@ var CZMLManager = class {
     __publicField(this, "currentSelectedEntity", null);
     __publicField(this, "activePolygonSession", null);
     __publicField(this, "polygonSessionCleanup");
+    // 编辑模式标志
+    __publicField(this, "editingMode", false);
     __publicField(this, "_polygonEditor");
     // Path manager composition
     __publicField(this, "_pathMgr");
@@ -12484,10 +12664,17 @@ var CZMLManager = class {
       bringDataSourceToTop(this.viewer, "other");
     }
     const session = this.polygonEditor.startDrawing(type, layer, (entity) => {
+      this.exitEditingMode();
       this.cancelActivePolygonDrawing();
       onComplete?.(entity);
     });
     if (session && typeof session.stop === "function") {
+      this.enterEditingMode();
+      const originalStop = session.stop;
+      session.stop = () => {
+        this.exitEditingMode();
+        originalStop();
+      };
       this.activePolygonSession = session;
     } else {
       this.activePolygonSession = null;
@@ -12589,6 +12776,39 @@ var CZMLManager = class {
     bringDataSourceToTop(this.viewer, "other");
     return this.polygonEditor.startPointDrawing?.(layer, iconSvg, onComplete);
   }
+  /**
+   * 进入编辑模式：禁用所有 MassPolygonManager 的交互
+   * 防止编辑多边形时其他图层响应鼠标事件
+   */
+  enterEditingMode() {
+    if (this.editingMode) return;
+    this.editingMode = true;
+    const managers = globalState.getAllMassPolygonManagers?.();
+    if (managers) {
+      for (const manager of managers) {
+        manager.disableInteraction();
+      }
+    }
+  }
+  /**
+   * 退出编辑模式：恢复所有 MassPolygonManager 的交互
+   */
+  exitEditingMode() {
+    if (!this.editingMode) return;
+    this.editingMode = false;
+    const managers = globalState.getAllMassPolygonManagers?.();
+    if (managers) {
+      for (const manager of managers) {
+        manager.enableInteraction();
+      }
+    }
+  }
+  /**
+   * 检查是否处于编辑模式
+   */
+  isInEditingMode() {
+    return this.editingMode;
+  }
   // New: start editing an existing polygon entity's vertices
   // Accepts: an Entity, or an id string, or undefined to use the last selected entity from state
   startPolygonEditing(entityOrId, onComplete) {
@@ -12630,7 +12850,20 @@ var CZMLManager = class {
     } else if (dataSource.name === "other") {
       bringDataSourceToTop(this.viewer, "other");
     }
-    return this.polygonEditor.startEditing(entity, dataSource, onComplete);
+    this.enterEditingMode();
+    const wrappedOnComplete = (editedEntity) => {
+      this.exitEditingMode();
+      onComplete?.(editedEntity);
+    };
+    const session = this.polygonEditor.startEditing(entity, dataSource, wrappedOnComplete);
+    if (session) {
+      const originalStop = session.stop;
+      session.stop = () => {
+        this.exitEditingMode();
+        originalStop();
+      };
+    }
+    return session;
   }
   ensurePolygonSessionHooks() {
     if (this.polygonSessionCleanup || typeof window === "undefined" || typeof document === "undefined") {
@@ -14169,6 +14402,8 @@ var MassPolygonManager = class {
     __publicField(this, "hoverHandler");
     __publicField(this, "clickHandler");
     __publicField(this, "rightClickHandler");
+    // 交互禁用标志（编辑模式时禁用）
+    __publicField(this, "interactionDisabled", false);
     // 悬停状态
     __publicField(this, "highlightedId");
     __publicField(this, "originalHighlightFillColor");
@@ -14257,12 +14492,35 @@ var MassPolygonManager = class {
   getLayerCollection() {
     return this.layerCollection;
   }
+  /**
+   * 禁用所有交互（hover/click/rightClick）
+   * 用于编辑模式下隔离其他图层的交互
+   */
+  disableInteraction() {
+    this.interactionDisabled = true;
+    this.clearHighlight();
+    this.hideLabel();
+  }
+  /**
+   * 启用所有交互
+   * 用于退出编辑模式后恢复交互
+   */
+  enableInteraction() {
+    this.interactionDisabled = false;
+  }
+  /**
+   * 检查交互是否被禁用
+   */
+  isInteractionDisabled() {
+    return this.interactionDisabled;
+  }
   /**
    * 批量创建多边形
    */
   create(polygons, options) {
     const C = this.CesiumNS;
     this.clear();
+    globalState.registerMassPolygonManager(this);
     this.currentOptions = options ?? {};
     this.layerName = options?.layerName;
     if (options?.style) {
@@ -14456,6 +14714,7 @@ var MassPolygonManager = class {
     this.hoverHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.hoverHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         const now = Date.now();
         if (now - this.lastPickTime < this.pickThrottleMs) return;
         this.lastPickTime = now;
@@ -14497,6 +14756,7 @@ var MassPolygonManager = class {
     this.clickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.clickHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         let polygonId = null;
         if (this.isClampToGround) {
           polygonId = this.pickPolygonByPosition(movement.position);
@@ -14539,6 +14799,7 @@ var MassPolygonManager = class {
     this.rightClickHandler = new C.ScreenSpaceEventHandler(this.viewer.scene.canvas);
     this.rightClickHandler.setInputAction(
       (movement) => {
+        if (this.interactionDisabled) return;
         let polygonId = null;
         if (this.isClampToGround) {
           polygonId = this.pickPolygonByPosition(movement.position);
@@ -15319,6 +15580,7 @@ var MassPolygonManager = class {
    * 清除所有多边形
    */
   clear() {
+    globalState.unregisterMassPolygonManager(this);
     if (this.hoverHandler) {
       this.hoverHandler.destroy();
       this.hoverHandler = void 0;
@@ -15338,6 +15600,7 @@ var MassPolygonManager = class {
     this.originalSelectFillColor = void 0;
     this.originalSelectOutlineColor = void 0;
     this.hoverLabel = void 0;
+    this.interactionDisabled = false;
     this.highlightPrimitive = void 0;
     this.selectPrimitive = void 0;
     if (this.layerCollection && this.viewer?.scene?.primitives) {