deeptwins-engine-3d 0.0.42

package/dist/measure/DistanceSurfaceMeasure.js

@@ -0,0 +1,122 @@
+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 _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 { Cartesian2, Cartographic, EllipsoidGeodesic, SceneTransforms } from 'deeptwins-cesium';
+import DistanceMeasure from "./DistanceMeasure";
+import { pickCartesian3 } from "./utils";
+/**
+ * 贴地距离测量类
+ */
+var DistanceSurfaceMeasure = /*#__PURE__*/function (_DistanceMeasure) {
+  _inherits(DistanceSurfaceMeasure, _DistanceMeasure);
+  var _super = _createSuper(DistanceSurfaceMeasure);
+  function DistanceSurfaceMeasure(viewer) {
+    var _options$splitNum;
+    var _this;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, DistanceSurfaceMeasure);
+    _this = _super.call(this, viewer, options);
+    _defineProperty(_assertThisInitialized(_this), "_splitNum", void 0);
+    _this._splitNum = (_options$splitNum = options.splitNum) !== null && _options$splitNum !== void 0 ? _options$splitNum : 50;
+    return _this;
+  }
+  /**
+   * 计算线段的表面距离
+   * @param startPoint  -线段起点的屏幕坐标
+   * @param endPoint    -线段终点的屏幕坐标
+   * @returns 表面距离
+   */
+  _createClass(DistanceSurfaceMeasure, [{
+    key: "_calculateSurfaceDistance",
+    value: function _calculateSurfaceDistance(startPoint, endPoint) {
+      var resultDistance = 0;
+      var sampleWindowPoints = [startPoint];
+      var interval = Math.sqrt(Math.pow(endPoint.x - startPoint.x, 2) + (endPoint.y - startPoint.y, 2)) / this._splitNum;
+      for (var ii = 1; ii <= this._splitNum; ii += 1) {
+        var tempPositon = this._findWindowPositionByPixelInterval(startPoint, endPoint, ii * interval);
+        sampleWindowPoints.push(tempPositon);
+      }
+      sampleWindowPoints.push(endPoint);
+      for (var jj = 0; jj < sampleWindowPoints.length - 1; jj += 1) {
+        resultDistance += this._calculateDetailSurfaceLength(sampleWindowPoints[jj + 1], sampleWindowPoints[jj]);
+      }
+      return resultDistance;
+    }
+
+    /**
+     * 计算细分后的，每一小段的笛卡尔坐标距离（也就是大地坐标系距离）
+     * @param startPoint -每一段线段起点
+     * @param endPoint -每一段线段终点
+     * @returns 表面距离
+     */
+  }, {
+    key: "_calculateDetailSurfaceLength",
+    value: function _calculateDetailSurfaceLength(startPoint, endPoint) {
+      var innerS = 0;
+      var surfaceStartCartesian3 = pickCartesian3(this._viewer, startPoint);
+      var surfaceEndCartesian3 = pickCartesian3(this._viewer, endPoint);
+      if (surfaceStartCartesian3 && surfaceEndCartesian3) {
+        var cartographicStart = Cartographic.fromCartesian(surfaceStartCartesian3);
+        var cartographicEnd = Cartographic.fromCartesian(surfaceEndCartesian3);
+        var geoD = new EllipsoidGeodesic();
+        geoD.setEndPoints(cartographicStart, cartographicEnd);
+        innerS = geoD.surfaceDistance;
+        innerS = Math.sqrt(Math.pow(innerS, 2) + Math.pow(cartographicStart.height - cartographicEnd.height, 2));
+      }
+      return innerS;
+    }
+
+    /**
+     * 获取线段上距起点一定距离出的线上点坐标（屏幕坐标）
+     * @param startPosition  -线段起点（屏幕坐标）
+     * @param endPosition -线段终点（屏幕坐标）
+     * @param interval -距起点距离
+     * @returns -结果坐标（屏幕坐标）
+     */
+  }, {
+    key: "_findWindowPositionByPixelInterval",
+    value: function _findWindowPositionByPixelInterval(startPosition, endPosition, interval) {
+      var result = new Cartesian2(0, 0);
+      var length = Math.sqrt(Math.pow(endPosition.x - startPosition.x, 2) + Math.pow(endPosition.y - startPosition.y, 2));
+      if (length < interval) {
+        return result;
+      } else {
+        var x = interval / length * (endPosition.x - startPosition.x) + startPosition.x;
+        //alert(interval/length)
+        var y = interval / length * (endPosition.y - startPosition.y) + startPosition.y;
+        result.x = x;
+        result.y = y;
+      }
+      return result;
+    }
+  }, {
+    key: "getDistance",
+    value: function getDistance(pos1, pos2) {
+      var start = SceneTransforms.worldToWindowCoordinates(this._viewer.scene, pos1);
+      var end = SceneTransforms.worldToWindowCoordinates(this._viewer.scene, pos2);
+      return this._calculateSurfaceDistance(start, end);
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this._start('polyline', {
+        clampToGround: true,
+        style: style
+      });
+    }
+  }]);
+  return DistanceSurfaceMeasure;
+}(DistanceMeasure);
+export default DistanceSurfaceMeasure;

