cesium-xs-sdk 1.0.0

package/src/modules/tools/EditTool.js

@@ -0,0 +1,1585 @@
+import { BaseTool } from './BaseTool.js';
+import { PlotGraphicType } from '../PlotGraphicType.js';
+import { PlotGeometryUtil } from '../../utils/PlotGeometryUtil.js';
+
+/**
+ * 编辑模式枚举
+ */
+export const EditMode = {
+  VERTEX: 'vertex'   // 顶点编辑模式（同时支持平移）
+};
+
+/**
+ * 编辑工具
+ * 支持选中图元的顶点编辑、平移、缩放
+ */
+export class EditTool extends BaseTool {
+  // 静态常量
+  static CLOSE_POINT_TOLERANCE = 0.001;  // 闭合点检测容差（1毫米）
+  static DEFAULT_PIXEL_SIZE = 12;
+  static DEFAULT_OUTLINE_WIDTH = 2;
+  static MOVE_THROTTLE_MS = 16;  // 拖拽节流间隔（~60fps）
+
+  constructor(editorModule, options = {}) {
+    super(editorModule, options);
+    this._editMode = options.editMode || EditMode.VERTEX;
+    this._selectedEntity = null;       // 当前选中的图元
+    this._selectedEntityId = null;
+    this._editHandles = [];            // 编辑控制点
+    this._positionOutline = null;      // 位置辅助线
+    this._polygonPreview = null;      // 多边形预览
+    this._tempEntities = [];           // 临时图元（如包围盒）
+    this._isDragging = false;          // 是否正在拖拽
+    this._dragHandle = null;           // 当前拖拽的控制点
+    this._originalPositions = null;    // 原始位置（用于撤销）
+    this._handleVertexIndices = null; // 控制点对应的实际顶点索引
+    this._rectangleOriginalPositions = null; // 矩形原始顶点位置
+    this._originalEnableInputs = true; // 原始相机控制状态
+    this._lastMoveTime = 0;           // 上次移动时间（用于节流）
+    this._originalCircleCenter = null;  // 圆形原始圆心
+    this._originalCircleRadius = null; // 圆形原始半径
+    this._originalEntityCenter = null; // 原始中心点（用于平移）
+    this._radiusLine = null;           // 半径线引用
+  }
+
+  /**
+   * 设置编辑模式
+   * @param {string} mode EditMode
+   */
+  setEditMode(mode) {
+    this._editMode = mode;
+    return this;
+  }
+
+  getEditMode() {
+    return this._editMode;
+  }
+
+  /**
+   * 手动选中图元进行编辑
+   * @param {string} entityId 图元 ID
+   */
+  selectEntity(entityId) {
+    const entity = this._graphicModule.getGraphic(entityId);
+    if (entity) {
+      this._selectEntity(entity);
+    }
+  }
+
+  onActivate() {
+    this.registerObserver('mouse:click', this._onClick.bind(this));
+    this.registerObserver('mouse:move', this._onMove.bind(this));
+    this.registerObserver('mouse:down', this._onMouseDown.bind(this));
+    this.registerObserver('mouse:up', this._onMouseUp.bind(this));
+  }
+
+  onDeactivate() {
+    this._deselectEntity();
+  }
+
+  _onClick(_lngLat, _entity, movement) {
+    // movement.position 包含屏幕坐标 {x, y}
+    const screenPos = movement.position || (movement && movement.endPosition);
+    if (!screenPos) return;
+
+    const picked = this._viewer.scene.pick({ x: screenPos.x, y: screenPos.y });
+    console.log('EditTool _onClick:', { picked, screenPos });
+
+    if (Cesium.defined(picked) && Cesium.defined(picked.id)) {
+      const entityId = picked.id.id;
+      console.log('EditTool picked entity:', entityId);
+
+      // 忽略临时图元
+      if (entityId && entityId.startsWith('__temp_')) {
+        return;
+      }
+
+      // 忽略控制点（拖拽在 _onMouseDown 中处理）
+      if (entityId && (entityId.startsWith('__edit_handle_') || entityId.includes('__edit_handle_'))) {
+        return;
+      }
+
+      const entity = this._graphicModule.getGraphic(entityId);
+      if (entity) {
+        console.log('EditTool selecting entity');
+        this._selectEntity(entity);
+      } else {
+        this._deselectEntity();
+      }
+    } else {
+      // 点击空白处取消选择
+      console.log('EditTool click on empty');
+      this._deselectEntity();
+    }
+  }
+
+  _onMouseDown(_lngLat, _entity, movement) {
+    // movement 包含屏幕坐标 {position: {x, y}}
+    const screenPos = movement && (movement.position || movement.endPosition);
+    if (!screenPos) return;
+
+    // 如果已经选中了图元，检查是否点击了控制点
+    if (this._selectedEntity && !this._isDragging) {
+      const picked = this._viewer.scene.pick({ x: screenPos.x, y: screenPos.y });
+      if (Cesium.defined(picked) && Cesium.defined(picked.id)) {
+        const entityId = picked.id.id;
+        if (entityId && (entityId.startsWith('__edit_handle_') || entityId.includes('__edit_handle_'))) {
+          // 直接在 _editHandles 中查找被点击的控制点
+          const clickedHandle = this._editHandles.find(handle => handle.id === entityId);
+          if (clickedHandle) {
+            this._dragHandle = clickedHandle;
+            this._isDragging = true;
+            this._originalPositions = this._getEntityPositions(this._selectedEntity);
+            // 禁用相机控制，防止拖拽时相机移动
+            this._viewer.scene.screenSpaceCameraController.enableRotate = false;
+            this._viewer.scene.screenSpaceCameraController.enableTranslate = false;
+          }
+        }
+      }
+    }
+  }
+
+  _onMouseUp(_data) {
+    if (this._isDragging) {
+      this._isDragging = false;
+      // 恢复相机控制
+      this._viewer.scene.screenSpaceCameraController.enableRotate = true;
+      this._viewer.scene.screenSpaceCameraController.enableTranslate = true;
+      this._setCursorStyle('default');
+      this._emitEditComplete();
+      this._dragHandle = null;
+    }
+  }
+
+  /**
+   * 设置鼠标样式
+   * @param {string} style CSS cursor 样式
+   */
+  _setCursorStyle(style) {
+    if (this._viewer && this._viewer.canvas) {
+      this._viewer.canvas.style.cursor = style;
+    }
+  }
+
+  _onMove(data) {
+    // _onMove receives movement object from BaseTool
+    const screenPos = data.position || data.endPosition;
+    if (!screenPos) return;
+
+    // 非拖拽时做节流，避免 hover 检测过于频繁
+    if (!this._isDragging) {
+      const now = Date.now();
+      if (now - this._lastMoveTime < EditTool.MOVE_THROTTLE_MS) return;
+      this._lastMoveTime = now;
+
+      // 检测是否悬停在控制点上
+      const picked = this._viewer.scene.pick({ x: screenPos.x, y: screenPos.y });
+      const isOverHandle = Cesium.defined(picked) && Cesium.defined(picked.id) &&
+        picked.id.id && picked.id.id.startsWith('__edit_handle_');
+      this._setCursorStyle(isOverHandle ? 'move' : 'default');
+    }
+
+    if (this._isDragging && this._dragHandle) {
+      this._setCursorStyle('grabbing');
+
+      // 拖拽时优先使用椭球面拾取，避免拾取到控制点句柄本身导致图元跟随滞后
+      let lonLat = null;
+      const cartesian = this._viewer.camera.pickEllipsoid(
+        new Cesium.Cartesian2(screenPos.x, screenPos.y),
+        this._viewer.scene.globe.ellipsoid
+      );
+      if (cartesian) {
+        const c = Cesium.Cartographic.fromCartesian(cartesian);
+        lonLat = [
+          Cesium.Math.toDegrees(c.longitude),
+          Cesium.Math.toDegrees(c.latitude),
+          c.height || 0
+        ];
+      } else {
+        lonLat = this.screenToLonLat({ x: screenPos.x, y: screenPos.y });
+      }
+
+      if (lonLat) {
+        this._updateEntityPosition(lonLat);
+      }
+    }
+  }
+
+  /**
+   * 平移标绘图元的所有控制点
+   * @param {Cesium.Cartesian3} newAnchorCartesian 新锚点位置
+   * @param {Cesium.Cartesian3} oldAnchorCartesian 旧锚点位置
+   */
+  _translatePlotControlPoints(newAnchorCartesian, oldAnchorCartesian) {
+    const deltaX = newAnchorCartesian.x - oldAnchorCartesian.x;
+    const deltaY = newAnchorCartesian.y - oldAnchorCartesian.y;
+    const deltaZ = newAnchorCartesian.z - oldAnchorCartesian.z;
+
+    const controlPoints = this._selectedEntity._controlPoints.map(cp => {
+      const cpCart = Cesium.Cartesian3.fromDegrees(cp[0], cp[1], cp[2] || 0);
+      const newCpCart = new Cesium.Cartesian3(
+        cpCart.x + deltaX,
+        cpCart.y + deltaY,
+        cpCart.z + deltaZ
+      );
+      const newCpCarto = Cesium.Cartographic.fromCartesian(newCpCart);
+      return [
+        Cesium.Math.toDegrees(newCpCarto.longitude),
+        Cesium.Math.toDegrees(newCpCarto.latitude),
+        newCpCarto.height || 0
+      ];
+    });
+
+    this._selectedEntity._controlPoints = controlPoints;
+
+    // 更新包装器几何
+    const wrapper = this._graphicModule.wrapperMap.get(this._selectedEntity.id);
+    if (wrapper) {
+      wrapper.setControlPoints(controlPoints);
+    }
+
+    // 更新所有控制点位置
+    this._editHandles.forEach((handle) => {
+      if (handle.id && handle.id.includes('center')) {
+        // 扇形/椭圆：中心控制点固定在圆心/中心；其他类型使用重心
+        const plotType = this._selectedEntity._plotType;
+        const center = (plotType === PlotGraphicType.SECTOR || plotType === PlotGraphicType.ELLIPSE)
+          ? controlPoints[0]
+          : this._getPlotControlPointsCenter(controlPoints);
+        handle.position = new Cesium.ConstantPositionProperty(
+          this._clampPositionToGround(Cesium.Cartesian3.fromDegrees(center[0], center[1], center[2] || 0))
+        );
+        return;
+      }
+      // 按句柄 ID 解析真实控制点索引（扇形跳过了索引 0，不能直接使用 forEach 索引）
+      const match = handle.id.match(/__edit_handle_(\d+)$/);
+      if (match) {
+        const cpIndex = parseInt(match[1], 10);
+        const cp = controlPoints[cpIndex];
+        handle.position = new Cesium.ConstantPositionProperty(
+          this._clampPositionToGround(Cesium.Cartesian3.fromDegrees(cp[0], cp[1], cp[2] || 0))
+        );
+      }
+    });
+
+    this._originalPositions = this._getEntityPositions(this._selectedEntity);
+  }
+
+  _selectEntity(entity) {
+    // 先取消之前的选中
+    this._deselectEntity();
+
+    this._selectedEntity = entity;
+    this._selectedEntityId = entity.id;
+
+    // 创建编辑控制点
+    this._createEditHandles();
+
+    // 高亮选中图元
+    this._highlightEntity(entity, true);
+
+    this._emitSelect(entity.id);
+  }
+
+  _deselectEntity() {
+    if (this._selectedEntity) {
+      this._highlightEntity(this._selectedEntity, false);
+    }
+
+    this._clearEditHandles();
+    this._selectedEntity = null;
+    this._selectedEntityId = null;
+    this._isDragging = false;
+    this._dragHandle = null;
+    // 确保取消选择时也恢复相机控制
+    this._viewer.scene.screenSpaceCameraController.enableRotate = true;
+    this._viewer.scene.screenSpaceCameraController.enableTranslate = true;
+  }
+
+  _createEditHandles() {
+    this._clearEditHandles();
+
+    // 标绘图元：显示控制点并重新生成几何
+    if (this._selectedEntity && this._selectedEntity._isPlotGraphic) {
+      this._createPlotControlHandles(this._selectedEntity);
+      return;
+    }
+
+    const positions = this._getEditablePositions(this._selectedEntity);
+    if (!positions || positions.length === 0) return;
+
+    // 创建顶点编辑控制点
+    this._createVertexHandles(positions);
+
+    // 如果是多顶点图元（非圆形），创建中心控制点用于平移
+    // 圆形在 _createVertexHandles 中已经创建了中心控制点
+    if (positions.length > 1 && !this._isCircle(this._selectedEntity)) {
+      this._createCenterHandleForVertexMode(positions);
+    }
+  }
+
+  /**
+   * 将位置转换为贴地位置（高度设为0）
+   * @param {Cesium.Cartesian3} position 
+   * @returns {Cesium.Cartesian3}
+   */
+  _clampPositionToGround(position) {
+    if (!position) return position;
+    const cartographic = Cesium.Cartographic.fromCartesian(position);
+    return Cesium.Cartesian3.fromDegrees(
+      Cesium.Math.toDegrees(cartographic.longitude),
+      Cesium.Math.toDegrees(cartographic.latitude),
+      0
+    );
+  }
+
+  /**
+   * 创建标绘图元的控制点
+   * @param {Cesium.Entity} entity 标绘图元实体
+   */
+  _createPlotControlHandles(entity) {
+    const controlPoints = entity._controlPoints || [];
+    if (controlPoints.length === 0) return;
+
+    // 扇形：圆心作为平移控制点，不创建黄色顶点句柄
+    const plotType = entity._plotType;
+    const isSector = plotType === PlotGraphicType.SECTOR;
+    const isEllipse = plotType === PlotGraphicType.ELLIPSE;
+
+    controlPoints.forEach((cp, index) => {
+      if ((isSector || isEllipse) && index === 0) return; // 扇形/椭圆圆心/中心由中心控制点处理
+
+      const clampedPos = this._clampPositionToGround(
+        Cesium.Cartesian3.fromDegrees(cp[0], cp[1], cp[2] || 0)
+      );
+      const handle = this.createTempEntity(`__edit_handle_${index}`, {
+        position: clampedPos,
+        point: {
+          color: Cesium.Color.YELLOW,
+          pixelSize: 12,
+          outlineColor: Cesium.Color.RED,
+          outlineWidth: 2,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+        }
+      });
+      this._editHandles.push(handle);
+    });
+
+    // 显示轮廓辅助线
+    if (controlPoints.length > 1) {
+      this._createPlotPositionOutline();
+    }
+
+    // 椭圆：显示两条半轴辅助线
+    if (isEllipse) {
+      this._createEllipseAxisLines();
+    }
+
+    // 创建中心平移控制点
+    if (controlPoints.length > 1) {
+      if (isSector || isEllipse) {
+        // 扇形/椭圆：中心点即为中心平移控制点
+        this._createPlotCenterHandle(controlPoints, controlPoints[0]);
+      } else {
+        this._createPlotCenterHandle(controlPoints);
+      }
+    }
+  }
+
+  /**
+   * 创建标绘图元的中心平移控制点
+   * @param {Array} controlPoints 控制点
+   * @param {Array|null} centerPoint 指定中心点位置；为空时使用控制点重心
+   */
+  _createPlotCenterHandle(controlPoints, centerPoint = null) {
+    const center = centerPoint || this._getPlotControlPointsCenter(controlPoints);
+    if (!center) return;
+
+    this._originalEntityCenter = this._clampPositionToGround(
+      Cesium.Cartesian3.fromDegrees(center[0], center[1], center[2] || 0)
+    );
+
+    const handle = this.createTempEntity('__edit_handle_center_plot', {
+      position: this._originalEntityCenter,
+      point: {
+        color: Cesium.Color.CYAN,
+        pixelSize: 14,
+        outlineColor: Cesium.Color.BLUE,
+        outlineWidth: 2,
+        disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+      }
+    });
+    this._editHandles.push(handle);
+  }
+
+  /**
+   * 计算标绘控制点的中心点
+   * @param {Array} controlPoints 控制点 [lon, lat, height][]
+   */
+  _getPlotControlPointsCenter(controlPoints) {
+    if (!controlPoints || controlPoints.length === 0) return null;
+
+    let x = 0, y = 0, z = 0;
+    controlPoints.forEach(cp => {
+      x += cp[0];
+      y += cp[1];
+      z += cp[2] || 0;
+    });
+    return [x / controlPoints.length, y / controlPoints.length, z / controlPoints.length];
+  }
+
+  /**
+   * 创建标绘图元轮廓辅助线
+   */
+  _createPlotPositionOutline() {
+    const self = this;
+    const entity = this._selectedEntity;
+    const isLine = Cesium.defined(entity.polyline);
+
+    // 以下标绘图元的控制点连线会干扰真实几何，不绘制轮廓辅助线
+    const skipOutlineTypes = new Set([
+      PlotGraphicType.FINE_ARROW,
+      PlotGraphicType.ASSAULT_DIRECTION,
+      PlotGraphicType.ATTACK_ARROW,
+      PlotGraphicType.SWALLOWTAIL_ATTACK_ARROW,
+      PlotGraphicType.SQUAD_COMBAT,
+      PlotGraphicType.SWALLOWTAIL_SQUAD_COMBAT,
+      PlotGraphicType.DOUBLE_ARROW,
+      PlotGraphicType.CURVED_ARROW,
+      PlotGraphicType.CURVE
+    ]);
+
+    this._positionOutline = this.createTempEntity(this.generateId('temp_plot_outline'), {
+      polyline: {
+        positions: new Cesium.CallbackProperty(function () {
+          const handles = self._editHandles;
+          if (!handles || handles.length === 0) return [];
+
+          const plotType = entity._plotType;
+          if (skipOutlineTypes.has(plotType)) {
+            return [];
+          }
+
+          // 扇形/椭圆：直接沿实际几何边界绘制辅助线
+          if (plotType === PlotGraphicType.SECTOR || plotType === PlotGraphicType.ELLIPSE) {
+            const hierarchy = entity.polygon?.hierarchy;
+            let positions = null;
+            if (hierarchy) {
+              if (typeof hierarchy.getValue === 'function') {
+                const value = hierarchy.getValue(Cesium.JulianDate.now());
+                positions = value ? value.positions : null;
+              } else if (hierarchy.positions) {
+                positions = hierarchy.positions;
+              }
+            }
+            if (positions && positions.length > 2) {
+              // 复制并显式闭合，避免 polygon 顶点重复导致 polyline 退化
+              const closed = positions.slice();
+              closed.push(positions[0]);
+              return closed;
+            }
+            return positions || [];
+          }
+
+          const degrees = [];
+          handles.forEach(handle => {
+            // 跳过中心平移控制点
+            if (handle.id && handle.id.includes('center')) return;
+
+            const pos = handle.position.getValue(Cesium.JulianDate.now());
+            if (pos) {
+              const c = Cesium.Cartographic.fromCartesian(pos);
+              degrees.push(Cesium.Math.toDegrees(c.longitude));
+              degrees.push(Cesium.Math.toDegrees(c.latitude));
+              degrees.push(c.height || 0);
+            }
+          });
+
+          if (degrees.length === 0) return [];
+
+          const cartesians = Cesium.Cartesian3.fromDegreesArrayHeights(degrees);
+          if (isLine) {
+            return cartesians;
+          }
+          return [...cartesians, cartesians[0]];
+        }, false),
+        material: Cesium.Color.YELLOW,
+        width: 2,
+        clampToGround: true
+      }
+    });
+    this._positionOutline._isPreview = true;
+    this._tempEntities.push(this._positionOutline);
+  }
+
+  /**
+   * 创建椭圆半轴辅助线（中心到长/短半轴端点）
+   */
+  _createEllipseAxisLines() {
+    const self = this;
+    const axisLine = this.createTempEntity(this.generateId('temp_ellipse_axis'), {
+      polyline: {
+        positions: new Cesium.CallbackProperty(function () {
+          const entity = self._selectedEntity;
+          const cps = entity?._controlPoints;
+          if (!cps || cps.length < 3) return [];
+
+          const center = Cesium.Cartesian3.fromDegrees(cps[0][0], cps[0][1], cps[0][2] || 0);
+          const major = Cesium.Cartesian3.fromDegrees(cps[1][0], cps[1][1], cps[1][2] || 0);
+          const minor = Cesium.Cartesian3.fromDegrees(cps[2][0], cps[2][1], cps[2][2] || 0);
+          return [center, major, center, minor];
+        }, false),
+        material: Cesium.Color.YELLOW,
+        width: 2,
+        clampToGround: true
+      }
+    });
+    axisLine._isPreview = true;
+    this._tempEntities.push(axisLine);
+  }
+
+  /**
+   * 创建顶点编辑控制点
+   * @param {Array} positions 可编辑位置数组
+   */
+  _createVertexHandles(positions) {
+    // 判断是否是矩形（4个顶点形成矩形）
+    const isRectangle = Cesium.defined(this._selectedEntity.polygon) && positions.length === 4 &&
+      this._isRectangle(positions);
+
+    if (isRectangle) {
+      this._rectangleOriginalPositions = positions.slice();
+
+      const vertexIndices = [0, 1, 2, 3];
+
+      vertexIndices.forEach((vertexIdx, handleIdx) => {
+        // 修复：位置贴地
+        const clampedPos = this._clampPositionToGround(positions[vertexIdx]);
+        const handle = this.createTempEntity(`__edit_handle_${handleIdx}`, {
+          position: clampedPos,
+          point: {
+            color: Cesium.Color.YELLOW,
+            pixelSize: 12,
+            outlineColor: Cesium.Color.RED,
+            outlineWidth: 2,
+            disableDepthTestDistance: Number.POSITIVE_INFINITY,
+            heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
+          }
+        });
+        this._editHandles.push(handle);
+      });
+
+      this._handleVertexIndices = [0, 1, 2, 3];
+    } else if (this._isCircle(this._selectedEntity)) {
+      const circleInfo = this._getCircleInfo(this._selectedEntity);
+      if (!circleInfo) return;
+
+      const { center, radius } = circleInfo;
+      // 修复：圆心位置贴地
+      const centerCartesian = Cesium.Cartesian3.fromDegrees(center[0], center[1], 0);
+      const radiusPoint = this._getPointOnCircle(center, radius, 0);
+      const radiusCartesian = Cesium.Cartesian3.fromDegrees(radiusPoint[0], radiusPoint[1], 0);
+
+      // 圆心控制点（可平移）- 使用与其他类型不同的ID格式
+      const centerHandle = this.createTempEntity('__edit_handle_center', {
+        position: centerCartesian,
+        point: {
+          color: Cesium.Color.CYAN,
+          pixelSize: 14,
+          outlineColor: Cesium.Color.BLUE,
+          outlineWidth: 2,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+        }
+      });
+      this._editHandles.push(centerHandle);
+
+      // 半径控制点
+      const radiusHandle = this.createTempEntity('__edit_handle_radius', {
+        position: radiusCartesian,
+        point: {
+          color: Cesium.Color.RED,
+          pixelSize: 12,
+          outlineColor: Cesium.Color.YELLOW,
+          outlineWidth: 2,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+        }
+      });
+      this._editHandles.push(radiusHandle);
+
+      this._handleVertexIndices = ['center', 'radius'];
+      this._originalCircleCenter = center;
+      this._originalCircleRadius = radius;
+      this._rectangleOriginalPositions = null;
+
+      this._createCircleOutline();
+    } else {
+      this._rectangleOriginalPositions = null;
+      this._handleVertexIndices = null;
+
+      positions.forEach((pos, index) => {
+        const clampedPos = this._clampPositionToGround(pos);
+        const handle = this.createTempEntity(`__edit_handle_${index}`, {
+          position: clampedPos,
+          point: {
+            color: Cesium.Color.YELLOW,
+            pixelSize: 12,
+            outlineColor: Cesium.Color.RED,
+            outlineWidth: 2,
+            disableDepthTestDistance: Number.POSITIVE_INFINITY,
+            // heightReference: Cesium.HeightReference.CLAMP_TO_GROUND,
+          }
+        });
+        this._editHandles.push(handle);
+      });
+    }
+
+    if (positions.length > 1) {
+      this._createPositionOutline();
+    }
+  }
+
+  /**
+   * 在 VERTEX 模式下创建中心控制点用于平移
+   * @param {Array} positions 顶点位置数组
+   */
+  _createCenterHandleForVertexMode(positions) {
+    const center = this._getEntityCenter(this._selectedEntity);
+    if (!center) return;
+
+    // 修复：中心点贴地
+    const clampedCenter = this._clampPositionToGround(center);
+    this._originalEntityCenter = clampedCenter;
+
+    // 圆形特殊处理：保存圆心和半径用于 undo
+    if (this._isCircle(this._selectedEntity)) {
+      const circleInfo = this._getCircleInfo(this._selectedEntity);
+      if (circleInfo) {
+        this._originalCircleCenter = circleInfo.center.slice();
+        this._originalCircleRadius = circleInfo.radius;
+      }
+    }
+
+    // 创建中心控制点（使用不同的 ID 区分）
+    const handle = this.createTempEntity('__edit_handle_center_vertex', {
+      position: clampedCenter,
+      point: {
+        color: Cesium.Color.CYAN,
+        pixelSize: 14,
+        outlineColor: Cesium.Color.BLUE,
+        outlineWidth: 2,
+        disableDepthTestDistance: Number.POSITIVE_INFINITY,
+        heightReference: Cesium.HeightReference.CLAMP_TO_GROUND
+      }
+    });
+    this._editHandles.push(handle);
+  }
+
+  /**
+   * 更新中心控制点位置（在顶点编辑后重新计算）
+   */
+  _updateCenterHandlePosition() {
+    // 圆形不需要更新中心点，因为圆心就是中心
+    if (this._isCircle(this._selectedEntity)) return;
+
+    const centerHandle = this._editHandles.find(h => h.id && h.id.includes('center'));
+    if (!centerHandle) return;
+
+    // 重新计算当前几何中心
+    const newCenter = this._getEntityCenter(this._selectedEntity);
+    if (!newCenter) return;
+
+    // 修复：中心点贴地
+    const clampedCenter = this._clampPositionToGround(newCenter);
+
+    // 更新中心控制点位置
+    centerHandle.position = new Cesium.ConstantPositionProperty(clampedCenter);
+    // 更新原始中心点缓存（用于下次平移计算）
+    this._originalEntityCenter = clampedCenter;
+  }
+
+  _createPositionOutline() {
+    // 从控制点获取位置，性能更好（避免每次从实体重新获取和转换）
+    const self = this;
+    const isPolyline = Cesium.defined(this._selectedEntity.polyline);
+
+    this._positionOutline = this.createTempEntity(this.generateId('temp_outline'), {
+      polyline: {
+        positions: new Cesium.CallbackProperty(function () {
+          // 从控制点获取位置（已被更新），排除中心控制点
+          const handles = self._editHandles;
+          if (!handles || handles.length === 0) return [];
+
+          // 收集所有控制点的当前位置，排除中心控制点
+          const degrees = [];
+          handles.forEach(handle => {
+            // 跳过所有中心控制点（用于平移）- 修复：统一使用 includes('center')
+            if (handle.id && handle.id.includes('center')) return;
+
+            const pos = handle.position.getValue(Cesium.JulianDate.now());
+            if (pos) {
+              const c = Cesium.Cartographic.fromCartesian(pos);
+              degrees.push(Cesium.Math.toDegrees(c.longitude));
+              degrees.push(Cesium.Math.toDegrees(c.latitude));
+              degrees.push(c.height || 0);
+            }
+          });
+
+          if (degrees.length === 0) return [];
+
+          // 线不闭合，面需要闭合
+          if (isPolyline) {
+            return Cesium.Cartesian3.fromDegreesArrayHeights(degrees);
+          }
+          // 闭合多边形（首尾点相同）
+          return Cesium.Cartesian3.fromDegreesArrayHeights([...degrees, degrees[0], degrees[1], degrees[2] || 0]);
+        }, false),
+        material: Cesium.Color.YELLOW,
+        width: 2,
+        clampToGround: true
+      }
+    });
+    this._positionOutline._isPreview = true;
+    this._tempEntities.push(this._positionOutline);
+  }
+
+  _clearEditHandles() {
+    this._editHandles.forEach(handle => {
+      this.removeTempEntity(handle);
+    });
+    this._editHandles = [];
+    this._positionOutline = null;
+    this._polygonPreview = null;
+    this._handleVertexIndices = null;
+    this._rectangleOriginalPositions = null;
+    this._originalCircleCenter = null;
+    this._originalCircleRadius = null;
+    this._originalEntityCenter = null;
+    this._radiusLine = null;
+
+    this._tempEntities.forEach(entity => {
+      this.removeTempEntity(entity);
+    });
+    this._tempEntities = [];
+  }
+
+  _getEditablePositions(entity) {
+    if (!entity) return [];
+
+    if (Cesium.defined(entity.polyline) && Cesium.defined(entity.polyline.positions)) {
+      return entity.polyline.positions.getValue(Cesium.JulianDate.now());
+    }
+
+    if (Cesium.defined(entity.polygon) && Cesium.defined(entity.polygon.hierarchy)) {
+      const hierarchy = entity.polygon.hierarchy.getValue(Cesium.JulianDate.now());
+      if (hierarchy && hierarchy.positions) {
+        let positions = hierarchy.positions;
+
+        // ✅ 检查并移除闭合点（首尾相同）
+        if (positions.length >= 2) {
+          const first = positions[0];
+          const last = positions[positions.length - 1];
+          // 使用距离判断而不是精确相等（避免浮点误差）
+          const distance = Cesium.Cartesian3.distance(first, last);
+          if (distance < EditTool.CLOSE_POINT_TOLERANCE) {
+            positions = positions.slice(0, -1); // 移除最后一个点
+          }
+        }
+
+        return positions;
+      }
+    }
+
+    if (Cesium.defined(entity.position)) {
+      return [entity.position.getValue(Cesium.JulianDate.now())];
+    }
+
+    return [];
+  }
+
+  _getEntityPositions(entity) {
+    return this._getEditablePositions(entity);
+  }
+
+  /**
+   * 获取图元中心点
+   */
+  _getEntityCenter(entity) {
+    const positions = this._getEditablePositions(entity);
+    if (!positions || positions.length === 0) return null;
+
+    let x = 0, y = 0, z = 0;
+    positions.forEach(p => {
+      x += p.x;
+      y += p.y;
+      z += p.z;
+    });
+    const count = positions.length;
+    return new Cesium.Cartesian3(x / count, y / count, z / count);
+  }
+
+  /**
+   * 平移整个图元
+   * @param {Cesium.Cartesian3} newCenter 新中心点
+   */
+  _translateEntity(newCenter) {
+    if (!this._selectedEntity || !this._originalEntityCenter) {
+      console.log('Translate skipped: no entity or no original center', {
+        hasEntity: !!this._selectedEntity,
+        originalCenter: this._originalEntityCenter
+      });
+      return;
+    }
+
+    // 修复：新中心点贴地
+    const clampedNewCenter = this._clampPositionToGround(newCenter);
+
+    // 计算偏移量
+    const deltaX = clampedNewCenter.x - this._originalEntityCenter.x;
+    const deltaY = clampedNewCenter.y - this._originalEntityCenter.y;
+    const deltaZ = clampedNewCenter.z - this._originalEntityCenter.z;
+
+    // 计算真正的新中心位置（不是鼠标位置）
+    const actualNewCenter = new Cesium.Cartesian3(
+      this._originalEntityCenter.x + deltaX,
+      this._originalEntityCenter.y + deltaY,
+      this._originalEntityCenter.z + deltaZ
+    );
+
+    // 更新原始中心（用于下次平移计算）
+    this._originalEntityCenter = actualNewCenter;
+
+    // 更新中心控制点位置
+    this._dragHandle.position = new Cesium.ConstantPositionProperty(actualNewCenter);
+
+    if (Cesium.defined(this._selectedEntity.polyline)) {
+      // 线图元：平移所有位置
+      const newPositions = this._originalPositions.map(p => {
+        const newPos = new Cesium.Cartesian3(p.x + deltaX, p.y + deltaY, p.z + deltaZ);
+        // 修复：贴地
+        return this._clampPositionToGround(newPos);
+      });
+      this._selectedEntity.polyline.positions = newPositions;
+      
+      // 修复：更新所有顶点控制点位置，同时更新中心控制点位置
+      this._editHandles.forEach((handle) => {
+        // 修复：统一使用 includes('center') 来判断中心控制点
+        if (handle.id && handle.id.includes('center')) {
+          // 中心控制点已经更新过了
+          return;
+        }
+        // 找到对应的顶点索引
+        const match = handle.id.match(/__edit_handle_(\d+)$/);
+        if (match) {
+          const index = parseInt(match[1], 10);
+          if (newPositions[index]) {
+            handle.position = new Cesium.ConstantPositionProperty(newPositions[index]);
+          }
+        }
+      });
+      
+      // 更新原始位置缓存
+      this._originalPositions = newPositions;
+    } else if (Cesium.defined(this._selectedEntity.polygon)) {
+      if (this._isCircle(this._selectedEntity)) {
+        // 圆形平移
+        const oldCenter = this._selectedEntity._circleCenter; // [lon, lat]
+
+        // 将旧的圆心经纬度转为 Cartesian3
+        const oldCenterCartesian = Cesium.Cartesian3.fromDegrees(oldCenter[0], oldCenter[1], 0);
+
+        // 应用偏移量计算新的 Cartesian3 位置
+        const newCenterCartesian = new Cesium.Cartesian3(
+          oldCenterCartesian.x + deltaX,
+          oldCenterCartesian.y + deltaY,
+          oldCenterCartesian.z + deltaZ
+        );
+
+        // 将新的 Cartesian3 转回经纬度
+        const newCenterCartographic = Cesium.Cartographic.fromCartesian(newCenterCartesian);
+        const newCenterLon = Cesium.Math.toDegrees(newCenterCartographic.longitude);
+        const newCenterLat = Cesium.Math.toDegrees(newCenterCartographic.latitude);
+
+        this._selectedEntity._circleCenter = [newCenterLon, newCenterLat];
+
+        // 更新多边形顶点
+        const positions = this._generateCirclePositions(
+          this._selectedEntity._circleCenter,
+          this._selectedEntity._circleRadius,
+          256
+        );
+        const flat = positions.flatMap(c => [c[0], c[1], 0]);
+        this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(flat)
+        );
+
+        // 更新圆心控制点位置
+        const centerHandle = this._editHandles.find(h => h.id && h.id.includes('__edit_handle_center'));
+        if (centerHandle) {
+          centerHandle.position = new Cesium.ConstantPositionProperty(newCenterCartesian);
+        }
+      } else {
+        // 普通多边形：平移所有顶点
+        const newPositions = this._originalPositions.map(p => {
+          const newPos = new Cesium.Cartesian3(p.x + deltaX, p.y + deltaY, p.z + deltaZ);
+          // 修复：贴地
+          return this._clampPositionToGround(newPos);
+        });
+        // 添加闭合点
+        newPositions.push(newPositions[0].clone());
+        this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(newPositions);
+        
+        // 修复：更新顶点控制点位置，使用更可靠的ID匹配
+        this._editHandles.forEach((handle) => {
+          // 修复：统一使用 includes('center') 来判断中心控制点
+          if (handle.id && handle.id.includes('center')) {
+            return;
+          }
+          // 提取数字索引
+          const match = handle.id.match(/__edit_handle_(\d+)$/);
+          if (match) {
+            const index = parseInt(match[1], 10);
+            if (newPositions[index]) {
+              handle.position = new Cesium.ConstantPositionProperty(newPositions[index]);
+            }
+          }
+        });
+        
+        // 更新原始位置缓存
+        this._originalPositions = newPositions.slice(0, -1);
+      }
+    } else if (Cesium.defined(this._selectedEntity.position)) {
+      // 点/文本图元：平移位置
+      this._selectedEntity.position = new Cesium.ConstantPositionProperty(actualNewCenter);
+      this._originalPositions = [actualNewCenter];
+    }
+  }
+
+  _isRectangle(positions) {
+    if (positions.length !== 4) return false;
+
+    const relativeTolerance = 0.001; // 0.1% 相对误差
+
+    // 提取XY坐标（忽略Z）
+    const xy = positions.map(p => ({ x: p.x, y: p.y }));
+
+    const [v0, v1, v2, v3] = xy;
+
+    // 计算XY平面上的距离
+    const dist = (p1, p2) => Math.sqrt(
+      Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2)
+    );
+
+    const d01 = dist(v0, v1);
+    const d12 = dist(v1, v2);
+    const d23 = dist(v2, v3);
+    const d30 = dist(v3, v0);
+    const d02 = dist(v0, v2);
+    const d13 = dist(v1, v3);
+
+    const oppositeSidesEqual =
+      Math.abs(d01 - d23) / Math.max(d01, d23) < relativeTolerance &&
+      Math.abs(d12 - d30) / Math.max(d12, d30) < relativeTolerance;
+
+    const diagonalsEqual = Math.abs(d02 - d13) / Math.max(d02, d13) < relativeTolerance;
+
+    return oppositeSidesEqual && diagonalsEqual;
+  }
+
+  /**
+   * 检测 entity 是否为圆
+   */
+  _isCircle(entity) {
+    return entity && entity._isCircle === true;
+  }
+
+  /**
+   * 获取圆的中心点和半径
+   */
+  _getCircleInfo(entity) {
+    if (!this._isCircle(entity)) return null;
+    return {
+      center: entity._circleCenter,  // [lon, lat]
+      radius: entity._circleRadius   // 米
+    };
+  }
+
+  /**
+   * 生成圆的多边形顶点（用于更新圆的形状）
+   * @param {Array} center [lon, lat]
+   * @param {number} radius 半径（米）
+   * @param {number} segments 顶点数
+   * @returns {Array} 经纬度数组
+   */
+  _generateCirclePositions(center, radius, segments = 256) {
+    const [lon, lat] = center;
+    const radPerDeg = Math.PI / 180;
+    const positions = [];
+
+    // 当前纬度的经度米数（随纬度变化）
+    const metersPerLonDeg = 111320 * Math.cos(lat * radPerDeg);
+    const metersPerLatDeg = 110540; // 纬度方向相对固定
+
+    for (let i = 0; i <= segments; i++) {
+      const angle = (i / segments) * Math.PI * 2;
+      const dLon = (radius * Math.cos(angle) / metersPerLonDeg);
+      const dLat = (radius * Math.sin(angle) / metersPerLatDeg);
+      positions.push([lon + dLon, lat + dLat]);
+    }
+
+    return positions;
+  }
+
+  /**
+   * 计算圆周上的点
+   * @param {Array} center [lon, lat]
+   * @param {number} radius 半径（米）
+   * @param {number} angleRadians 角度（弧度）
+   * @returns {Array} [lon, lat]
+   */
+  _getPointOnCircle(center, radius, angleRadians) {
+    const [lon, lat] = center;
+    const radPerDeg = Math.PI / 180;
+    const metersPerLonDeg = 111320 * Math.cos(lat * radPerDeg);
+    const metersPerLatDeg = 110540;
+
+    const dLon = (radius * Math.cos(angleRadians) / metersPerLonDeg);
+    const dLat = (radius * Math.sin(angleRadians) / metersPerLatDeg);
+    return [lon + dLon, lat + dLat];
+  }
+
+  /**
+   * 将 oldAxis 绕原点旋转到与 newAxis 垂直，并保持原长度和相对方向（顺/逆时针）
+   * @param {Array} newAxis [dx, dy]
+   * @param {Array} oldAxis [dx, dy]
+   * @returns {Array} [rx, ry]
+   */
+  _rotatePerpendicular(newAxis, oldAxis) {
+    const newLen = Math.hypot(newAxis[0], newAxis[1]);
+    const oldLen = Math.hypot(oldAxis[0], oldAxis[1]);
+    if (newLen === 0 || oldLen === 0) return [0, 0];
+
+    const ux = newAxis[0] / newLen;
+    const uy = newAxis[1] / newLen;
+
+    // 叉积判断 oldAxis 在 newAxis 的左侧还是右侧
+    const cross = newAxis[0] * oldAxis[1] - newAxis[1] * oldAxis[0];
+    const sign = cross >= 0 ? 1 : -1;
+
+    // 将 newAxis 旋转 ±90° 得到新的垂直方向，并保持 oldAxis 长度
+    return [-sign * uy * oldLen, sign * ux * oldLen];
+  }
+
+  /**
+   * 创建圆形辅助线
+   */
+  _createCircleOutline() {
+    const self = this;
+
+    // 圆周辅助线（黄色）
+    this._positionOutline = this.createTempEntity(this.generateId('temp_circle_outline'), {
+      polyline: {
+        positions: new Cesium.CallbackProperty(function () {
+          const circleInfo = self._getCircleInfo(self._selectedEntity);
+          if (!circleInfo) return [];
+
+          const { center, radius } = circleInfo;
+          const positions = self._generateCirclePositions(center, radius, 256);
+          const flat = positions.flatMap(c => [c[0], c[1], 0]);
+          return Cesium.Cartesian3.fromDegreesArrayHeights(flat);
+        }, false),
+        material: Cesium.Color.YELLOW,
+        width: 2,
+        clampToGround: true
+      }
+    });
+    this._positionOutline._isPreview = true;
+    this._tempEntities.push(this._positionOutline);
+
+    // 半径连线（红色，从圆心到编辑点）
+    // 修复：正确获取半径控制点的位置
+    this._radiusLine = this.createTempEntity(this.generateId('temp_radius_line'), {
+      polyline: {
+        positions: new Cesium.CallbackProperty(function () {
+          const circleInfo = self._getCircleInfo(self._selectedEntity);
+          if (!circleInfo) return [];
+
+          const { center } = circleInfo;
+          // 修复：通过ID查找半径控制点，而不是固定索引
+          const radiusHandle = self._editHandles.find(h => h.id && h.id.includes('__edit_handle_radius'));
+          if (!radiusHandle) return [];
+
+          const radiusPos = radiusHandle.position.getValue(Cesium.JulianDate.now());
+          if (!radiusPos) return [];
+
+          const centerCart = Cesium.Cartesian3.fromDegrees(center[0], center[1], 0);
+          return [centerCart, radiusPos];
+        }, false),
+        material: Cesium.Color.RED,
+        width: 3,
+        clampToGround: true
+      }
+    });
+    this._radiusLine._isPreview = true;
+    this._tempEntities.push(this._radiusLine);
+  }
+
+  /**
+   * 计算两点之间的距离（米）
+   * @param {Array} coord1 [lon, lat]
+   * @param {Array} coord2 [lon, lat]
+   * @returns {number} 距离（米）
+   */
+  _calcDistance(coord1, coord2) {
+    const earthRadius = 6371000; // 米
+    const [lon1, lat1] = coord1.map(d => d * Math.PI / 180);
+    const [lon2, lat2] = coord2.map(d => d * Math.PI / 180);
+
+    const dLat = lat2 - lat1;
+    const dLon = lon2 - lon1;
+
+    const a = Math.sin(dLat / 2) ** 2 +
+      Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+    return earthRadius * c;
+  }
+
+  /**
+   * 计算矩形拖拽后的新顶点位置
+   * @param {Cesium.Cartesian3} newPos - 拖拽的新位置
+   * @param {Array} originalPositions - 原始4个顶点位置
+   * @param {number} draggedIndex - 被拖拽的顶点索引 (0,1,2,3)
+   * @returns {Array} 新的4个顶点位置数组
+   */
+  _computeRectangleNewPositions(newPos, originalPositions, draggedIndex) {
+    // 对角顶点索引：0->2, 1->3, 2->0, 3->1
+    const oppositeIndex = (draggedIndex + 2) % 4;
+    const newP = Cesium.Cartographic.fromCartesian(newPos);
+    const currentPos = originalPositions.map(p => Cesium.Cartographic.fromCartesian(p));
+    const oppositePos = currentPos[oppositeIndex];
+
+    const newPositions = new Array(4);
+    newPositions[draggedIndex] = newPos; // 拖拽点为新位置
+    newPositions[oppositeIndex] = originalPositions[oppositeIndex]; // 对角点固定
+
+    // 计算相邻两个顶点
+    // draggedIndex 的相邻顶点是 (draggedIndex + 1) % 4 和 (draggedIndex + 3) % 4
+    const neighbor1 = (draggedIndex + 1) % 4;
+    const neighbor2 = (draggedIndex + 3) % 4;
+
+    // neighbor1 使用 newPos 的 longitude 和 opposite 的 latitude
+    newPositions[neighbor1] = Cesium.Cartesian3.fromRadians(
+      newP.longitude,
+      oppositePos.latitude,
+      oppositePos.height
+    );
+
+    // neighbor2 使用 opposite 的 longitude 和 newPos 的 latitude
+    newPositions[neighbor2] = Cesium.Cartesian3.fromRadians(
+      oppositePos.longitude,
+      newP.latitude,
+      oppositePos.height
+    );
+
+    return newPositions;
+  }
+
+  _updateEntityPosition(newLonLat) {
+    if (!this._selectedEntity) return;
+
+    const handleIndex = this._editHandles.indexOf(this._dragHandle);
+    if (handleIndex === -1) return;
+
+    // 修复：新位置贴地（高度设为0）
+    const newCartesian = Cesium.Cartesian3.fromDegrees(newLonLat[0], newLonLat[1], 0);
+
+    // 标绘图元：拖拽控制点重新生成几何
+    if (this._selectedEntity._isPlotGraphic) {
+      const handleId = this._dragHandle.id;
+
+      // 拖拽中心控制点：平移整个标绘图元
+      if (handleId && handleId.includes('center') && this._originalEntityCenter) {
+        const clampedNewCenter = this._clampPositionToGround(newCartesian);
+        this._translatePlotControlPoints(clampedNewCenter, this._originalEntityCenter);
+        this._originalEntityCenter = clampedNewCenter;
+        return;
+      }
+
+      const handleMatch = handleId.match(/__edit_handle_(\d+)$/);
+      if (!handleMatch) return;
+
+      const index = parseInt(handleMatch[1], 10);
+      const plotType = this._selectedEntity._plotType;
+
+      // 扇形：拖拽圆心（索引0）时整体平移，保持两半径等长
+      if (plotType === PlotGraphicType.SECTOR && index === 0) {
+        const oldCenter = this._selectedEntity._controlPoints[0];
+        const oldCenterCart = Cesium.Cartesian3.fromDegrees(oldCenter[0], oldCenter[1], oldCenter[2] || 0);
+        const clampedNewCenter = this._clampPositionToGround(newCartesian);
+        this._translatePlotControlPoints(clampedNewCenter, oldCenterCart);
+        // 中心控制点固定在圆心
+        this._originalEntityCenter = this._clampPositionToGround(
+          Cesium.Cartesian3.fromDegrees(
+            this._selectedEntity._controlPoints[0][0],
+            this._selectedEntity._controlPoints[0][1],
+            this._selectedEntity._controlPoints[0][2] || 0
+          )
+        );
+        return;
+      }
+
+      const controlPoints = this._selectedEntity._controlPoints.map((cp, i) =>
+        i === index ? [newLonLat[0], newLonLat[1], cp[2] || 0] : cp
+      );
+
+      // 扇形：两个半径控制点同步缩放，保持半径一致
+      if (plotType === PlotGraphicType.SECTOR && index > 0) {
+        const center = controlPoints[0];
+        // 使用球面距离（米）作为新半径，与 createSector 保持一致
+        const newRadius = PlotGeometryUtil._calcSphericalDistance(controlPoints[index], center);
+        const otherIndex = index === 1 ? 2 : 1;
+        const otherCp = controlPoints[otherIndex];
+        // 保持另一个控制点的真实地理方位角，按新半径在球面圆上重新定位
+        const otherBearing = PlotGeometryUtil._getBearing(center, otherCp);
+        const newOtherPoint = PlotGeometryUtil._getPointAtBearingAndDistance(center, newRadius, otherBearing);
+        controlPoints[otherIndex] = [newOtherPoint[0], newOtherPoint[1], otherCp[2] || 0];
+      }
+
+      // 椭圆：长短半轴端点控制，保持两轴垂直
+      if (plotType === PlotGraphicType.ELLIPSE && (index === 1 || index === 2)) {
+        const center = controlPoints[0];
+        if (index === 1) {
+          // 长轴端点移动：改变长轴长度/方向，短轴端点跟随旋转并保持长度
+          const newMajor = [controlPoints[1][0] - center[0], controlPoints[1][1] - center[1]];
+          const oldMinor = [
+            this._selectedEntity._controlPoints[2][0] - center[0],
+            this._selectedEntity._controlPoints[2][1] - center[1]
+          ];
+          const newMinor = this._rotatePerpendicular(newMajor, oldMinor);
+          controlPoints[2] = [center[0] + newMinor[0], center[1] + newMinor[1], center[2] || 0];
+        } else if (index === 2) {
+          // 短轴端点移动：只改变短轴长度，投影到过中心且与长轴垂直的直线上
+          const major = [controlPoints[1][0] - center[0], controlPoints[1][1] - center[1]];
+          const majorLen = Math.hypot(major[0], major[1]);
+          if (majorLen > 0) {
+            const ux = major[0] / majorLen;
+            const uy = major[1] / majorLen;
+            // 长轴逆时针旋转 90° 得到垂直方向
+            const perpUx = -uy;
+            const perpUy = ux;
+            const mouseVec = [newLonLat[0] - center[0], newLonLat[1] - center[1]];
+            const projectedLen = mouseVec[0] * perpUx + mouseVec[1] * perpUy;
+            controlPoints[2] = [
+              center[0] + perpUx * projectedLen,
+              center[1] + perpUy * projectedLen,
+              center[2] || 0
+            ];
+          }
+        }
+      }
+
+      // 更新控制点缓存
+      this._selectedEntity._controlPoints = controlPoints;
+
+      // 重新生成几何
+      const wrapper = this._graphicModule.wrapperMap.get(this._selectedEntity.id);
+      if (wrapper) {
+        wrapper.setControlPoints(controlPoints);
+      }
+
+      // 更新控制点位置（不含中心控制点）
+      this._editHandles.forEach((handle) => {
+        if (handle.id && handle.id.includes('center')) return;
+        // 按句柄 ID 解析真实控制点索引（扇形跳过了索引 0）
+        const match = handle.id.match(/__edit_handle_(\d+)$/);
+        if (match) {
+          const cpIndex = parseInt(match[1], 10);
+          const cp = controlPoints[cpIndex];
+          handle.position = new Cesium.ConstantPositionProperty(
+            this._clampPositionToGround(Cesium.Cartesian3.fromDegrees(cp[0], cp[1], cp[2] || 0))
+          );
+        }
+      });
+
+      // 更新中心控制点位置
+      const centerHandle = this._editHandles.find(h => h.id && h.id.includes('center'));
+      if (centerHandle) {
+        // 扇形/椭圆：中心控制点固定在中心；其他类型使用重心
+        const newCenter = (plotType === PlotGraphicType.SECTOR || plotType === PlotGraphicType.ELLIPSE)
+          ? controlPoints[0]
+          : this._getPlotControlPointsCenter(controlPoints);
+        centerHandle.position = new Cesium.ConstantPositionProperty(
+          this._clampPositionToGround(Cesium.Cartesian3.fromDegrees(newCenter[0], newCenter[1], newCenter[2] || 0))
+        );
+        this._originalEntityCenter = this._clampPositionToGround(
+          Cesium.Cartesian3.fromDegrees(newCenter[0], newCenter[1], newCenter[2] || 0)
+        );
+      }
+
+      // 更新原始位置缓存
+      this._originalPositions = this._getEntityPositions(this._selectedEntity);
+      return;
+    }
+
+    const hierarchy = this._selectedEntity.polygon?.hierarchy?.getValue(Cesium.JulianDate.now());
+
+    // 拖动中心控制点：平移整个图元
+    // 修复：统一使用 includes('center') 来判断
+    if (this._dragHandle.id && this._dragHandle.id.includes('center') && this._originalEntityCenter) {
+      this._translateEntity(newCartesian);
+      return;
+    }
+
+    // 矩形特殊情况：重新计算所有4个顶点
+    // 确保是数字索引（矩形用 [0,1,2,3]，圆用 ['center','radius']）
+    if (this._handleVertexIndices &&
+      Array.isArray(this._handleVertexIndices) &&
+      typeof this._handleVertexIndices[0] === 'number' &&
+      Cesium.defined(this._selectedEntity.polygon)) {
+      if (!hierarchy || !hierarchy.positions || hierarchy.positions.length < 4) return;
+
+      const draggedVertexIndex = this._handleVertexIndices[handleIndex];
+      const newPositions = this._computeRectangleNewPositions(newCartesian, hierarchy.positions, draggedVertexIndex);
+
+      // 修复：所有新位置贴地
+      const clampedPositions = newPositions.map(pos => this._clampPositionToGround(pos));
+
+      // 更新多边形
+      this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(clampedPositions);
+
+      // 更新所有控制点位置（使用 ConstantPositionProperty 确保正确更新）
+      this._editHandles.forEach((handle, i) => {
+        // 修复：跳过中心控制点
+        if (handle.id && handle.id.includes('center')) return;
+        handle.position = new Cesium.ConstantPositionProperty(clampedPositions[i]);
+      });
+
+      // 修复：顶点编辑后重新计算并更新中心控制点位置
+      this._updateCenterHandlePosition();
+
+      return;
+    }
+
+    // 圆形特殊情况：编辑半径或圆心
+    if (this._handleVertexIndices &&
+      Array.isArray(this._handleVertexIndices) &&
+      this._isCircle(this._selectedEntity)) {
+
+      const circleInfo = this._getCircleInfo(this._selectedEntity);
+      if (!circleInfo) return;
+
+      const handleId = this._dragHandle.id;
+
+      // 拖拽圆心：平移整个圆
+      if (handleId && handleId.includes('__edit_handle_center')) {
+        // 计算新圆心
+        const newCenterLonLat = newLonLat;
+
+        // 更新圆心控制点位置
+        this._dragHandle.position = newCartesian;
+
+        // 更新圆的实体属性
+        this._selectedEntity._circleCenter = newCenterLonLat;
+
+        // 更新多边形顶点
+        const positions = this._generateCirclePositions(newCenterLonLat, circleInfo.radius, 256);
+        const flat = positions.flatMap(c => [c[0], c[1], 0]);
+        this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(
+          Cesium.Cartesian3.fromDegreesArrayHeights(flat)
+        );
+
+        // 更新半径控制点位置
+        const radiusHandle = this._editHandles.find(h => h.id && h.id.includes('radius'));
+        if (radiusHandle) {
+          const radiusPoint = this._getPointOnCircle(newCenterLonLat, circleInfo.radius, 0);
+          radiusHandle.position = new Cesium.ConstantPositionProperty(
+            Cesium.Cartesian3.fromDegrees(radiusPoint[0], radiusPoint[1], 0)
+          );
+        }
+
+        return;
+      }
+
+      // 拖拽半径：计算新半径
+      let newRadius = this._calcDistance(circleInfo.center, newLonLat);
+      // 更新半径控制点位置（在圆周上）
+      const angle = Math.atan2(newLonLat[1] - circleInfo.center[1], newLonLat[0] - circleInfo.center[0]);
+      const radiusPoint = this._getPointOnCircle(circleInfo.center, newRadius, angle);
+      this._dragHandle.position = new Cesium.ConstantPositionProperty(
+        Cesium.Cartesian3.fromDegrees(radiusPoint[0], radiusPoint[1], 0)
+      );
+
+      // 更新圆的实体属性
+      this._selectedEntity._circleCenter = circleInfo.center;
+      this._selectedEntity._circleRadius = newRadius;
+
+      // 更新多边形顶点
+      const positions = this._generateCirclePositions(circleInfo.center, newRadius, 256);
+      const flat = positions.flatMap(c => [c[0], c[1], 0]);
+      this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(
+        Cesium.Cartesian3.fromDegreesArrayHeights(flat)
+      );
+
+      return;
+    }
+
+    if (Cesium.defined(this._selectedEntity.polyline)) {
+      const positions = this._selectedEntity.polyline.positions.getValue(Cesium.JulianDate.now());
+      if (positions && positions[handleIndex]) {
+        // 直接修改数组元素触发更新
+        positions[handleIndex] = newCartesian;
+        this._selectedEntity.polyline.positions = positions;
+        this._dragHandle.position = new Cesium.ConstantPositionProperty(newCartesian);
+        
+        // 修复：线编辑后重新计算并更新中心控制点位置
+        this._updateCenterHandlePosition();
+      }
+    } else if (Cesium.defined(this._selectedEntity.polygon)) {
+      // 获取当前实际顶点数（不包含闭合点）
+      const actualVertexCount = this._editHandles.filter(h => !h.id.includes('center')).length;
+
+      // 构建新位置数组
+      const newPositions = [];
+      let vertexIndex = 0;
+      for (let i = 0; i < this._editHandles.length; i++) {
+        const handle = this._editHandles[i];
+        // 修复：跳过中心控制点
+        if (handle.id && handle.id.includes('center')) continue;
+        
+        if (handle === this._dragHandle) {
+          newPositions.push(newCartesian);
+        } else {
+          // 从控制点获取当前位置
+          const pos = handle.position.getValue(Cesium.JulianDate.now());
+          // 修复：确保位置贴地
+          newPositions.push(this._clampPositionToGround(pos));
+        }
+        vertexIndex++;
+      }
+
+      // ✅ 添加闭合点
+      newPositions.push(newPositions[0].clone());
+
+      // 更新多边形
+      this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(newPositions);
+
+      // 更新控制点
+      this._dragHandle.position = new Cesium.ConstantPositionProperty(newCartesian);
+      
+      // 修复：多边形编辑后重新计算并更新中心控制点位置
+      this._updateCenterHandlePosition();
+
+      return;
+    } else if (Cesium.defined(this._selectedEntity.position)) {
+      this._selectedEntity.position = new Cesium.ConstantPositionProperty(newCartesian);
+      this._dragHandle.position = new Cesium.ConstantPositionProperty(newCartesian);
+    }
+  }
+
+  _highlightEntity(entity, highlight) {
+    if (!entity) return;
+
+    if (Cesium.defined(entity.point)) {
+      if (highlight) {
+        entity.point.outlineColor = Cesium.Color.CYAN;
+        entity.point.outlineWidth = 3;
+      } else {
+        entity.point.outlineColor = Cesium.Color.WHITE;
+        entity.point.outlineWidth = 1;
+      }
+    }
+
+    if (Cesium.defined(entity.polyline)) {
+      if (highlight) {
+        entity.polyline.material = Cesium.Color.CYAN;
+      } else {
+        entity.polyline.material = Cesium.Color.BLUE;
+      }
+    }
+
+    if (Cesium.defined(entity.polygon)) {
+      if (highlight) {
+        entity.polygon.outlineColor = Cesium.Color.CYAN;
+      } else {
+        entity.polygon.outlineColor = Cesium.Color.WHITE;
+      }
+    }
+  }
+
+  /**
+   * 获取当前选中的图元 ID
+   */
+  getSelectedEntityId() {
+    return this._selectedEntityId;
+  }
+
+  /**
+   * 获取编辑前的原始位置（用于撤销）
+   */
+  getOriginalPositions() {
+    return this._originalPositions;
+  }
+
+  /**
+   * 撤销编辑，恢复原始位置
+   */
+  undo() {
+    if (!this._selectedEntity) return;
+
+    // 圆形特殊处理：恢复圆心和半径
+    if (this._isCircle(this._selectedEntity) && this._originalCircleCenter && this._originalCircleRadius) {
+      const center = this._originalCircleCenter;
+      const radius = this._originalCircleRadius;
+
+      // 恢复圆的实体属性
+      this._selectedEntity._circleCenter = center;
+      this._selectedEntity._circleRadius = radius;
+
+      // 更新多边形顶点
+      const positions = this._generateCirclePositions(center, radius, 256);
+      const flat = positions.flatMap(c => [c[0], c[1], 0]);
+      this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(
+        Cesium.Cartesian3.fromDegreesArrayHeights(flat)
+      );
+
+      this._createEditHandles();
+      this._emitEditComplete();
+      return;
+    }
+
+    // 优先使用矩形原始位置，其次使用一般原始位置
+    const originalPositions = this._rectangleOriginalPositions || this._originalPositions;
+    if (!originalPositions) return;
+
+    // 拷贝一份避免直接修改原始数据
+    const positionsCopy = originalPositions.map(p => p.clone ? p.clone() : p);
+
+    if (Cesium.defined(this._selectedEntity.polyline)) {
+      this._selectedEntity.polyline.positions = positionsCopy;
+    } else if (Cesium.defined(this._selectedEntity.polygon)) {
+      this._selectedEntity.polygon.hierarchy = new Cesium.PolygonHierarchy(positionsCopy);
+    }
+
+    this._createEditHandles();
+    this._emitEditComplete();
+  }
+
+  _emitSelect(entityId) {
+    if (this._options.onSelect) {
+      this._options.onSelect({ entityId });
+    }
+  }
+
+  _emitEditComplete() {
+    if (this._options.onEditComplete) {
+      this._options.onEditComplete({
+        entityId: this._selectedEntityId,
+        positions: this._getEntityPositions(this._selectedEntity)
+      });
+    }
+  }
+}