deeptwins-engine-3d 0.0.42

package/dist/material/WeatherEffects.js

@@ -0,0 +1,159 @@
+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 { merge } from 'lodash';
+import { DEFAULT_FOG, DEFAULT_RAIN, DEFAULT_SNOW } from "../constant";
+import { colorString, toRadians } from "../tool/utils";
+var fsSnow = "\n    precision highp float;\n\n    uniform sampler2D colorTexture;\n    uniform float speed;\n    uniform float size;\n    in vec2 v_textureCoordinates;\n    out vec4 fragColor;\n\n    float snow(vec2 uv, float sc) {\n      float scale = sc * size;\n      float time = float(czm_frameNumber) / speed;\n      float w = smoothstep(1.0, 0.0, -uv.y * (scale / 10.0));\n      if (w < 0.1) return 0.0;\n      uv += time / scale;\n      uv.y += time * 2.0 / scale;\n      uv.x += sin(uv.y + time * 0.5) / scale;\n      uv *= scale;\n      vec2 s = floor(uv), f = fract(uv), p;\n      float k = 3.0, d;\n      p = 0.5 + 0.35 * sin(11.0 * fract(sin((s + p + scale) * mat2(7, 3, 6, 5)) * 5.0)) - f;\n      d = length(p);\n      k = min(d, k);\n      k = smoothstep(0.0, k, sin(f.x + f.y) * 0.01);\n      return k * w;\n    }\n\n    void main() {\n      vec2 resolution = czm_viewport.zw;\n      vec2 uv = (gl_FragCoord.xy * 2.0 - resolution.xy) / min(resolution.x, resolution.y);\n      vec3 finalColor = vec3(0.0);\n      float c = 0.0;\n      c+=snow(uv,10.);\n      c+=snow(uv,8.);\n      c+=snow(uv,7.);\n      c+=snow(uv,6.);\n      c+=snow(uv,5.);\n      c+=snow(uv,4.);\n      c+=snow(uv,3.);\n      c+=snow(uv,2.);\n      c+=snow(uv,1.);\n      c+=snow(uv,.6);\n      finalColor = vec3(c);\n\n      // \u8C03\u6574\u4EAE\u5EA6\n      finalColor = finalColor * 2.2;\n\n      fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(finalColor, 1.0), 0.2);\n    }\n  ";
+var fsRain = "\n      precision highp float;\n\n      uniform sampler2D colorTexture;\n      uniform float direction;\n      uniform float size;\n      uniform float speed;\n      in vec2 v_textureCoordinates;\n      out vec4 fragColor;\n\n      float hash(float x){\n          return fract(sin(x * 133.3) * 13.13);\n      }\n\n      void main() {\n          float time = czm_frameNumber / speed;\n          vec2 resolution = czm_viewport.zw;\n          vec2 uv = (gl_FragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);\n          vec3 c = vec3(0.6, 0.7, 0.8);\n          float a = direction;\n          float si = sin(a), co = cos(a);\n          uv *= mat2(co, -si, si, co);\n          uv *= length(uv + vec2(0.0, 4.9)) * size + 1.0;\n          float v = 1.0 - sin(hash(floor(uv.x * 100.0)) * 2.0);\n          float b = clamp(abs(sin(20.0 * time * v + uv.y * (5.0 / (2.0 + v)))) - 0.95, 0.0, 1.0) * 20.0;\n          c *= v * b;\n\n          fragColor = mix(texture(colorTexture, v_textureCoordinates), vec4(c, 1.0), 0.5);\n      }\n  ";
+var fsFog = "\n    float getDistance(sampler2D depthTexture, vec2 texCoords)\n  {\n      float depth = czm_unpackDepth(texture(depthTexture, texCoords));\n      if (depth == 0.0) {\n          return czm_infinity;\n      }\n      vec4 eyeCoordinate = czm_windowToEyeCoordinates(gl_FragCoord.xy, depth);\n      return -eyeCoordinate.z / eyeCoordinate.w;\n  }\n  //\u6839\u636E\u8DDD\u79BB\uFF0C\u5728\u4E2D\u95F4\u8FDB\u884C\u63D2\u503C\n  float interpolateByDistance(vec4 nearFarScalar, float distance)\n  {\n      //\u6839\u636E\u5E38\u8BC6\uFF0C\u96FE\u5E94\u8BE5\u662F\u8DDD\u79BB\u8FDC\uFF0C\u8D8A\u770B\u4E0D\u6E05\uFF0C\u8FD1\u8DDD\u79BB\u5185\u7684\u7269\u4F53\u53EF\u4EE5\u770B\u6E05\n      //\u56E0\u6B64\u8FD1\u8DDD\u79BBalpha=0\uFF0C\u8FDC\u8DDD\u79BB\u7684alpha=1.0\n      //\u672C\u4F8B\u4E2D\u8BBE\u7F6E\u53EF\u89C1\u5EA6\u4E3A200\u7C73\n      //\u96FE\u7279\u6548\u7684\u8D77\u59CB\u8DDD\u79BB\n      float startDistance = nearFarScalar.x;\n      //\u96FE\u7279\u6548\u7684\u8D77\u59CBalpha\u503C\n      float startValue = nearFarScalar.y;\n      //\u96FE\u7279\u6548\u7684\u7ED3\u675F\u8DDD\u79BB\n      float endDistance = nearFarScalar.z;\n      //\u96FE\u7279\u6548\u7684\u7ED3\u675Falpha\u503C\n      float endValue = nearFarScalar.w;\n      //\u6839\u636E\u6BCF\u6BB5\u8DDD\u79BB\u5360\u603B\u957F\u5EA6\u7684\u5360\u6BD4\uFF0C\u63D2\u503Calpha\uFF0C\u8DDD\u79BB\u8D8A\u8FDC\uFF0Calpha\u503C\u8D8A\u5927\u3002\u63D2\u503C\u8303\u56F40,1\u3002\n      float t = clamp((distance - startDistance) / (endDistance - startDistance), 0.0, 1.0);\n      return mix(startValue, endValue, t);\n  }\n  vec4 alphaBlend(vec4 sourceColor, vec4 destinationColor)\n  {\n      return sourceColor * vec4(sourceColor.aaa, 1.0) + destinationColor * (1.0 - sourceColor.a);\n  }\n  uniform sampler2D colorTexture;\n  uniform sampler2D depthTexture;\n  uniform vec4 fogByDistance;\n  uniform vec4 fogColor;\n  in vec2 v_textureCoordinates;\n  void main(void)\n  {\n      //\u83B7\u53D6\u5730\u7269\u8DDD\u76F8\u673A\u7684\u8DDD\u79BB\n      float distance = getDistance(depthTexture, v_textureCoordinates);\n      //\u83B7\u53D6\u573A\u666F\u539F\u672C\u7684\u7EB9\u7406\u989C\u8272\n      vec4 sceneColor = texture(colorTexture, v_textureCoordinates);\n      //\u6839\u636E\u8DDD\u79BB\uFF0C\u5BF9alpha\u8FDB\u884C\u63D2\u503C\n      float blendAmount = interpolateByDistance(fogByDistance, distance);\n      //\u5C06alpha\u53D8\u5316\u503C\u4EE3\u5165\u96FE\u7684\u539F\u59CB\u989C\u8272\u4E2D\uFF0C\u5E76\u5C06\u96FE\u4E0E\u573A\u666F\u539F\u59CB\u7EB9\u7406\u8FDB\u884C\u878D\u5408\n      vec4 finalFogColor = vec4(fogColor.rgb, fogColor.a * blendAmount);\n      out_FragColor = alphaBlend(finalFogColor, sceneColor);\n  }";
+var WeatherEffects = /*#__PURE__*/function () {
+  function WeatherEffects(type) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, WeatherEffects);
+    _defineProperty(this, "type", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "stage", void 0);
+    _defineProperty(this, "_map", void 0);
+    this.type = type;
+    this.options = options;
+    switch (this.type) {
+      case 'snow':
+        this._snowEffect(options);
+        break;
+      case 'rain':
+        this._rainEffect(options);
+        break;
+      case 'fog':
+        this._fogEffect(options);
+        break;
+    }
+  }
+
+  // 移除
+  _createClass(WeatherEffects, [{
+    key: "remove",
+    value: function remove() {
+      if (!this._map) return;
+      this._map.scene.postProcessStages.remove(this.stage);
+    }
+
+    // 添加到地图
+  }, {
+    key: "addToMap",
+    value: function addToMap(map) {
+      this._map = map;
+      map.scene.postProcessStages.add(this.stage);
+    }
+
+    // 修改参数
+  }, {
+    key: "setEffect",
+    value: function setEffect(options) {
+      this.options = merge(this.options, options);
+      var effects = {};
+      switch (this.type) {
+        case 'snow':
+          effects = this._handleSnowOptions(this.options);
+          break;
+        case 'rain':
+          effects = this._handleRainOptions(this.options);
+          break;
+        case 'fog':
+          effects = this._handleFogOptions(this.options);
+          break;
+      }
+      for (var key in effects) {
+        this.stage.uniforms[key] = effects[key];
+      }
+    }
+  }, {
+    key: "_handleSnowOptions",
+    value: function _handleSnowOptions(options) {
+      var _merge = merge(DEFAULT_SNOW(), options),
+        size = _merge.size,
+        speed = _merge.speed;
+      if (size < 1 || size > 30) {
+        throw new Error('size属性超出限制');
+      }
+      if (speed < 1 || speed > 100) {
+        throw new Error('speed属性超出限制');
+      }
+      return {
+        size: 20 / size,
+        speed: 1800 / speed
+      };
+    }
+  }, {
+    key: "_snowEffect",
+    value: function _snowEffect(options) {
+      this.stage = new Cesium.PostProcessStage({
+        fragmentShader: fsSnow,
+        uniforms: this._handleSnowOptions(options)
+      });
+    }
+  }, {
+    key: "_handleRainOptions",
+    value: function _handleRainOptions(options) {
+      var _merge2 = merge(DEFAULT_RAIN(), options),
+        direction = _merge2.direction,
+        size = _merge2.size,
+        speed = _merge2.speed;
+      if (direction < -90 || direction > 90) {
+        throw new Error('direction属性超出限制');
+      }
+      if (size < 1 || size > 100) {
+        throw new Error('size属性超出限制');
+      }
+      if (speed < 1 || speed > 100) {
+        throw new Error('speed属性超出限制');
+      }
+      return {
+        direction: toRadians(direction),
+        size: 10 / size,
+        speed: 1800 / speed
+      };
+    }
+  }, {
+    key: "_rainEffect",
+    value: function _rainEffect(options) {
+      this.stage = new Cesium.PostProcessStage({
+        fragmentShader: fsRain,
+        uniforms: this._handleRainOptions(options)
+      });
+    }
+  }, {
+    key: "_handleFogOptions",
+    value: function _handleFogOptions(options) {
+      var _merge3 = merge(DEFAULT_FOG(), options),
+        startDistance = _merge3.startDistance,
+        endDistance = _merge3.endDistance,
+        color = _merge3.color;
+      if (startDistance < 1 || startDistance > 5000) {
+        throw new Error('startDistance属性超出限制');
+      }
+      if (endDistance < 5000 || endDistance > 50000) {
+        throw new Error('endDistance属性超出限制');
+      }
+      return {
+        fogByDistance: new Cesium.Cartesian4(startDistance, 0.1, endDistance, 0.8),
+        fogColor: colorString(color)
+      };
+    }
+  }, {
+    key: "_fogEffect",
+    value: function _fogEffect(options) {
+      this.stage = new Cesium.PostProcessStage({
+        fragmentShader: fsFog,
+        uniforms: this._handleFogOptions(options)
+      });
+    }
+  }]);
+  return WeatherEffects;
+}();
+export { WeatherEffects as default };