package/dist/measure/Measure.d.ts

@@ -0,0 +1,111 @@
+import { Cartesian2, Color, HeightReference, LabelCollection, LabelStyle, NearFarScalar } from 'deeptwins-cesium';
+import Drawer from '../drawer';
+import ToolTip from '../toolTip/index';
+import type { Units } from '@turf/helpers';
+import type { Cartesian3, Entity, Viewer } from 'deeptwins-cesium';
+import type { DrawOption } from '../drawer';
+export type MeasureUnits = Units;
+export type MeasureLocaleOptions = {
+    start: string;
+    total: string;
+    area: string;
+    /**
+     * 格式化显示长度
+     * @param length 单位米
+     * @param unit 目标单位
+     */
+    formatLength(length: number, unitedLength: number, unit: MeasureUnits): string;
+    /**
+     * 格式化显示面积
+     * @param area 单位米
+     * @param unit 目标单位
+     */
+    formatArea(area: number, unitedArea: number, unit: MeasureUnits): string;
+};
+export type MeasureOptions = {
+    labelStyle?: {
+        font?: string;
+        fillColor?: Color;
+        backgroundColor?: Color;
+        backgroundPadding?: Cartesian2;
+        outlineWidth?: number;
+        style?: LabelStyle;
+        pixelOffset?: Cartesian2;
+        scale?: number;
+        scaleByDistance?: NearFarScalar;
+        heightReference?: HeightReference;
+    };
+    /** defaults to kilometers */
+    units?: MeasureUnits;
+    complete?: (entity: Entity) => void;
+    drawerOptions?: Partial<DrawOption>;
+    /**
+     * @example
+     * {
+          start: '起点',
+          area: '面积',
+          total: '总计',
+          formatLength: (length, unitedLength) => {
+            if (length < 1000) {
+              return length + '米';
+            }
+            return unitedLength + '千米';
+          },
+          formatArea: (area, unitedArea) => {
+            if (area < 1000000) {
+              return area + '平方米';
+            }
+            return unitedArea + '平方千米';
+          }
+        }
+     */
+    locale?: Partial<MeasureLocaleOptions>;
+};
+export type Status = 'INIT' | 'WORKING' | 'DESTROY';
+export default class Measure {
+    protected _viewer: Viewer;
+    protected _status: Status;
+    protected _labels: LabelCollection;
+    protected _labelStyle: MeasureOptions['labelStyle'];
+    protected _units: MeasureUnits;
+    protected _locale: MeasureLocaleOptions;
+    mouseTooltip: ToolTip;
+    drawer: Drawer;
+    private _complete;
+    /**
+     * 量算工具
+     * @param viewer
+     * @param {MeasureOptions['locale']} [options.locale] 绘制时的提示信息
+     */
+    constructor(viewer: Viewer, options?: MeasureOptions);
+    /**
+     * @return {boolean} 返回量算工具是否已销毁
+     */
+    get destroyed(): boolean;
+    /**
+     * 根据传入的坐标信息更新标签
+     * @param {Cartesian3[]} positions
+     */
+    protected _updateLabelFunc(positions: Cartesian3[]): void;
+    protected _cartesian2Lonlat(positions: Cartesian3[]): number[][];
+    start(): void;
+    /**
+     * 开始绘制
+     * @param {string} type 绘制图形类型
+     * @param {boolean} clampToGround 是否贴地
+     */
+    protected _start(type: 'polygon' | 'polyline' | 'point' | 'ellipse' | 'rectangle', options?: {
+        style?: object;
+        clampToGround?: boolean;
+    }): void;
+    getDistances(): {
+        total: any;
+        prev: any;
+    }[];
+    getAreas(): any;
+    /**
+     * 清除测量结果,重置绘制
+     */
+    end(): void;
+    destroy(): void;
+}

