deeptwins-engine-3d 0.1.32 → 0.1.34

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

@@ -1,9 +1,6 @@
 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 _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); }; }
@@ -11,49 +8,316 @@ 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 { defined, Entity } from 'deeptwins-cesium';
-import BasicGraphics from "../base";
-var Point = /*#__PURE__*/function (_BasicGraphics) {
-  _inherits(Point, _BasicGraphics);
+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 _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 BaseShape from "./BaseShape";
+
+// 拖动点样式
+var DRAG_POINT_STYLE = {
+  pixelSize: 10,
+  color: '#ffffff',
+  outline: true,
+  outlineColor: '#1890FF',
+  outlineWidth: 2
+};
+
+// 临时拖动点样式
+var TEMP_DRAG_POINT_STYLE = {
+  pixelSize: 10,
+  color: '#1890FF',
+  outline: true,
+  outlineColor: '#ffffff',
+  outlineWidth: 2
+};
+
+// 创建可拖动的点
+export var DragPoint = /*#__PURE__*/function () {
+  /**
+   * 构造函数，用于创建一个地图元素实例
+   * @param map 地图对象，包含地图上下文信息
+   * @param options 配置选项对象
+   * @param options.positions 点的坐标位置数组
+   * @param options.style 样式配置
+   * @param options.isMiddlePoint 是否为中间点的标识，默认为false
+   */
+  function DragPoint(map, _ref) {
+    var positions = _ref.positions,
+      style = _ref.style,
+      _ref$isMiddlePoint = _ref.isMiddlePoint,
+      isMiddlePoint = _ref$isMiddlePoint === void 0 ? false : _ref$isMiddlePoint;
+    _classCallCheck(this, DragPoint);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "id", '');
+    _defineProperty(this, "layer", void 0);
+    // 是否编辑中
+    _defineProperty(this, "isEditing", false);
+    // 是否是中间点
+    _defineProperty(this, "isMiddlePoint", false);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "labelLayer", void 0);
+    _defineProperty(this, "_geoJson", void 0);
+    _defineProperty(this, "_style", void 0);
+    this._mapContext = map._mapContext;
+    this.id = uuidV4();
+    this.isMiddlePoint = isMiddlePoint;
+    this._geoJson = {
+      type: 'Feature',
+      geometry: {
+        type: 'Point',
+        coordinates: positions
+      }
+    };
+    this._style = style;
+    this._create();
+  }
+  _createClass(DragPoint, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('DragPoint实例已销毁');
+        return false;
+      }
+      return true;
+    }
+
+    // 创建
+  }, {
+    key: "_create",
+    value: function _create() {
+      if (!this._canOperate()) return;
+      this.layer = this.getMap().addGraphicLayer(this._geoJson, {
+        type: 'point',
+        id: this.id,
+        style: _objectSpread(_objectSpread({}, this._style), {}, {
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        }),
+        positionProperty: new PositionProperty()
+      });
+      if (!this.isMiddlePoint) {
+        this._createLabel();
+      }
+    }
+
+    // 创建label
+  }, {
+    key: "_createLabel",
+    value: function _createLabel() {
+      this.labelLayer = this.getMap().addGraphicLayer(this._geoJson, {
+        type: 'label',
+        style: {
+          text: '',
+          font: 'bold 16px Arial',
+          style: Cesium.LabelStyle.FILL_AND_OUTLINE,
+          outlineWidth: 4,
+          eyeOffset: [-20, 0, 0],
+          horizontalOrigin: Cesium.HorizontalOrigin.RIGHT,
+          heightReference: Cesium.HeightReference.NONE,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY,
+          show: false
+        },
+        positionProperty: new PositionProperty()
+      });
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      if (!this._canOperate()) return;
+      this.isEditing = true;
+      this.layer && this.layer.setStyle(this.isMiddlePoint ? TEMP_DRAG_POINT_STYLE : DRAG_POINT_STYLE);
+    }
+
+    // 开始鼠标拖拽
+  }, {
+    key: "mouseDragStart",
+    value: function mouseDragStart() {
+      if (this.isMiddlePoint) {
+        this.isMiddlePoint = false;
+        this.layer && this.layer.setStyle(DRAG_POINT_STYLE);
+        this._createLabel();
+      }
+    }
+
+    // 鼠标拖拽
+  }, {
+    key: "mouseDragChange",
+    value: function mouseDragChange(position) {
+      if (!this._canOperate()) return;
+      if (this.layer && position) {
+        var lng = position.lng,
+          lat = position.lat,
+          alt = position.alt;
+        this._geoJson.geometry.coordinates = [lng, lat, alt];
+        this.layer.setData(this._geoJson);
+        this.labelLayer && this.labelLayer.setData(this._geoJson);
+      }
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit() {
+      if (!this._canOperate()) return;
+      if (this.layer) {
+        this.isEditing = false;
+        this.layer.setStyle(this._style);
+      }
+    }
+
+    // 隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      if (!this._canOperate()) return;
+      this.layer && this.layer.show(isShow);
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      this.isDestroyed = true;
+      this.layer && this.layer.remove();
+      this.layer = null;
+      this.labelLayer && this.labelLayer.remove();
+      this.labelLayer = null;
+    }
+  }]);
+  return DragPoint;
+}();
+var Point = /*#__PURE__*/function (_BaseShape) {
+  _inherits(Point, _BaseShape);
   var _super = _createSuper(Point);
-  function Point() {
+  function Point(drawContext, config) {
+    var _this;
     _classCallCheck(this, Point);
-    return _super.apply(this, arguments);
+    _this = _super.call(this, drawContext);
+    _defineProperty(_assertThisInitialized(_this), "type", 'point');
+    _defineProperty(_assertThisInitialized(_this), "shapePointLayer", void 0);
+    _this.clampToGround = isNil(config === null || config === void 0 ? void 0 : config.clampToGround) ? _this.clampToGround : config.clampToGround;
+    _this.pointStyle.heightReference = _this.clampToGround ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE;
+    return _this;
   }
+
+  // 数据转换
   _createClass(Point, [{
-    key: "dropPoint",
-    value: function dropPoint(event) {
-      if (!event.position) return;
-      var earthPosition = this.painter.pickCartesian3(event.position);
-      if (earthPosition && defined(earthPosition)) this.result = this.createDynamicShape(earthPosition);
+    key: "transformData",
+    value: function transformData(positions) {
+      this.positions = positions;
+      this.shapePointLayer = new DragPoint(this.getMap(), {
+        positions: this.positions,
+        style: this.pointStyle
+      });
+      this.shapePointLayer.endEdit();
+      this.dragPoints = [this.shapePointLayer];
+      // 存入
+      this._drawContext.setDrawerLayer(this.id, this);
+    }
+
+    // 添加点位
+  }, {
+    key: "addPoint",
+    value: function addPoint(position) {
+      var lng = position.lng,
+        lat = position.lat,
+        alt = position.alt;
+      this.positions = [lng, lat, alt];
+      this.shapePointLayer = new DragPoint(this.getMap(), {
+        positions: this.positions,
+        style: this.pointStyle
+      });
+      this.dragPoints = [this.shapePointLayer];
+      // 存入
+      this._drawContext.setDrawerLayer(this.id, this);
+      this.drawing(this);
+      this.drawEnd(this);
+      this.startEdit();
     }
+
+    // 开始编辑
   }, {
-    key: "moving",
-    value: function moving() {
-      return undefined;
+    key: "startEdit",
+    value: function startEdit() {
+      _get(_getPrototypeOf(Point.prototype), "startEdit", this).call(this);
+      this.dragPoints[0] && this.dragPoints[0].startEdit();
     }
+
+    // 开始鼠标拖拽
   }, {
-    key: "playOff",
-    value: function playOff() {
-      this.painter.reset();
-      return this.result;
+    key: "mouseDragStart",
+    value: function mouseDragStart(position, dragLayer) {
+      this.dragging = true;
+      this.dragLayer = dragLayer;
     }
+
+    // 鼠标拖拽
   }, {
-    key: "cancel",
-    value: function cancel() {
-      this.painter.reset();
-      return undefined;
+    key: "mouseDragChange",
+    value: function mouseDragChange(position) {
+      if (this.dragging) {
+        var _this$_drawContext$op, _this$_drawContext$op2;
+        // 调用点位改变事件
+        ((_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
+        }));
+        this.dragLayer.mouseDragChange(position);
+      }
     }
+
+    // 结束鼠标拖拽
   }, {
-    key: "createDynamicShape",
-    value: function createDynamicShape(position) {
-      var point = Object.assign({}, this.finalOptions);
-      return new Entity({
-        position: position,
-        point: point
+    key: "mouseDragEnd",
+    value: function mouseDragEnd() {
+      this.dragging = false;
+      this.dragLayer = null;
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit(layer) {
+      _get(_getPrototypeOf(Point.prototype), "endEdit", this).call(this, layer);
+      this.dragPoints[0] && this.dragPoints[0].endEdit();
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      _get(_getPrototypeOf(Point.prototype), "destroy", this).call(this);
+      this.dragPoints.forEach(function (t) {
+        return t.destroy();
+      });
+      this.dragPoints = [];
+      this.edges.forEach(function (t) {
+        return t.middlePoint.destroy();
       });
+      this.edges = [];
+      this.shapePointLayer && this.shapePointLayer.destroy();
+      this.shapePointLayer = null;
     }
   }]);
   return Point;
-}(BasicGraphics);
-export { Point as default };
+}(BaseShape);
+export default Point;

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

@@ -1,10 +1,44 @@
-import { CallbackProperty, Entity } from 'deeptwins-cesium';
-import BasicGraphics from '../base';
-import type { Cartesian3 } from 'deeptwins-cesium';
-import type { LifeCycle } from '../base';
-export default class Polygon extends BasicGraphics implements LifeCycle {
-    dropPoint(event: any): void;
-    playOff(): Entity;
-    cancel(): void;
-    createShape(hierarchy: Cartesian3[] | CallbackProperty, isDynamic?: boolean): Entity;
+import BaseShape from './BaseShape';
+export declare class ShapePolygon {
+    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 Polygon extends BaseShape {
+    readonly type: string;
+    shapePolylineLayer: any;
+    shapePolygonLayer: any;
+    private _tempPosition;
+    constructor(drawContext: any, config: any);
+    transformData(positions: any[]): void;
+    private _getDrawPolylinePositions;
+    private _getDrawPolygonPositions;
+    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 Polygon;