package/dist/measure/AreaMeasure.d.ts

@@ -0,0 +1,19 @@
+import { Cartesian3 } from 'deeptwins-cesium';
+import Measure from './Measure';
+import type { PolygonGraphics } from 'deeptwins-cesium';
+/**
+ * 面积测量类
+ */
+declare class AreaMeasure extends Measure {
+    protected _updateLabelFunc(positions: Cartesian3[]): void;
+    /**
+     * 计算多边形面积
+     * @param {Cartesian3[]} positions 点位
+     * @returns {number} 面积/平方米
+     */
+    getArea(positions: Cartesian3[]): number;
+    protected _updateLabelTexts(positions: Cartesian3[]): void;
+    protected _getDistance(pos1: Cartesian3, pos2: Cartesian3): number;
+    start(style?: PolygonGraphics.ConstructorOptions): void;
+}
+export default AreaMeasure;

package/dist/measure/AreaMeasure.js

@@ -0,0 +1,97 @@
+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 _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 _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+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; }
+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 _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 { convertArea, polygon } from '@turf/helpers';
+import { Cartesian2, Cartesian3 } from 'deeptwins-cesium';
+import Measure from "./Measure";
+import { mean } from "./utils";
+import area from '@turf/area';
+/**
+ * 面积测量类
+ */
+var AreaMeasure = /*#__PURE__*/function (_Measure) {
+  _inherits(AreaMeasure, _Measure);
+  var _super = _createSuper(AreaMeasure);
+  function AreaMeasure() {
+    _classCallCheck(this, AreaMeasure);
+    return _super.apply(this, arguments);
+  }
+  _createClass(AreaMeasure, [{
+    key: "_updateLabelFunc",
+    value: function _updateLabelFunc(positions) {
+      this._labels.removeAll();
+      if (positions.length < 3) return;
+      var position = _construct(Cartesian3, _toConsumableArray(['x', 'y', 'z'].map(function (key) {
+        return mean(positions.map(function (item) {
+          return item[key];
+        }));
+      })));
+      this._labels.add(_objectSpread(_objectSpread({
+        position: position
+      }, this._labelStyle), {}, {
+        pixelOffset: new Cartesian2(-100, 0)
+      }));
+      this._updateLabelTexts(positions);
+    }
+
+    /**
+     * 计算多边形面积
+     * @param {Cartesian3[]} positions 点位
+     * @returns {number} 面积/平方米
+     */
+  }, {
+    key: "getArea",
+    value: function getArea(positions) {
+      var lonlats = this._cartesian2Lonlat(positions);
+      var pg = polygon([[].concat(_toConsumableArray(lonlats), [lonlats[0]])]);
+      var polygonArea = area(pg);
+      return polygonArea;
+    }
+  }, {
+    key: "_updateLabelTexts",
+    value: function _updateLabelTexts(positions) {
+      var label = this._labels.get(0);
+      var area = +this.getArea(positions).toFixed(2);
+      var unitedArea = +convertArea(area, 'meters', this._units).toFixed(2);
+      // @ts-ignore
+      label.total = area;
+      label.text = "".concat(this._locale.area, ": ").concat(this._locale.formatArea(area, unitedArea, this._units));
+    }
+  }, {
+    key: "_getDistance",
+    value: function _getDistance(pos1, pos2) {
+      return Cartesian3.distance(pos1, pos2);
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.end();
+      this._start('polygon', {
+        style: style
+      });
+    }
+  }]);
+  return AreaMeasure;
+}(Measure);
+export default AreaMeasure;