package/dist/measure/Measure.js

@@ -0,0 +1,177 @@
+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 _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 { Cartesian2, Math as CMath, Color, HeightReference, LabelCollection, LabelStyle, NearFarScalar } from 'deeptwins-cesium';
+import Drawer from "../drawer";
+import ToolTip from "../toolTip/index";
+import { formatArea, formatLength } from "./utils";
+var DefaultOptions = {
+  labelStyle: {
+    font: "bold 20px Arial",
+    fillColor: Color.WHITE,
+    backgroundColor: new Color(0.165, 0.165, 0.165, 0.8),
+    backgroundPadding: new Cartesian2(4, 4),
+    outlineWidth: 4,
+    style: LabelStyle.FILL_AND_OUTLINE,
+    pixelOffset: new Cartesian2(4, 0),
+    scale: 1,
+    scaleByDistance: new NearFarScalar(1, 0.85, 8.0e6, 0.75),
+    heightReference: HeightReference.CLAMP_TO_GROUND
+  }
+};
+var Measure = /*#__PURE__*/function () {
+  /**
+   * 量算工具
+   * @param viewer
+   * @param {MeasureOptions['locale']} [options.locale] 绘制时的提示信息
+   */
+  function Measure(viewer) {
+    var _options$units;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Measure);
+    _defineProperty(this, "_viewer", void 0);
+    _defineProperty(this, "_status", void 0);
+    _defineProperty(this, "_labels", void 0);
+    _defineProperty(this, "_labelStyle", void 0);
+    _defineProperty(this, "_units", void 0);
+    _defineProperty(this, "_locale", void 0);
+    _defineProperty(this, "mouseTooltip", void 0);
+    _defineProperty(this, "drawer", void 0);
+    _defineProperty(this, "_complete", void 0);
+    if (!viewer) throw new Error('undefined viewer');
+    this._viewer = viewer;
+    this._labelStyle = _objectSpread(_objectSpread({}, DefaultOptions.labelStyle), options.labelStyle);
+    this._units = (_options$units = options.units) !== null && _options$units !== void 0 ? _options$units : 'kilometers';
+    this._complete = options.complete;
+    this._locale = _objectSpread({
+      area: '面积',
+      start: '起点',
+      total: '总计',
+      formatLength: formatLength,
+      formatArea: formatArea
+    }, options.locale);
+    this.mouseTooltip = new ToolTip(viewer);
+    this.mouseTooltip.show(false);
+    this.drawer = new Drawer(viewer, _objectSpread({
+      sameStyle: true,
+      terrain: true
+    }, options.drawerOptions));
+    this._labels = new LabelCollection({
+      scene: this._viewer.scene
+    });
+    this._viewer.scene.primitives.add(this._labels);
+    this._status = 'INIT';
+  }
+
+  /**
+   * @return {boolean} 返回量算工具是否已销毁
+   */
+  _createClass(Measure, [{
+    key: "destroyed",
+    get: function get() {
+      return this._status === 'DESTROY';
+    }
+
+    /**
+     * 根据传入的坐标信息更新标签
+     * @param {Cartesian3[]} positions
+     */
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  }, {
+    key: "_updateLabelFunc",
+    value: function _updateLabelFunc(positions) {}
+  }, {
+    key: "_cartesian2Lonlat",
+    value: function _cartesian2Lonlat(positions) {
+      var _this = this;
+      return positions.map(function (pos) {
+        var cartographic = _this._viewer.scene.globe.ellipsoid.cartesianToCartographic(pos);
+        var lon = +CMath.toDegrees(cartographic.longitude);
+        var lat = +CMath.toDegrees(cartographic.latitude);
+        return [lon, lat];
+      });
+    }
+  }, {
+    key: "start",
+    value: function start() {}
+
+    /**
+     * 开始绘制
+     * @param {string} type 绘制图形类型
+     * @param {boolean} clampToGround 是否贴地
+     */
+  }, {
+    key: "_start",
+    value: function _start(type, options) {
+      var _ref = options !== null && options !== void 0 ? options : {},
+        style = _ref.style,
+        clampToGround = _ref.clampToGround;
+      if (this._status !== 'INIT') return;
+      var self = this;
+      this.drawer.start({
+        type: type,
+        onPointsChange: self._updateLabelFunc.bind(self),
+        dynamicOptions: _objectSpread(_objectSpread({}, style), {}, {
+          clampToGround: clampToGround
+        }),
+        finalOptions: _objectSpread(_objectSpread({}, style), {}, {
+          clampToGround: clampToGround
+        }),
+        complete: this._complete
+      });
+      this._status = 'WORKING';
+    }
+  }, {
+    key: "getDistances",
+    value: function getDistances() {
+      var distances = [];
+      for (var i = 1; i < this._labels.length; i += 1) {
+        var label = this._labels.get(i);
+        distances.push({
+          // @ts-ignore
+          total: label === null || label === void 0 ? void 0 : label.total,
+          // @ts-ignore
+          prev: label === null || label === void 0 ? void 0 : label.prev
+        });
+      }
+      return distances;
+    }
+  }, {
+    key: "getAreas",
+    value: function getAreas() {
+      var label = this._labels.get(0);
+      // @ts-ignore
+      return label.total;
+    }
+
+    /**
+     * 清除测量结果,重置绘制
+     */
+  }, {
+    key: "end",
+    value: function end() {
+      this.drawer.reset();
+      this._labels.removeAll();
+      this._status = 'INIT';
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.end();
+      this.mouseTooltip.destroy();
+      if (this._viewer && !this._viewer.isDestroyed()) {
+        this._viewer.scene.primitives.remove(this._labels);
+      }
+      this._status = 'DESTROY';
+    }
+  }]);
+  return Measure;
+}();
+export { Measure as default };

