deeptwins-engine-3d 0.1.32 → 0.1.34

package/dist/esm/drawer/shape/Polygon.js

@@ -5,11 +5,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
@@ -17,71 +14,426 @@ function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) ===
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-import { ArcType, CallbackProperty, ClassificationType, defined, Entity, PolygonHierarchy } from 'deeptwins-cesium';
-import BasicGraphics from "../base";
-var Polygon = /*#__PURE__*/function (_BasicGraphics) {
-  _inherits(Polygon, _BasicGraphics);
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import * as Cesium from 'deeptwins-cesium';
+import { isNil } from 'lodash';
+import { v4 as uuidV4 } from 'uuid';
+import PositionProperty from "../../property/PositionProperty";
+import * as utils from "../../tool/utils";
+import { STATUS } from "../index";
+import BaseShape from "./BaseShape";
+import { DragPoint } from "./Point";
+import { ShapePolyline } from "./Polyline";
+
+// 创建形状面
+export var ShapePolygon = /*#__PURE__*/function () {
+  /**
+   * 构造函数，用于创建一个地图多边形对象
+   * @param map 地图实例对象，用于获取地图上下文
+   * @param options 配置选项对象
+   * @param options.positions 多边形的坐标点数组
+   * @param options.style 多边形的样式配置
+   */
+  function ShapePolygon(map, _ref) {
+    var positions = _ref.positions,
+      style = _ref.style;
+    _classCallCheck(this, ShapePolygon);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "id", '');
+    _defineProperty(this, "layer", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "_geoJson", void 0);
+    _defineProperty(this, "_style", void 0);
+    this._mapContext = map._mapContext;
+    this.id = uuidV4();
+    this._geoJson = {
+      type: 'Feature',
+      geometry: {
+        type: 'Polygon',
+        coordinates: [positions]
+      }
+    };
+    this._style = style;
+    this._create();
+  }
+  _createClass(ShapePolygon, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('ShapePolygon实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "_create",
+    value: function _create() {
+      if (!this._canOperate()) return;
+      this.layer = this.getMap().addGraphicLayer(this._geoJson, {
+        type: 'polygon',
+        id: this.id,
+        style: this._style,
+        positionProperty: new PositionProperty()
+      });
+    }
+
+    // 更新
+  }, {
+    key: "update",
+    value: function update(positions) {
+      if (!this._canOperate()) return;
+      if (this.layer) {
+        this._geoJson.geometry.coordinates = [positions];
+        this.layer.setData(this._geoJson);
+      }
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      this.isDestroyed = true;
+      this.layer && this.layer.remove();
+      this.layer = null;
+    }
+  }]);
+  return ShapePolygon;
+}();
+var Polygon = /*#__PURE__*/function (_BaseShape) {
+  _inherits(Polygon, _BaseShape);
   var _super = _createSuper(Polygon);
-  function Polygon() {
+  function Polygon(drawContext, config) {
+    var _this;
     _classCallCheck(this, Polygon);
-    return _super.apply(this, arguments);
+    _this = _super.call(this, drawContext);
+    _defineProperty(_assertThisInitialized(_this), "type", 'polygon');
+    _defineProperty(_assertThisInitialized(_this), "shapePolylineLayer", void 0);
+    _defineProperty(_assertThisInitialized(_this), "shapePolygonLayer", void 0);
+    // 鼠标移动时的临时点
+    _defineProperty(_assertThisInitialized(_this), "_tempPosition", void 0);
+    _this.clampToGround = isNil(config === null || config === void 0 ? void 0 : config.clampToGround) ? _this.clampToGround : config.clampToGround;
+    _this.polylineStyle.clampToGround = _this.clampToGround;
+    if (_this.clampToGround) {
+      _this.polygonStyle.heightReference = Cesium.HeightReference.CLAMP_TO_GROUND;
+      _this.polygonStyle.perPositionHeight = false;
+    } else {
+      _this.polygonStyle.heightReference = Cesium.HeightReference.NONE;
+      _this.polygonStyle.perPositionHeight = true;
+    }
+    return _this;
   }
+
+  // 数据转换
   _createClass(Polygon, [{
-    key: "dropPoint",
-    value: function dropPoint(event) {
-      var _this = this;
-      if (!event.position) return;
-      var earthPosition = this.painter.pickCartesian3(event.position);
-      if (earthPosition && defined(earthPosition)) {
-        if (!this.painter._activeShapePoints.length) {
-          this.painter._activeShapePoints.push(earthPosition);
-          var dynamicPositions = new CallbackProperty(function () {
-            return new PolygonHierarchy(_this.painter._activeShapePoints);
-          }, false);
-          this.painter._dynamicShapeEntity = this.painter.addView(this.createShape(dynamicPositions, true));
+    key: "transformData",
+    value: function transformData(positions) {
+      var _this2 = this;
+      this.positions = positions;
+      this.shapePolylineLayer = new ShapePolyline(this.getMap(), {
+        map: this.getMap(),
+        positions: this._getDrawPolylinePositions(),
+        style: this.polylineStyle
+      });
+      this.shapePolygonLayer = new ShapePolygon(this.getMap(), {
+        map: this.getMap(),
+        positions: this._getDrawPolygonPositions(),
+        style: this.polygonStyle
+      });
+      positions.forEach(function (position, index) {
+        var layer = new DragPoint(_this2.getMap(), {
+          positions: position,
+          style: _this2.pointStyle
+        });
+        layer.isStart = index === 0;
+        layer.endEdit();
+        layer.show(false);
+        _this2.dragPoints.push(layer);
+      });
+      // 存入
+      this._drawContext.setDrawerLayer(this.id, this);
+    }
+
+    // 获取绘制中的线的点位
+  }, {
+    key: "_getDrawPolylinePositions",
+    value: function _getDrawPolylinePositions() {
+      var _this$positions;
+      if (!((_this$positions = this.positions) !== null && _this$positions !== void 0 && _this$positions.length)) return [];
+      var positions = this._tempPosition ? [].concat(_toConsumableArray(this.positions), [this._tempPosition]) : _toConsumableArray(this.positions);
+      var isNeedClose = positions.length > 2;
+      isNeedClose && positions.push(positions[0]);
+      return positions;
+    }
+
+    // 获取绘制中的面的点位
+  }, {
+    key: "_getDrawPolygonPositions",
+    value: function _getDrawPolygonPositions() {
+      var _this$positions2;
+      if (!((_this$positions2 = this.positions) !== null && _this$positions2 !== void 0 && _this$positions2.length)) return [];
+      return this._tempPosition ? [].concat(_toConsumableArray(this.positions), [this._tempPosition, this.positions[0]]) : [].concat(_toConsumableArray(this.positions), [this.positions[0]]);
+    }
+
+    // 添加点位
+  }, {
+    key: "addPoint",
+    value: function addPoint(position) {
+      var _this$positions3;
+      var lng = position.lng,
+        lat = position.lat,
+        alt = position.alt;
+      if (!((_this$positions3 = this.positions) !== null && _this$positions3 !== void 0 && _this$positions3.length)) {
+        // 创建
+        this.positions = [[lng, lat, alt]];
+        this.shapePolylineLayer = new ShapePolyline(this.getMap(), {
+          map: this.getMap(),
+          positions: this._getDrawPolylinePositions(),
+          style: this.polylineStyle
+        });
+        this.shapePolygonLayer = new ShapePolygon(this.getMap(), {
+          map: this.getMap(),
+          positions: this._getDrawPolygonPositions(),
+          style: this.polygonStyle
+        });
+      } else {
+        var _this$shapePolylineLa, _this$shapePolygonLay;
+        // 添加
+        this.positions.push([lng, lat, alt]);
+        (_this$shapePolylineLa = this.shapePolylineLayer) === null || _this$shapePolylineLa === void 0 || _this$shapePolylineLa.update(this._getDrawPolylinePositions());
+        (_this$shapePolygonLay = this.shapePolygonLayer) === null || _this$shapePolygonLay === void 0 || _this$shapePolygonLay.update(this._getDrawPolygonPositions());
+      }
+      // 创建拖动点位
+      this._createDragPoint(position);
+      // 绘制中
+      this.drawing(this);
+    }
+
+    // 创建拖动点位
+  }, {
+    key: "_createDragPoint",
+    value: function _createDragPoint(position) {
+      var _this$positions4;
+      var lng = position.lng,
+        lat = position.lat,
+        alt = position.alt;
+      var layer = new DragPoint(this.getMap(), {
+        positions: [lng, lat, alt],
+        style: this.pointStyle
+      });
+      layer.isStart = ((_this$positions4 = this.positions) === null || _this$positions4 === void 0 ? void 0 : _this$positions4.length) === 1;
+      this.dragPoints.push(layer);
+    }
+
+    // 删除上一个
+  }, {
+    key: "removePrev",
+    value: function removePrev() {
+      var _this$positions5, _this$positions6, _this$positions7, _this$positions8;
+      if (!((_this$positions5 = this.positions) !== null && _this$positions5 !== void 0 && _this$positions5.length)) return;
+      var i = ((_this$positions6 = this.positions) === null || _this$positions6 === void 0 ? void 0 : _this$positions6.length) - 1;
+      this.positions.splice(i, 1);
+      if (!((_this$positions7 = this.positions) !== null && _this$positions7 !== void 0 && _this$positions7.length)) {
+        this.positions = [];
+        this.shapePolylineLayer && this.shapePolylineLayer.destroy();
+        this.shapePolylineLayer = null;
+        this.shapePolygonLayer && this.shapePolygonLayer.destroy();
+        this.shapePolygonLayer = null;
+      } else {
+        var _this$shapePolylineLa2, _this$shapePolygonLay2;
+        (_this$shapePolylineLa2 = this.shapePolylineLayer) === null || _this$shapePolylineLa2 === void 0 || _this$shapePolylineLa2.update(this._getDrawPolylinePositions());
+        (_this$shapePolygonLay2 = this.shapePolygonLayer) === null || _this$shapePolygonLay2 === void 0 || _this$shapePolygonLay2.update(this._getDrawPolygonPositions());
+      }
+      if (this.dragPoints[i]) {
+        this.dragPoints[i].destroy();
+        this.dragPoints.splice(i, 1);
+      }
+      // 绘制中
+      this.drawing(this);
+      this._drawContext.options.onMouseMoveChange && this._drawContext.options.onMouseMoveChange({
+        layer: this,
+        positions: this._tempPosition ? [].concat(_toConsumableArray(this.positions), [this._tempPosition]) : this.positions
+      });
+      if (!((_this$positions8 = this.positions) !== null && _this$positions8 !== void 0 && _this$positions8.length)) {
+        this._drawContext._changeStatus(STATUS.START_DRAW);
+        this._drawContext._updateTooltip();
+      }
+    }
+
+    // 更新临时点位
+  }, {
+    key: "updateTempPosition",
+    value: function updateTempPosition(position) {
+      var _this$shapePolylineLa3, _this$shapePolygonLay3;
+      if (!this.shapePolylineLayer || !this.shapePolygonLayer) return;
+      var lng = position.lng,
+        lat = position.lat,
+        alt = position.alt;
+      this._tempPosition = [lng, lat, alt];
+      (_this$shapePolylineLa3 = this.shapePolylineLayer) === null || _this$shapePolylineLa3 === void 0 || _this$shapePolylineLa3.update(this._getDrawPolylinePositions());
+      (_this$shapePolygonLay3 = this.shapePolygonLayer) === null || _this$shapePolygonLay3 === void 0 || _this$shapePolygonLay3.update(this._getDrawPolygonPositions());
+      this._drawContext.options.onMouseMoveChange && this._drawContext.options.onMouseMoveChange({
+        layer: this,
+        positions: this._tempPosition ? [].concat(_toConsumableArray(this.positions), [this._tempPosition]) : this.positions
+      });
+    }
+
+    // 结束绘制
+  }, {
+    key: "endDraw",
+    value: function endDraw() {
+      var _this$shapePolylineLa4, _this$shapePolygonLay4;
+      this._tempPosition = null;
+      (_this$shapePolylineLa4 = this.shapePolylineLayer) === null || _this$shapePolylineLa4 === void 0 || _this$shapePolylineLa4.update(this._getDrawPolylinePositions());
+      (_this$shapePolygonLay4 = this.shapePolygonLayer) === null || _this$shapePolygonLay4 === void 0 || _this$shapePolygonLay4.update(this._getDrawPolygonPositions());
+      this.drawEnd(this);
+      // 存入
+      this._drawContext.setDrawerLayer(this.id, this);
+      this.startEdit();
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      _get(_getPrototypeOf(Polygon.prototype), "startEdit", this).call(this);
+      this.edges = [];
+      this.edges = this._createEdgesAndMiddle(this.dragPoints, true);
+    }
+
+    // 开始鼠标拖拽
+  }, {
+    key: "mouseDragStart",
+    value: function mouseDragStart(position, dragLayer) {
+      var _this3 = this;
+      this.dragging = true;
+      this.dragLayer = dragLayer;
+      if (this.dragLayer.isMiddlePoint) {
+        // 找到相应有关系的边
+        var changeEdges = this.edges.filter(function (t) {
+          return t.middlePoint.id === _this3.dragLayer.id;
+        });
+        this.edges = this.edges.filter(function (t) {
+          return t.middlePoint.id !== _this3.dragLayer.id;
+        });
+        var _loop = function _loop() {
+          var source = changeEdges[i].source;
+          var target = changeEdges[i].target;
+          var middlePoint = changeEdges[i].middlePoint;
+          middlePoint.isStart = false;
+          _this3.edges.push({
+            source: source,
+            target: middlePoint,
+            middlePoint: null
+          }, {
+            source: middlePoint,
+            target: target,
+            middlePoint: null
+          });
+          var findIndex = _this3.dragPoints.findIndex(function (t) {
+            return t.id === source.id;
+          });
+          if (findIndex > -1) {
+            _this3.dragPoints.splice(findIndex + 1, 0, middlePoint);
+          }
+        };
+        for (var i = 0; i < changeEdges.length; i++) {
+          _loop();
+        }
+      } else {
+        // 找到相应有关系的边
+        var _changeEdges = this.edges.filter(function (t) {
+          return t.source.id === _this3.dragLayer.id || t.target.id === _this3.dragLayer.id;
+        });
+        for (var _i = 0; _i < _changeEdges.length; _i++) {
+          // 删除中间点
+          if (_changeEdges[_i].middlePoint) {
+            _changeEdges[_i].middlePoint.destroy();
+            _changeEdges[_i].middlePoint = null;
+          }
         }
-        this.SetBreakpoint(earthPosition);
       }
+      this.dragLayer.mouseDragStart();
     }
+
+    // 鼠标拖拽
   }, {
-    key: "playOff",
-    value: function playOff() {
-      // 去除最后一个多余点
-      this._cancel(this.createShape.bind(this));
-      return this._playOff(this.createShape.bind(this));
+    key: "mouseDragChange",
+    value: function mouseDragChange(position) {
+      var _this$shapePolylineLa5, _this$shapePolygonLay5, _this$_drawContext$op, _this$_drawContext$op2;
+      if (!this.dragging) return;
+      // 点拖拽
+      this.dragLayer.mouseDragChange(position);
+      // 根据edges重新生成新的点位
+      this.positions = this._updatePositionsFromEdges();
+      (_this$shapePolylineLa5 = this.shapePolylineLayer) === null || _this$shapePolylineLa5 === void 0 || _this$shapePolylineLa5.update(this._getDrawPolylinePositions());
+      (_this$shapePolygonLay5 = this.shapePolygonLayer) === null || _this$shapePolygonLay5 === void 0 || _this$shapePolygonLay5.update(this._getDrawPolygonPositions());
+      // 调用点位改变事件
+      ((_this$_drawContext$op = this._drawContext.options) === null || _this$_drawContext$op === void 0 ? void 0 : _this$_drawContext$op.onPointsChange) && ((_this$_drawContext$op2 = this._drawContext.options) === null || _this$_drawContext$op2 === void 0 ? void 0 : _this$_drawContext$op2.onPointsChange({
+        layer: this,
+        positions: this.positions
+      }));
     }
+
+    // 拖拽结束
   }, {
-    key: "cancel",
-    value: function cancel() {
-      this._cancel(this.createShape.bind(this));
+    key: "mouseDragEnd",
+    value: function mouseDragEnd() {
+      var _this4 = this;
+      // 找到相应有关系的边
+      var changeEdges = this.edges.filter(function (t) {
+        return t.source.id === _this4.dragLayer.id || t.target.id === _this4.dragLayer.id;
+      });
+      // 创建中间点
+      for (var i = 0; i < changeEdges.length; i++) {
+        var p1 = changeEdges[i].source.layer.layers[0].source.positions;
+        var p2 = changeEdges[i].target.layer.layers[0].source.positions;
+        var layer = this._createTwoPointMiddle(utils.getMidpoint(p1, p2));
+        layer.startEdit();
+        changeEdges[i].middlePoint = layer;
+      }
+      this.dragging = false;
+      this.dragLayer = null;
     }
+
+    // 结束编辑
   }, {
-    key: "createShape",
-    value: function createShape(hierarchy) {
-      var _this2 = this;
-      var isDynamic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-      var options = isDynamic && !this.sameStyle ? this.dynamicOptions : this.finalOptions;
-      var polygon = Object.assign({}, options, {
-        hierarchy: Array.isArray(hierarchy) ? new PolygonHierarchy(hierarchy) : hierarchy,
-        arcType: ArcType.RHUMB,
-        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
+    key: "endEdit",
+    value: function endEdit(layer) {
+      _get(_getPrototypeOf(Polygon.prototype), "endEdit", this).call(this, layer);
+      this.dragPoints.forEach(function (t) {
+        t.endEdit();
+        t.show(false);
       });
-      var polyline = {
-        width: options.outlineWidth,
-        material: options.outlineColor,
-        positions: Array.isArray(hierarchy) ? [].concat(_toConsumableArray(hierarchy), [hierarchy[0]]) : new CallbackProperty(function () {
-          return [].concat(_toConsumableArray(_this2.painter._activeShapePoints), [_this2.painter._activeShapePoints[0]]);
-        }, false),
-        clampToGround: true,
-        arcType: ArcType.RHUMB,
-        classificationType: this.painter._model ? ClassificationType.CESIUM_3D_TILE : undefined
-      };
-      return new Entity({
-        polygon: polygon,
-        polyline: polyline
+      this.edges.forEach(function (t) {
+        return t.middlePoint.destroy();
       });
+      this.edges = [];
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(Polygon.prototype), "destroy", this).call(this);
+      this.shapePolylineLayer && this.shapePolylineLayer.destroy();
+      this.shapePolylineLayer = null;
+      this.shapePolygonLayer && this.shapePolygonLayer.destroy();
+      this.shapePolygonLayer = null;
     }
   }]);
   return Polygon;
-}(BasicGraphics);
-export { Polygon as default };
+}(BaseShape);
+export default Polygon;

package/dist/esm/drawer/shape/Polyline.d.ts

@@ -1,11 +1,42 @@
-import { Entity } from 'deeptwins-cesium';
-import BasicGraphics from '../base';
-import type { CallbackProperty, Cartesian3 } from 'deeptwins-cesium';
-import type { EventArgs } from '../../tool/cesiumExtends/Subscriber';
-import type { LifeCycle } from '../base';
-export default class Polyline extends BasicGraphics implements LifeCycle {
-    dropPoint(event: EventArgs): void;
-    playOff(): Entity;
-    cancel(): void;
-    createShape(positions: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+import BaseShape from './BaseShape';
+export declare class ShapePolyline {
+    private readonly _mapContext;
+    id: string;
+    layer: any;
+    isDestroyed: boolean;
+    private _geoJson;
+    private _style;
+    /**
+     * 构造函数，用于创建一个线条对象
+     * @param map 地图实例对象，用于获取地图上下文
+     * @param options 配置选项对象
+     * @param options.positions 线条的坐标点数组
+     * @param options.style 线条的样式配置
+     */
+    constructor(map: any, { positions, style }: any);
+    getMap(): any;
+    private _canOperate;
+    private _create;
+    update(positions: any): void;
+    destroy(): void;
 }
+declare class Polyline extends BaseShape {
+    readonly type: string;
+    shapePolylineLayer: any;
+    private _tempPosition;
+    constructor(drawContext: any, config: any);
+    transformData(positions: any[]): void;
+    private _getDrawPolylinePositions;
+    addPoint(position: any): void;
+    private _createDragPoint;
+    removePrev(): void;
+    updateTempPosition(position: any): void;
+    endDraw(): void;
+    startEdit(): void;
+    mouseDragStart(position: any, dragLayer: any): void;
+    mouseDragChange(position: any): void;
+    mouseDragEnd(): void;
+    endEdit(layer: any): void;
+    destroy(): void;
+}
+export default Polyline;