package/dist/measure/AreaSurfaceMeasure.d.ts

@@ -0,0 +1,30 @@
+import type { Cartesian3, Viewer } from 'deeptwins-cesium';
+import AreaMeasure from './AreaMeasure';
+import type { MeasureOptions } from './Measure';
+/**
+ * 贴地面积量算类
+ */
+declare class AreaSurfaceMeasure extends AreaMeasure {
+    private _splitNum;
+    /**
+     * 贴地面积量算构造函数
+     * @param viewer
+     * @param [options.splitNum = 10] 插值数，将面分割的网格数, 默认为10
+     */
+    constructor(viewer: Viewer, options?: MeasureOptions & {
+        splitNum?: number;
+    });
+    private _calculateSurfaceArea;
+    private calculateDetailSurfaceArea;
+    private _getWorldPositionsArea;
+    private _Cartesian2turfPolygon;
+    private _intersect;
+    private _turfPloygon2CartesianArr;
+    /**
+     * 计算贴地的多边形面积
+     * @param {Cartesian3[]} positions 点位
+     * @returns {number} 面积/平方米
+     */
+    getArea(positions: Cartesian3[]): number;
+}
+export default AreaSurfaceMeasure;

package/dist/measure/AreaSurfaceMeasure.js

@@ -0,0 +1,151 @@
+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 { polygon } from '@turf/helpers';
+import intersect from '@turf/intersect';
+import { randomPoint } from '@turf/random';
+import voronoi from '@turf/voronoi';
+import { Cartesian2, Cartographic, EllipsoidGeodesic, SceneTransforms } from 'deeptwins-cesium';
+import AreaMeasure from "./AreaMeasure";
+import { getBounds, pickCartesian3 } from "./utils";
+
+/**
+ * 贴地面积量算类
+ */
+var AreaSurfaceMeasure = /*#__PURE__*/function (_AreaMeasure) {
+  _inherits(AreaSurfaceMeasure, _AreaMeasure);
+  var _super = _createSuper(AreaSurfaceMeasure);
+  /**
+   * 贴地面积量算构造函数
+   * @param viewer
+   * @param [options.splitNum = 10] 插值数，将面分割的网格数, 默认为10
+   */
+  function AreaSurfaceMeasure(viewer) {
+    var _options$splitNum;
+    var _this;
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, AreaSurfaceMeasure);
+    _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 : 10;
+    return _this;
+  }
+  _createClass(AreaSurfaceMeasure, [{
+    key: "_calculateSurfaceArea",
+    value: function _calculateSurfaceArea(positions) {
+      var _this2 = this;
+      var result = 0;
+      var bounds = getBounds(positions);
+      var points = randomPoint(this._splitNum, {
+        bbox: [bounds[0], bounds[1], bounds[2], bounds[3]]
+      });
+      var mainPoly = this._Cartesian2turfPolygon(positions);
+      var voronoiPolygons = voronoi(points, {
+        bbox: [bounds[0], bounds[1], bounds[2], bounds[3]]
+      });
+      voronoiPolygons.features.forEach(function (element) {
+        var intersectPoints = _this2._intersect(mainPoly, element.geometry);
+        result += _this2.calculateDetailSurfaceArea(intersectPoints);
+      });
+      return result;
+    }
+  }, {
+    key: "calculateDetailSurfaceArea",
+    value: function calculateDetailSurfaceArea(positions) {
+      var _this3 = this;
+      var worldPositions = [];
+      positions.forEach(function (element) {
+        var pickResult = pickCartesian3(_this3._viewer, element);
+        if (pickResult) worldPositions.push(pickResult);
+      });
+      return this._getWorldPositionsArea(worldPositions);
+    }
+  }, {
+    key: "_getWorldPositionsArea",
+    value: function _getWorldPositionsArea(positions) {
+      var x = [0];
+      var y = [0];
+      var geodesic = new EllipsoidGeodesic();
+      var radiansPerDegree = Math.PI / 180.0; //角度转化为弧度(rad)
+      //数组x,y分别按顺序存储各点的横、纵坐标值
+      for (var i = 0; i < positions.length - 1; i += 1) {
+        var p1 = positions[i];
+        var p2 = positions[i + 1];
+        var point1cartographic = Cartographic.fromCartesian(p1);
+        var point2cartographic = Cartographic.fromCartesian(p2);
+        geodesic.setEndPoints(point1cartographic, point2cartographic);
+        var s = Math.sqrt(Math.pow(geodesic.surfaceDistance, 2) + Math.pow(point2cartographic.height - point1cartographic.height, 2));
+        var lat1 = point2cartographic.latitude * radiansPerDegree;
+        var lon1 = point2cartographic.longitude * radiansPerDegree;
+        var lat2 = point1cartographic.latitude * radiansPerDegree;
+        var lon2 = point1cartographic.longitude * radiansPerDegree;
+        var angle = -Math.atan2(Math.sin(lon1 - lon2) * Math.cos(lat2), Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(lon1 - lon2));
+        if (angle < 0) {
+          angle += Math.PI * 2.0;
+        }
+        y.push(Math.sin(angle) * s + y[i]);
+        x.push(Math.cos(angle) * s + x[i]);
+      }
+      var sum = 0;
+      for (var _i = 0; _i < x.length - 1; _i += 1) {
+        sum += x[_i] * y[_i + 1] - x[_i + 1] * y[_i];
+      }
+      return Math.abs(sum + x[x.length - 1] * y[0] - x[0] * y[y.length - 1]) / 2;
+    }
+  }, {
+    key: "_Cartesian2turfPolygon",
+    value: function _Cartesian2turfPolygon(positions) {
+      var coordinates = [[]];
+      positions.forEach(function (element) {
+        coordinates[0].push([element.x, element.y]);
+      });
+      coordinates[0].push([positions[0].x, positions[0].y]);
+      var pg = polygon(coordinates);
+      return pg.geometry;
+    }
+  }, {
+    key: "_intersect",
+    value: function _intersect(poly1, poly2) {
+      var intersection = intersect(poly1, poly2);
+      if ((intersection === null || intersection === void 0 ? void 0 : intersection.geometry) !== undefined) {
+        return this._turfPloygon2CartesianArr(intersection === null || intersection === void 0 ? void 0 : intersection.geometry);
+      } else {
+        return [];
+      }
+    }
+  }, {
+    key: "_turfPloygon2CartesianArr",
+    value: function _turfPloygon2CartesianArr(polygon) {
+      return polygon.coordinates[0].map(function (item) {
+        return new Cartesian2(item[0], item[1]);
+      });
+    }
+
+    /**
+     * 计算贴地的多边形面积
+     * @param {Cartesian3[]} positions 点位
+     * @returns {number} 面积/平方米
+     */
+  }, {
+    key: "getArea",
+    value: function getArea(positions) {
+      var _this4 = this;
+      return this._calculateSurfaceArea(positions.map(function (item) {
+        return SceneTransforms.worldToWindowCoordinates(_this4._viewer.scene, item);
+      }));
+    }
+  }]);
+  return AreaSurfaceMeasure;
+}(AreaMeasure);
+export default AreaSurfaceMeasure;