package/dist/measure/index.d.ts

@@ -0,0 +1,5 @@
+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';

package/dist/measure/index.js

@@ -0,0 +1,5 @@
+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";

package/dist/measure/utils.d.ts

@@ -0,0 +1,23 @@
+import type { Cartesian2, Cartesian3, HeightReference, Viewer } from 'deeptwins-cesium';
+export type PickResult = {
+    cartesian: Cartesian3;
+    CartesianModel: Cartesian3;
+    cartesianTerrain: Cartesian3;
+    windowCoordinates: Cartesian2;
+    altitudeMode: HeightReference;
+};
+export declare function pickCartesian3(viewer: Viewer, position: Cartesian2): Cartesian3 | undefined;
+export declare function getBounds(points: Cartesian2[]): number[];
+/**
+ * 格式化显示长度
+ * @param length 单位米
+ * @param unit 目标单位
+ */
+export declare function formatLength(length: number, unitedLength: number): string;
+/**
+ * 格式化显示面积
+ * @param area 单位米
+ * @param unit 目标单位
+ */
+export declare function formatArea(area: number, unitedArea: number): string;
+export declare function mean(array: number[]): number;

package/dist/measure/utils.js

@@ -0,0 +1,58 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread 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 _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; }
+export function pickCartesian3(viewer, position) {
+  // We use `viewer.scene.pickPosition` here instead of `viewer.camera.pickEllipsoid` so that
+  // we get the correct point when mousing over terrain.
+  var ray = viewer.camera.getPickRay(position);
+  if (ray) return viewer.scene.globe.pick(ray, viewer.scene);
+  return undefined;
+}
+export function getBounds(points) {
+  var left = Math.min.apply(Math, _toConsumableArray(points.map(function (item) {
+    return item.x;
+  })));
+  var right = Math.max.apply(Math, _toConsumableArray(points.map(function (item) {
+    return item.x;
+  })));
+  var top = Math.max.apply(Math, _toConsumableArray(points.map(function (item) {
+    return item.y;
+  })));
+  var bottom = Math.min.apply(Math, _toConsumableArray(points.map(function (item) {
+    return item.y;
+  })));
+  var bounds = [left, top, right, bottom];
+  return bounds;
+}
+
+/**
+ * 格式化显示长度
+ * @param length 单位米
+ * @param unit 目标单位
+ */
+export function formatLength(length, unitedLength) {
+  if (length < 1000) {
+    return length + '米';
+  }
+  return unitedLength + '千米';
+}
+
+/**
+ * 格式化显示面积
+ * @param area 单位米
+ * @param unit 目标单位
+ */
+export function formatArea(area, unitedArea) {
+  if (area < 1000000) {
+    return area + '平方米';
+  }
+  return unitedArea + '平方千米';
+}
+export function mean(array) {
+  return array.reduce(function (accumulator, currentValue) {
+    return accumulator + currentValue;
+  }, 0) / array.length;
+}

package/dist/property/PositionProperty.d.ts

