deeptwins-engine-3d 0.1.32 → 0.1.34

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

@@ -0,0 +1,33 @@
+import { DrawContext } from '../index';
+import { DragPoint } from './Point';
+declare class BaseShape {
+    _drawContext: DrawContext;
+    id: string;
+    positions: any;
+    clampToGround: boolean;
+    pointStyle: any;
+    polylineStyle: any;
+    polygonStyle: any;
+    isDestroyed: boolean;
+    isEditing: boolean;
+    dragging: boolean;
+    dragLayer: any;
+    dragPoints: any[];
+    edges: any[];
+    constructor(drawContext: any);
+    getMap(): any;
+    private _canOperate;
+    drawing(layer: any): void;
+    drawEnd(layer: any): void;
+    startEdit(): void;
+    endEdit(layer: any): void;
+    destroy(): void;
+    _createEdgesAndMiddle(dragPoints: any[], isPolygon?: boolean): {
+        source: any;
+        target: any;
+        middlePoint: DragPoint;
+    }[];
+    _createTwoPointMiddle(position: any): DragPoint;
+    _updatePositionsFromEdges(): any[][] | undefined;
+}
+export default BaseShape;

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

@@ -0,0 +1,228 @@
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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 { cloneDeep } from 'lodash';
+import { v4 as uuidV4 } from 'uuid';
+import * as utils from "../../tool/utils";
+import { STATUS } from "../index";
+import { DragPoint } from "./Point";
+var BaseShape = /*#__PURE__*/function () {
+  function BaseShape(drawContext) {
+    _classCallCheck(this, BaseShape);
+    _defineProperty(this, "_drawContext", void 0);
+    _defineProperty(this, "id", void 0);
+    // 位置
+    _defineProperty(this, "positions", []);
+    // 是否贴地
+    _defineProperty(this, "clampToGround", false);
+    _defineProperty(this, "pointStyle", void 0);
+    _defineProperty(this, "polylineStyle", void 0);
+    _defineProperty(this, "polygonStyle", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    // 是否编辑
+    _defineProperty(this, "isEditing", false);
+    // 是否拖拽中
+    _defineProperty(this, "dragging", false);
+    // 拖拽中的点
+    _defineProperty(this, "dragLayer", void 0);
+    // 可拖动点位
+    _defineProperty(this, "dragPoints", []);
+    // 可拖动点位的映射关系
+    _defineProperty(this, "edges", []);
+    this.id = uuidV4();
+    this._drawContext = drawContext;
+    var clampToGround = drawContext.options.clampToGround;
+    this.clampToGround = clampToGround;
+    var _drawContext$options = drawContext.options,
+      pointStyle = _drawContext$options.pointStyle,
+      polylineStyle = _drawContext$options.polylineStyle,
+      polygonStyle = _drawContext$options.polygonStyle;
+    this.pointStyle = cloneDeep(pointStyle);
+    this.polylineStyle = cloneDeep(polylineStyle);
+    this.polygonStyle = cloneDeep(polygonStyle);
+  }
+  _createClass(BaseShape, [{
+    key: "getMap",
+    value: function getMap() {
+      return this._drawContext && this._drawContext.getMap();
+    }
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('DrawerShape实例已销毁');
+        return false;
+      }
+      return true;
+    }
+
+    // 绘制中
+  }, {
+    key: "drawing",
+    value: function drawing(layer) {
+      var _this$_drawContext$op, _this$_drawContext$op2;
+      if (!this._canOperate()) return;
+      // 调用点位改变事件
+      ((_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: layer,
+        positions: this.positions
+      }));
+      this._drawContext._changeStatus(STATUS.DRAWING);
+      this._drawContext._updateTooltip();
+    }
+
+    // 绘制结束
+  }, {
+    key: "drawEnd",
+    value: function drawEnd(layer) {
+      var _this$_drawContext$op3;
+      if (!this._canOperate()) return;
+      // 调用绘制完成事件
+      ((_this$_drawContext$op3 = this._drawContext.options) === null || _this$_drawContext$op3 === void 0 ? void 0 : _this$_drawContext$op3.onComplete) && this._drawContext.options.onComplete({
+        layer: layer,
+        positions: this.positions
+      });
+      this._drawContext._changeStatus(STATUS.END_DRAW);
+      this._drawContext._updateTooltip();
+      this.getMap().canvas.style.cursor = 'default';
+    }
+
+    // 开始编辑
+  }, {
+    key: "startEdit",
+    value: function startEdit() {
+      if (!this._canOperate()) return;
+      this.isEditing = true;
+      this._drawContext._changeStatus(STATUS.EDITING);
+    }
+
+    // 结束编辑
+  }, {
+    key: "endEdit",
+    value: function endEdit(layer) {
+      var _this$_drawContext$op4;
+      if (!this._canOperate()) return;
+      this.isEditing = false;
+      // 调用绘制完成事件
+      ((_this$_drawContext$op4 = this._drawContext.options) === null || _this$_drawContext$op4 === void 0 ? void 0 : _this$_drawContext$op4.onComplete) && this._drawContext.options.onComplete({
+        layer: layer,
+        positions: this.positions
+      });
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      this.positions = [];
+      this.isDestroyed = true;
+      this.dragPoints.forEach(function (t) {
+        return t.destroy();
+      });
+      this.dragPoints = [];
+      this.edges.forEach(function (t) {
+        return t.middlePoint.destroy();
+      });
+      this.edges = [];
+    }
+
+    // 根据可拖拽点位创建两个点位中间点和映射关系
+  }, {
+    key: "_createEdgesAndMiddle",
+    value: function _createEdgesAndMiddle(dragPoints, isPolygon) {
+      var edges = [];
+      for (var i = 0; i < dragPoints.length; i++) {
+        var item = dragPoints[i];
+        var itemNext = isPolygon ? dragPoints[i + 1] || dragPoints[0] : dragPoints[i + 1];
+        item.startEdit();
+        item.show(true);
+        if (itemNext) {
+          var p1 = item.layer.layers[0].source.positions;
+          var p2 = itemNext.layer.layers[0].source.positions;
+          var layer = this._createTwoPointMiddle(utils.getMidpoint(p1, p2));
+          layer.startEdit();
+          // 创建映射关系
+          edges.push({
+            source: item,
+            target: itemNext,
+            middlePoint: layer
+          });
+        }
+      }
+      return edges;
+    }
+
+    // 创建两点间的可拖动点位
+  }, {
+    key: "_createTwoPointMiddle",
+    value: function _createTwoPointMiddle(position) {
+      var lng = position.lng,
+        lat = position.lat,
+        alt = position.alt;
+      return new DragPoint(this.getMap(), {
+        positions: [lng, lat, alt],
+        style: _objectSpread(_objectSpread({}, this.pointStyle), {}, {
+          heightReference: this.clampToGround ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE
+        }),
+        isMiddlePoint: true
+      });
+    }
+
+    // 根据edges生成最新的positions数组
+  }, {
+    key: "_updatePositionsFromEdges",
+    value: function _updatePositionsFromEdges() {
+      var positions = [];
+      var visitedIds = new Set();
+
+      // 找到起点（isStart为true的点）
+      var startPoint = this.dragPoints.find(function (point) {
+        return point.isStart;
+      });
+      if (!startPoint) {
+        return;
+      }
+
+      // 从起点开始，按source->target的顺序构建positions数组
+      var currentPoint = startPoint;
+      while (currentPoint && !visitedIds.has(currentPoint.id)) {
+        // 添加当前点
+        var _currentPoint$_geoJso = _slicedToArray(currentPoint._geoJson.geometry.coordinates, 3),
+          lng = _currentPoint$_geoJso[0],
+          lat = _currentPoint$_geoJso[1],
+          alt = _currentPoint$_geoJso[2];
+        positions.push([lng, lat, alt]);
+        visitedIds.add(currentPoint.id);
+
+        // 查找以当前点为source的边
+        var currentEdge = this.edges.find(function (edge) {
+          var _edge$source;
+          return ((_edge$source = edge.source) === null || _edge$source === void 0 ? void 0 : _edge$source.id) === currentPoint.id;
+        });
+
+        // 移动到下一个点（target）
+        if (currentEdge && currentEdge.target && !visitedIds.has(currentEdge.target.id)) {
+          currentPoint = currentEdge.target;
+        } else {
+          break;
+        }
+      }
+      return positions;
+    }
+  }]);
+  return BaseShape;
+}();
+export default BaseShape;

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