package/dist/measure/DistanceMeasure.d.ts

@@ -0,0 +1,19 @@
+import { Cartesian3 } from 'deeptwins-cesium';
+import Measure from './Measure';
+import type { PolylineGraphics } from 'deeptwins-cesium';
+/**
+ * 距离测量类
+ */
+declare class DistanceMeasure extends Measure {
+    protected _updateLabelFunc(positions: Cartesian3[]): void;
+    /**
+     * 计算两点之间的距离
+     * @param {Cartesian3} start 点位1
+     * @param {Cartesian3} end 点位2
+     * @returns {number} 距离/米
+     */
+    getDistance(start: Cartesian3, end: Cartesian3): number;
+    protected _updateLabelTexts(positions: Cartesian3[]): void;
+    start(style?: PolylineGraphics.ConstructorOptions): void;
+}
+export default DistanceMeasure;

package/dist/measure/DistanceMeasure.js

@@ -0,0 +1,91 @@
+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 _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 _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 _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 { convertLength } from '@turf/helpers';
+import { Cartesian3 } from 'deeptwins-cesium';
+import Measure from "./Measure";
+/**
+ * 距离测量类
+ */
+var DistanceMeasure = /*#__PURE__*/function (_Measure) {
+  _inherits(DistanceMeasure, _Measure);
+  var _super = _createSuper(DistanceMeasure);
+  function DistanceMeasure() {
+    _classCallCheck(this, DistanceMeasure);
+    return _super.apply(this, arguments);
+  }
+  _createClass(DistanceMeasure, [{
+    key: "_updateLabelFunc",
+    value: function _updateLabelFunc(positions) {
+      var _this = this;
+      this._labels.removeAll();
+      positions.forEach(function (position) {
+        var newLabel = _objectSpread({
+          position: position
+        }, _this._labelStyle);
+        _this._labels.add(newLabel);
+      });
+      this._updateLabelTexts(positions);
+    }
+
+    /**
+     * 计算两点之间的距离
+     * @param {Cartesian3} start 点位1
+     * @param {Cartesian3} end 点位2
+     * @returns {number} 距离/米
+     */
+  }, {
+    key: "getDistance",
+    value: function getDistance(start, end) {
+      return Cartesian3.distance(start, end);
+    }
+  }, {
+    key: "_updateLabelTexts",
+    value: function _updateLabelTexts(positions) {
+      var num = positions.length;
+      var distance = 0;
+      for (var i = 0; i < num; i += 1) {
+        var label = this._labels.get(i);
+        if (i === 0) {
+          label.text = this._locale.start;
+          continue;
+        } else {
+          var newDis = +this.getDistance(positions[i - 1], positions[i]).toFixed(2);
+          var unitedNewDis = +convertLength(newDis, 'meters', this._units).toFixed(2);
+          distance += newDis;
+          distance = +distance.toFixed(2);
+          var unitedDistance = +convertLength(distance, 'meters', this._units).toFixed(2);
+          // @ts-ignore
+          label.total = distance;
+          // @ts-ignore
+          label.prev = newDis;
+          label.text = (i === num - 1 ? "".concat(this._locale.total, ": ") : '') + this._locale.formatLength(distance, unitedDistance, this._units) + (i > 1 ? "\n(+".concat(this._locale.formatLength(newDis, unitedNewDis, this._units), ")") : '');
+        }
+      }
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this._start('polyline', {
+        style: style,
+        clampToGround: false
+      });
+    }
+  }]);
+  return DistanceMeasure;
+}(Measure);
+export default DistanceMeasure;