@@ -0,0 +1,8 @@
+export default class PositionProperty {
+    type: string;
+    propertyClass: null;
+    constructor();
+    static changeToPropertyData(): any;
+    static changeToPropertyOrientation(orientation: any): any;
+    static changeToPropertyHierarchy(): any;
+}

package/dist/property/PositionProperty.js

@@ -0,0 +1,56 @@
+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 * as Cesium from 'deeptwins-cesium';
+import { PROPERTY_TYPE_TO_CLASS } from "../constant";
+var PositionProperty = /*#__PURE__*/function () {
+  function PositionProperty() {
+    _classCallCheck(this, PositionProperty);
+    _defineProperty(this, "type", 'callbackProperty');
+    _defineProperty(this, "propertyClass", void 0);
+    this.propertyClass = PROPERTY_TYPE_TO_CLASS[this.type];
+  }
+
+  // 根据property类型处理数据
+  _createClass(PositionProperty, null, [{
+    key: "changeToPropertyData",
+    value: function changeToPropertyData() {
+      // @ts-ignores
+      var self = this;
+      if (!self.positionProperty) return self.source.positions;
+      return new self.positionProperty.propertyClass(function () {
+        return self.source.positions;
+      }, false);
+    }
+  }, {
+    key: "changeToPropertyOrientation",
+    value: function changeToPropertyOrientation(orientation) {
+      // @ts-ignores
+      var self = this;
+      if (!self.positionProperty) return Cesium.Transforms.headingPitchRollQuaternion(self.source.positions, orientation);
+      return new self.positionProperty.propertyClass(function () {
+        return Cesium.Transforms.headingPitchRollQuaternion(self.source.positions, orientation);
+      }, false);
+    }
+  }, {
+    key: "changeToPropertyHierarchy",
+    value: function changeToPropertyHierarchy() {
+      // @ts-ignores
+      var self = this;
+      if (!self.positionProperty) return new Cesium.PolygonHierarchy(self.source.positions, self.source.holes.map(function (t) {
+        return new Cesium.PolygonHierarchy(t);
+      }));
+      return new self.positionProperty.propertyClass(function () {
+        return new Cesium.PolygonHierarchy(self.source.positions, self.source.holes.map(function (t) {
+          return new Cesium.PolygonHierarchy(t);
+        }));
+      }, false);
+    }
+  }]);
+  return PositionProperty;
+}();
+export { PositionProperty as default };

package/dist/tileLayer/ArcGisLayer.d.ts

@@ -0,0 +1,5 @@
+import * as Cesium from 'deeptwins-cesium';
+export default class ArcGisLayer extends Cesium.ArcGisMapServerImageryProvider {
+    constructor(options: any);
+    static fromUrl(options: any): Cesium.ImageryLayer;
+}

package/dist/tileLayer/ArcGisLayer.js

@@ -0,0 +1,41 @@
+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); }
+var _excluded = ["url"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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); }; }
+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); }
+import * as Cesium from 'deeptwins-cesium';
+import ImageryLayer from "./ImageryLayer";
+
+// @ts-ignore
+var ArcGisLayer = /*#__PURE__*/function (_Cesium$ArcGisMapServ) {
+  _inherits(ArcGisLayer, _Cesium$ArcGisMapServ);
+  var _super = _createSuper(ArcGisLayer);
+  function ArcGisLayer(options) {
+    _classCallCheck(this, ArcGisLayer);
+    return _super.call(this, options);
+  }
+  _createClass(ArcGisLayer, null, [{
+    key: "fromUrl",
+    value: function fromUrl(options) {
+      var url = options.url,
+        currOptions = _objectWithoutProperties(options, _excluded);
+      // @ts-ignore
+      return ImageryLayer.fromProviderAsync(_get(_getPrototypeOf(ArcGisLayer), "fromUrl", this).call(this, url, currOptions));
+    }
+  }]);
+  return ArcGisLayer;
+}(Cesium.ArcGisMapServerImageryProvider);
+export { ArcGisLayer as default };

package/dist/tileLayer/ImageryLayer.d.ts

@@ -0,0 +1,6 @@
+import * as Cesium from 'deeptwins-cesium';
+export default class ImageryLayer extends Cesium.ImageryLayer {
+    constructor(imageryProvider: any, options?: any);
+    static fromProviderAsync(imageryProviderPromise: any, options: any): Cesium.ImageryLayer;
+    setOpacity(alpha: number): void;
+}