deeptwins-engine-3d 0.1.32 → 0.1.34

package/dist/esm/measure/Distance.js

@@ -0,0 +1,239 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 _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); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+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); }
+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 { point } from '@turf/turf';
+import * as Cesium from 'deeptwins-cesium';
+import { SceneTransforms } from 'deeptwins-cesium';
+import { STATUS } from "../drawer";
+import { lngLatAltToCartesian3 } from "../tool/utils";
+import BaseDraw from "./BaseDraw";
+import * as utils from "./utils";
+var Distance = /*#__PURE__*/function (_BaseDraw) {
+  _inherits(Distance, _BaseDraw);
+  var _super = _createSuper(Distance);
+  function Distance(measureContext, config) {
+    var _this;
+    _classCallCheck(this, Distance);
+    _this = _super.call(this, measureContext);
+    _defineProperty(_assertThisInitialized(_this), "_type", 'distance');
+    _defineProperty(_assertThisInitialized(_this), "_config", void 0);
+    // 线图层
+    _defineProperty(_assertThisInitialized(_this), "_instance", void 0);
+    // 测量缓存数据
+    _defineProperty(_assertThisInitialized(_this), "_measureCache", []);
+    // 鼠标移动的label
+    _defineProperty(_assertThisInitialized(_this), "_mouseLabelLayer", void 0);
+    _this._config = config;
+    _this._init();
+    return _this;
+  }
+  _createClass(Distance, [{
+    key: "_init",
+    value: function _init() {
+      this._instance = this._drawer.startDraw('polyline', this._config);
+    }
+
+    // 绘制
+  }, {
+    key: "drawing",
+    value: function drawing(positions) {
+      if (!this._canOperate()) return;
+      this._measureContext._changeStatus(STATUS.DRAWING);
+      if (positions.length < 2) return {};
+      var mouseDistance = this._calculateMouseDistance(positions);
+      this._createMouseMoveLabel(positions.slice(-1)[0], "\u603B\u8BA1".concat(utils.formatLength(mouseDistance.allDistance), "\n(+").concat(utils.formatLength(mouseDistance.distance), ")"));
+      return mouseDistance;
+    }
+
+    // 点位修改
+  }, {
+    key: "pointsChange",
+    value: function pointsChange(layer, positions) {
+      if (!this._canOperate()) return;
+      // 未返回点位 销毁随鼠标移动的label
+      if (!positions.length) {
+        this._destroyMouseMoveLabel();
+        return [];
+      }
+      // 小于两个点时清除测量缓存数据
+      if (positions.length < 2) {
+        this._measureCache = [];
+      } else {
+        this._calculateDistance(positions);
+      }
+      if (!this._measureCache.length) {
+        layer.dragPoints[0].labelLayer.setStyle({
+          show: true,
+          text: '起点'
+        });
+      } else {
+        this._createMeasureCacheText(layer.dragPoints);
+      }
+      return this._measureCache;
+    }
+
+    // 结束绘制
+  }, {
+    key: "drawEnd",
+    value: function drawEnd() {
+      if (!this._canOperate()) return;
+      this._measureContext._changeStatus(STATUS.END_DRAW);
+      this._measureContext.setDrawerLayer(this.id, this);
+      this._destroyMouseMoveLabel();
+      this.startEdit();
+      return this._measureCache;
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      if (!this._canOperate()) return;
+      this._measureContext._changeStatus(STATUS.EDITING);
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit() {
+      if (!this._canOperate()) return;
+      return this._measureCache;
+    }
+
+    // 绘制随鼠标移动的label
+  }, {
+    key: "_createMouseMoveLabel",
+    value: function _createMouseMoveLabel(position, text) {
+      if (!this._canOperate()) return;
+      if (this._mouseLabelLayer) {
+        this._mouseLabelLayer.setData(point(position));
+        this._mouseLabelLayer.setStyle({
+          text: text,
+          eyeOffset: [-20, 0, 0],
+          horizontalOrigin: Cesium.HorizontalOrigin.RIGHT
+        });
+      } else {
+        this._mouseLabelLayer = this.createLabelLayer(position, text, {
+          eyeOffset: [-20, 0, 0],
+          horizontalOrigin: Cesium.HorizontalOrigin.RIGHT
+        });
+      }
+    }
+
+    // 销毁随鼠标移动的label
+  }, {
+    key: "_destroyMouseMoveLabel",
+    value: function _destroyMouseMoveLabel() {
+      this._mouseLabelLayer && this._mouseLabelLayer.destroy();
+      this._mouseLabelLayer = null;
+    }
+
+    // 计算距离
+  }, {
+    key: "_calculateDistance",
+    value: function _calculateDistance(positions) {
+      if (!this._canOperate()) return;
+      if (positions.length < 2) return;
+      var distanceList = [];
+      this._measureCache = [];
+      var config = _objectSpread(_objectSpread({}, this._measureContext.options), this._config);
+      for (var i = 0; i < positions.length - 1; i++) {
+        var start = positions[i];
+        var end = positions[i + 1];
+        var startC3 = lngLatAltToCartesian3(start[0], start[1], start[2]);
+        var endC3 = lngLatAltToCartesian3(end[0], end[1], end[2]);
+        var distance = 0;
+        if (config.clampToGround) {
+          var startC2 = SceneTransforms.worldToWindowCoordinates(this.getMap().scene, startC3);
+          var endC2 = SceneTransforms.worldToWindowCoordinates(this.getMap().scene, endC3);
+          distance = utils.calculateSurfaceDistance(this.getMap(), startC2, endC2, config.splitNum);
+        } else {
+          distance = utils.getDistance(startC3, endC3);
+        }
+        distanceList.push(distance);
+        this._measureCache.push({
+          start: start,
+          end: end,
+          distance: distance,
+          allDistance: distanceList.reduce(function (sum, distance) {
+            return sum + distance;
+          }, 0)
+        });
+      }
+    }
+
+    // 计算鼠标和线之间的距离
+  }, {
+    key: "_calculateMouseDistance",
+    value: function _calculateMouseDistance(positions) {
+      if (!this._canOperate()) return;
+      if (positions.length < 2) return;
+      var start = positions.slice(-2, -1)[0];
+      var end = positions.slice(-1)[0];
+      var startC3 = lngLatAltToCartesian3(start[0], start[1], start[2]);
+      var endC3 = lngLatAltToCartesian3(end[0], end[1], end[2]);
+      var distance = 0;
+      var config = _objectSpread(_objectSpread({}, this._measureContext.options), this._config);
+      if (config.clampToGround) {
+        var startC2 = SceneTransforms.worldToWindowCoordinates(this.getMap().scene, startC3);
+        var endC2 = SceneTransforms.worldToWindowCoordinates(this.getMap().scene, endC3);
+        distance = utils.calculateSurfaceDistance(this.getMap(), startC2, endC2, config.splitNum);
+      } else {
+        distance = utils.getDistance(startC3, endC3);
+      }
+      return {
+        distance: distance,
+        allDistance: this._measureCache.reduce(function (sum, item) {
+          return sum + item.distance;
+        }, distance)
+      };
+    }
+
+    // 根据缓存数据创建文字
+  }, {
+    key: "_createMeasureCacheText",
+    value: function _createMeasureCacheText(dragPoints) {
+      if (!this._canOperate()) return;
+      for (var i = 0; i < this._measureCache.length; i++) {
+        var _this$_measureCache$i = this._measureCache[i],
+          distance = _this$_measureCache$i.distance,
+          allDistance = _this$_measureCache$i.allDistance;
+        dragPoints[i + 1].labelLayer.setStyle({
+          show: true,
+          text: "".concat(utils.formatLength(allDistance), "\n(+").concat(utils.formatLength(distance), ")")
+        });
+      }
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      _get(_getPrototypeOf(Distance.prototype), "destroy", this).call(this);
+      this._drawer.removeDrawerLayer(this._instance);
+      this._instance = null;
+      this._mouseLabelLayer && this._mouseLabelLayer.remove();
+      this._mouseLabelLayer = null;
+      this._measureCache = [];
+      this._destroyMouseMoveLabel();
+    }
+  }]);
+  return Distance;
+}(BaseDraw);
+export default Distance;

package/dist/esm/measure/index.d.ts

@@ -1,5 +1,44 @@
-export { default as AreaMeasure } from './AreaMeasure';
-export { default as AreaSurfaceMeasure } from './AreaSurfaceMeasure';
-export { default as DistanceMeasure } from './DistanceMeasure';
-export { default as DistanceSurfaceMeasure } from './DistanceSurfaceMeasure';
-export { default as Measure } from './Measure';
+import Drawer from '../drawer';
+export interface MeasureContext {
+    options: any;
+    getMap: any;
+    drawer: any;
+    setDrawerLayer: any;
+    _changeStatus: any;
+}
+export declare const STATUS: {
+    readonly INIT: "INIT";
+    readonly START_DRAW: "START_DRAW";
+    readonly DRAWING: "DRAWING";
+    readonly END_DRAW: "END_DRAW";
+    readonly EDITING: "EDITING";
+    readonly END_EDIT: "END_EDIT";
+};
+export type Status = (typeof STATUS)[keyof typeof STATUS];
+declare class Measure implements MeasureContext {
+    private readonly _mapContext;
+    private readonly _measureContext;
+    options: any;
+    isDestroyed: boolean;
+    private _status;
+    drawer: Drawer;
+    private _instance;
+    private _measureDrawLayers;
+    constructor(map: any, options?: any);
+    private _canOperate;
+    getMap(): any;
+    _changeStatus(status: any): void;
+    startDraw(type: any, config?: any): any;
+    private _stopDraw;
+    endDraw(): void;
+    startEdit(id: any): void;
+    endEdit(): void;
+    getDrawerLayer(id: any): any;
+    setDrawerLayer(id: any, value: any): void;
+    removeDrawerLayer(id: any): void;
+    getAllDrawerLayers(): unknown[] | undefined;
+    clearAllDrawerLayers(): void;
+    clear(): void;
+    destroy(): void;
+}
+export default Measure;

package/dist/esm/measure/index.js

@@ -1,5 +1,278 @@
-export { default as AreaMeasure } from "./AreaMeasure";
-export { default as AreaSurfaceMeasure } from "./AreaSurfaceMeasure";
-export { default as DistanceMeasure } from "./DistanceMeasure";
-export { default as DistanceSurfaceMeasure } from "./DistanceSurfaceMeasure";
-export { default as Measure } from "./Measure";
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+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 { isString, merge } from 'lodash';
+import { DEFAULT_MEASURE_STYLE } from "../constant";
+import Drawer from "../drawer";
+import { error } from "../tool/utils";
+import Area from "./Area";
+import Distance from "./Distance";
+var MEASURE_TYPE = {
+  DISTANCE: 'distance',
+  AREA: 'area'
+};
+
+// 状态表定义
+export var STATUS = {
+  INIT: 'INIT',
+  START_DRAW: 'START_DRAW',
+  DRAWING: 'DRAWING',
+  END_DRAW: 'END_DRAW',
+  EDITING: 'EDITING',
+  END_EDIT: 'END_EDIT'
+};
+
+// 从状态表推导类型
+var Measure = /*#__PURE__*/function () {
+  function Measure(map) {
+    var _this = this;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Measure);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "_measureContext", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "_status", STATUS.INIT);
+    _defineProperty(this, "drawer", void 0);
+    // 绘制的实例
+    _defineProperty(this, "_instance", void 0);
+    // 绘制完成的图层
+    _defineProperty(this, "_measureDrawLayers", new Map());
+    this._mapContext = map._mapContext;
+    this.options = merge(DEFAULT_MEASURE_STYLE(), options);
+    this.drawer = new Drawer(this.getMap(), {
+      onMouseMoveChange: function onMouseMoveChange(e) {
+        if (_this._instance) {
+          _this._instance.drawing(e.positions);
+        }
+      },
+      onPointsChange: function onPointsChange(e) {
+        if (_this._instance) {
+          var data = _this._instance.pointsChange(e.layer, e.positions);
+          _this.options.onPointsChange && _this.options.onPointsChange({
+            layer: _this._instance,
+            positions: e.positions,
+            measure: data
+          });
+        }
+      },
+      onComplete: function onComplete(e) {
+        if (_this._instance) {
+          var data = {};
+          if (_this._status === 'END_DRAW' || _this._status === 'DRAWING') {
+            data = _this._instance.drawEnd(e.positions);
+            _this.options.onComplete && _this.options.onComplete({
+              layer: _this._instance,
+              positions: e.positions,
+              measure: data
+            });
+          }
+          if (_this._status === 'END_EDIT') {
+            data = _this._instance.endEdit(e.positions);
+            _this.options.onComplete && _this.options.onComplete({
+              layer: _this._instance,
+              positions: e.positions,
+              measure: data
+            });
+          }
+        }
+      }
+    });
+    this._measureContext = {
+      options: this.options,
+      getMap: this.getMap.bind(this),
+      drawer: this.drawer,
+      setDrawerLayer: this.setDrawerLayer.bind(this),
+      _changeStatus: this._changeStatus.bind(this)
+    };
+  }
+
+  // 是否能进行操作
+  _createClass(Measure, [{
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        error('Drawer实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+
+    // 修改状态
+  }, {
+    key: "_changeStatus",
+    value: function _changeStatus(status) {
+      this._status = status;
+    }
+
+    // 开始绘制
+  }, {
+    key: "startDraw",
+    value: function startDraw(type) {
+      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this._canOperate()) return;
+      if (!Object.values(MEASURE_TYPE).includes(type)) return;
+      if (this._instance) {
+        this._stopDraw();
+      }
+      this._changeStatus(STATUS.START_DRAW);
+      if (type === MEASURE_TYPE.DISTANCE) {
+        this._instance = new Distance(this._measureContext, config);
+      }
+      if (type === MEASURE_TYPE.AREA) {
+        this._instance = new Area(this._measureContext, config);
+      }
+      return this._instance;
+    }
+
+    // 中止当前绘制
+  }, {
+    key: "_stopDraw",
+    value: function _stopDraw() {
+      if (!this._canOperate()) return;
+      if (!this._instance) return;
+      if (this._status === STATUS.INIT || this._status === STATUS.START_DRAW || this._status === STATUS.END_EDIT) {
+        var layer = this.getDrawerLayer(this._instance);
+        // layer未存入
+        if (!layer) {
+          this._instance.destroy();
+        }
+        this._instance = null;
+        return;
+      }
+      if (this._status === STATUS.DRAWING) {
+        this.removeDrawerLayer(this._instance);
+        this._instance = null;
+        return;
+      }
+      if (this._status === STATUS.END_DRAW || this._status === STATUS.EDITING) {
+        this.endEdit();
+        return;
+      }
+    }
+
+    // 结束绘制
+  }, {
+    key: "endDraw",
+    value: function endDraw() {
+      if (!this._canOperate()) return;
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit(id) {
+      if (!this._canOperate()) return;
+      if (!id) return;
+      if (this._instance) {
+        this.drawer.endEdit();
+        this.setDrawerLayer(this._instance.id, this._instance);
+        this._instance = null;
+      }
+      this._changeStatus(STATUS.EDITING);
+      this._instance = this.getDrawerLayer(id);
+      if (!this._instance) return;
+      this._changeStatus(STATUS.EDITING);
+      this.drawer.startEdit(this._instance._instance);
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit() {
+      if (!this._canOperate()) return;
+      this._changeStatus(STATUS.END_EDIT);
+      if (!this._instance) return;
+      this.drawer.endEdit();
+      this.setDrawerLayer(this._instance.id, this._instance);
+      this._instance = null;
+    }
+
+    // 获取绘制的图层
+  }, {
+    key: "getDrawerLayer",
+    value: function getDrawerLayer(id) {
+      if (!this._canOperate) return;
+      if (!id) return;
+      return isString(id) ? this._measureDrawLayers.get(id) : id;
+    }
+
+    // 添加完成绘制的图层
+  }, {
+    key: "setDrawerLayer",
+    value: function setDrawerLayer(id, value) {
+      if (!this._instance) return;
+      this._measureDrawLayers.set(id, value);
+    }
+
+    // 移除绘制的图层
+  }, {
+    key: "removeDrawerLayer",
+    value: function removeDrawerLayer(id) {
+      if (!this._canOperate) return;
+      var layer = this.getDrawerLayer(id);
+      if (layer) {
+        var _this$_instance;
+        if (layer.id === (this === null || this === void 0 || (_this$_instance = this._instance) === null || _this$_instance === void 0 ? void 0 : _this$_instance.id)) {
+          this._instance = null;
+          this._status = STATUS.INIT;
+        }
+        this._measureDrawLayers.delete(layer.id);
+        layer.destroy();
+        layer = null;
+      }
+    }
+
+    // 获取所有绘制的图层
+  }, {
+    key: "getAllDrawerLayers",
+    value: function getAllDrawerLayers() {
+      if (!this._canOperate) return;
+      return Array.from(this._measureDrawLayers.values());
+    }
+
+    // 清除所有绘制的图层
+  }, {
+    key: "clearAllDrawerLayers",
+    value: function clearAllDrawerLayers() {
+      if (!this._canOperate) return;
+      this._measureDrawLayers.forEach(function (t) {
+        return t.destroy();
+      });
+      this._measureDrawLayers.clear();
+    }
+
+    // 清除
+  }, {
+    key: "clear",
+    value: function clear() {
+      if (!this._canOperate) return;
+      this.getMap().canvas.style.cursor = 'default';
+      this._changeStatus(STATUS.INIT);
+      this._instance && this._instance.destroy();
+      this._instance = null;
+      this.clearAllDrawerLayers();
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate) return;
+      this.clear();
+      this.drawer.destroy();
+      this.isDestroyed = true;
+    }
+  }]);
+  return Measure;
+}();
+export default Measure;