package/dist/measure/DistanceSurfaceMeasure.d.ts

@@ -0,0 +1,37 @@
+import DistanceMeasure from './DistanceMeasure';
+import type { Cartesian3, PolylineGraphics, Viewer } from 'deeptwins-cesium';
+import type { MeasureOptions } from './Measure';
+/**
+ * 贴地距离测量类
+ */
+declare class DistanceSurfaceMeasure extends DistanceMeasure {
+    private _splitNum;
+    constructor(viewer: Viewer, options?: MeasureOptions & {
+        splitNum?: number;
+    });
+    /**
+     * 计算线段的表面距离
+     * @param startPoint  -线段起点的屏幕坐标
+     * @param endPoint    -线段终点的屏幕坐标
+     * @returns 表面距离
+     */
+    private _calculateSurfaceDistance;
+    /**
+     * 计算细分后的，每一小段的笛卡尔坐标距离（也就是大地坐标系距离）
+     * @param startPoint -每一段线段起点
+     * @param endPoint -每一段线段终点
+     * @returns 表面距离
+     */
+    private _calculateDetailSurfaceLength;
+    /**
+     * 获取线段上距起点一定距离出的线上点坐标（屏幕坐标）
+     * @param startPosition  -线段起点（屏幕坐标）
+     * @param endPosition -线段终点（屏幕坐标）
+     * @param interval -距起点距离
+     * @returns -结果坐标（屏幕坐标）
+     */
+    private _findWindowPositionByPixelInterval;
+    getDistance(pos1: Cartesian3, pos2: Cartesian3): number;
+    start(style?: PolylineGraphics.ConstructorOptions): void;
+}
+export default DistanceSurfaceMeasure;