@@ -1,12 +1,45 @@
-import { Entity } from 'deeptwins-cesium';
-import BasicGraphics from '../base';
-import type { Cartesian3 } from 'deeptwins-cesium';
-import type { EventArgs } from '../../tool/cesiumExtends/Subscriber';
-import type { LifeCycle } from '../base';
-export default class Point extends BasicGraphics implements LifeCycle {
-    dropPoint(event: EventArgs): void;
-    moving(): void;
-    playOff(): Entity;
-    cancel(): void;
-    createDynamicShape(position: Cartesian3): Entity;
+import BaseShape from './BaseShape';
+export declare class DragPoint {
+    private readonly _mapContext;
+    id: string;
+    layer: any;
+    isEditing: boolean;
+    isMiddlePoint: boolean;
+    isDestroyed: boolean;
+    labelLayer: any;
+    private _geoJson;
+    private _style;
+    /**
+     * 构造函数，用于创建一个地图元素实例
+     * @param map 地图对象，包含地图上下文信息
+     * @param options 配置选项对象
+     * @param options.positions 点的坐标位置数组
+     * @param options.style 样式配置
+     * @param options.isMiddlePoint 是否为中间点的标识，默认为false
+     */
+    constructor(map: any, { positions, style, isMiddlePoint }: any);
+    getMap(): any;
+    private _canOperate;
+    private _create;
+    private _createLabel;
+    startEdit(): void;
+    mouseDragStart(): void;
+    mouseDragChange(position: any): void;
+    endEdit(): void;
+    show(isShow: boolean): void;
+    destroy(): void;
 }
+declare class Point extends BaseShape {
+    readonly type: string;
+    shapePointLayer: any;
+    constructor(drawContext: any, config: any);
+    transformData(positions: any[]): void;
+    addPoint(position: any): void;
+    startEdit(): void;
+    mouseDragStart(position: any, dragLayer: any): void;
+    mouseDragChange(position: any): void;
+    mouseDragEnd(): void;
+    endEdit(layer: any): void;
+    destroy(): void;
+}
+export default Point;