deeptwins-engine-3d 0.1.69 → 0.1.71

package/dist/esm/visualization/MigrationEffect.js

@@ -0,0 +1,397 @@
+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, merge } from 'lodash';
+import { v4 as uuidv4 } from 'uuid';
+import { DEFAULT_MIGRATION_EFFECT_STYLE } from "../constant";
+import BaseSource from "../graphicLayer/BaseSource";
+import PolylineTrailLinkMaterialProperty from "../material/entity/PolylineTrailLinkMaterialProperty";
+import * as utils from "../tool/utils";
+// 动态迁徙效果
+var MigrationEffect = /*#__PURE__*/function () {
+  function MigrationEffect() {
+    var routes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, MigrationEffect);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "id", void 0);
+    _defineProperty(this, "routes", void 0);
+    _defineProperty(this, "style", void 0);
+    _defineProperty(this, "lineLayer", void 0);
+    _defineProperty(this, "endpointEntities", []);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "_routeSamples", []);
+    _defineProperty(this, "_isAdded", false);
+    this.id = uuidv4();
+    this.routes = routes;
+    this.style = merge(DEFAULT_MIGRATION_EFFECT_STYLE(), cloneDeep(style || {}));
+    this._routeSamples = this._buildRouteSamples(this.routes);
+  }
+  _createClass(MigrationEffect, [{
+    key: "getMap",
+    value: function getMap() {
+      var _this$_mapContext;
+      return (_this$_mapContext = this._mapContext) === null || _this$_mapContext === void 0 ? void 0 : _this$_mapContext.getMap();
+    }
+
+    // 添加到地图
+  }, {
+    key: "addToMap",
+    value: function addToMap(map) {
+      if (!this._canOperate()) {
+        return;
+      }
+      if (this._isAdded && this.getMap() === map) {
+        return this;
+      }
+      if (this._isAdded) {
+        this.remove();
+      }
+      this._mapContext = map._mapContext;
+      this._rebuild();
+      return this;
+    }
+
+    // 移除迁徙效果
+  }, {
+    key: "remove",
+    value: function remove() {
+      if (this.isDestroyed) {
+        return;
+      }
+      this._clearLayers();
+      this._isAdded = false;
+      return this;
+    }
+
+    // 显示隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      var _this = this;
+      if (!this._canOperate()) {
+        return;
+      }
+      this.style.show = isShow;
+      this.lineLayer && this.lineLayer.show(isShow);
+      this.endpointEntities.forEach(function (entity) {
+        var _this$style$endpoint;
+        entity.show = isShow && ((_this$style$endpoint = _this.style.endpoint) === null || _this$style$endpoint === void 0 ? void 0 : _this$style$endpoint.show) !== false;
+      });
+      return this;
+    }
+
+    // 更新迁徙数据
+  }, {
+    key: "setData",
+    value: function setData() {
+      var routes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      if (!this._canOperate()) {
+        return;
+      }
+      this.routes = routes;
+      this._routeSamples = this._buildRouteSamples(routes);
+      if (this._isAdded) {
+        this._rebuild();
+      }
+      return this;
+    }
+
+    // 更新迁徙样式
+  }, {
+    key: "setStyle",
+    value: function setStyle() {
+      var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this._canOperate()) {
+        return;
+      }
+      this.style = merge(this.style, cloneDeep(style || {}));
+      this._routeSamples = this._buildRouteSamples(this.routes);
+      if (this._isAdded) {
+        this._rebuild();
+      }
+      return this;
+    }
+
+    // 飞行至迁徙范围
+  }, {
+    key: "flyTo",
+    value: function flyTo() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this._canOperate() || !this.getMap()) {
+        return;
+      }
+      var positions = this._routeSamples.flatMap(function (sample) {
+        return sample.positions;
+      });
+      if (!positions.length) {
+        return;
+      }
+      utils.cameraFlyToPositions(this.getMap().camera, positions, _objectSpread({
+        scale: 1.4
+      }, options));
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this.isDestroyed) {
+        return;
+      }
+      this.remove();
+      this.routes = [];
+      this._routeSamples = [];
+      this._mapContext = undefined;
+      this.isDestroyed = true;
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('MigrationEffect实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "_rebuild",
+    value: function _rebuild() {
+      var map = this.getMap();
+      if (!map) {
+        return;
+      }
+      this._clearLayers();
+      this._routeSamples = this._buildRouteSamples(this.routes);
+      if (!this._routeSamples.length) {
+        utils.error('MigrationEffect至少需要1条有效迁徙路线');
+        this._isAdded = false;
+        return;
+      }
+      this._createLineLayer(map);
+      this._createEndpoints(map);
+      this._isAdded = true;
+    }
+  }, {
+    key: "_clearLayers",
+    value: function _clearLayers() {
+      var map = this.getMap();
+      if (this.lineLayer) {
+        this.lineLayer.remove();
+        this.lineLayer = null;
+      }
+      if (map) {
+        this.endpointEntities.forEach(function (entity) {
+          map.entities.remove(entity);
+        });
+      }
+      this.endpointEntities = [];
+    }
+  }, {
+    key: "_createLineLayer",
+    value: function _createLineLayer(map) {
+      var material = new PolylineTrailLinkMaterialProperty({
+        color: this.style.lineColor,
+        duration: this.style.duration,
+        repeat: this.style.repeat,
+        repeatPixel: this.style.repeatPixel,
+        image: this.style.image,
+        mixRatio: this.style.mixRatio
+      });
+      this.lineLayer = map.addGraphicLayer(this._buildLineGeoJson(), {
+        type: 'polyline',
+        style: {
+          show: this.style.show,
+          width: this.style.width,
+          material: material
+        }
+      });
+      material.dynamicsSize(map, this.lineLayer);
+    }
+  }, {
+    key: "_createEndpoints",
+    value: function _createEndpoints(map) {
+      var _this2 = this;
+      var endpointStyle = this.style.endpoint || {};
+      if (endpointStyle.show === false) {
+        return;
+      }
+      this._routeSamples.forEach(function (sample, index) {
+        if (endpointStyle.showStart !== false) {
+          _this2.endpointEntities.push(_this2._createEndpoint(map, sample, index, 'start'));
+        }
+        if (endpointStyle.showEnd !== false) {
+          _this2.endpointEntities.push(_this2._createEndpoint(map, sample, index, 'end'));
+        }
+      });
+    }
+  }, {
+    key: "_createEndpoint",
+    value: function _createEndpoint(map, sample, index, type) {
+      var endpointStyle = this.style.endpoint || {};
+      var position = this._getEndpointPosition(sample, type);
+      var pointColor = type === 'start' ? endpointStyle.startColor : endpointStyle.endColor;
+      return map.entities.add({
+        id: "".concat(this.id, "_endpoint_").concat(type, "_").concat(index),
+        show: this.style.show,
+        properties: _objectSpread(_objectSpread({}, sample.feature.properties || {}), {}, {
+          endpointType: type
+        }),
+        position: position,
+        point: {
+          pixelSize: endpointStyle.pixelSize,
+          color: utils.colorString(pointColor),
+          outlineColor: utils.colorString(endpointStyle.outlineColor),
+          outlineWidth: endpointStyle.outlineWidth,
+          disableDepthTestDistance: Number.POSITIVE_INFINITY
+        }
+      });
+    }
+  }, {
+    key: "_getEndpointPosition",
+    value: function _getEndpointPosition(sample, type) {
+      if (type === 'start') {
+        return sample.positions[0];
+      }
+      return sample.positions[sample.positions.length - 1];
+    }
+  }, {
+    key: "_buildLineGeoJson",
+    value: function _buildLineGeoJson() {
+      return {
+        type: 'FeatureCollection',
+        features: this._routeSamples.map(function (sample, index) {
+          return {
+            type: 'Feature',
+            properties: _objectSpread(_objectSpread({}, sample.feature.properties || {}), {}, {
+              migrationIndex: index
+            }),
+            geometry: {
+              type: 'LineString',
+              coordinates: sample.coordinates
+            }
+          };
+        })
+      };
+    }
+  }, {
+    key: "_buildRouteSamples",
+    value: function _buildRouteSamples(routes) {
+      var _this3 = this;
+      if (!routes) {
+        return [];
+      }
+      if (BaseSource.analysisSourceType(routes) !== 'geoJson') {
+        utils.error('MigrationEffect routes必须是GeoJSON Feature或FeatureCollection');
+        return [];
+      }
+      var features = [];
+      try {
+        features = BaseSource.geoJsonToGeoCartesian3Array(routes);
+      } catch (error) {
+        utils.error("MigrationEffect GeoJSON\u89E3\u6790\u5931\u8D25\uFF1A".concat(error.message));
+        return [];
+      }
+      var ignoredCount = 0;
+      var invalidCount = 0;
+      var samples = [];
+      features.forEach(function (feature) {
+        var _feature$geometry;
+        if ((feature === null || feature === void 0 || (_feature$geometry = feature.geometry) === null || _feature$geometry === void 0 ? void 0 : _feature$geometry.type) !== 'LineString') {
+          ignoredCount += 1;
+          return;
+        }
+        var sample = _this3._sampleRoute(feature);
+        if (sample) {
+          samples.push(sample);
+        } else {
+          invalidCount += 1;
+        }
+      });
+      if (ignoredCount) {
+        utils.warn("MigrationEffect\u4EC5\u652F\u6301LineString\u548CMultiLineString\uFF0C\u5DF2\u5FFD\u7565".concat(ignoredCount, "\u4E2A\u975E\u7EBF\u8981\u7D20"));
+      }
+      if (invalidCount) {
+        utils.warn("MigrationEffect\u5DF2\u5FFD\u7565".concat(invalidCount, "\u6761\u65E0\u6548\u8FC1\u5F99\u8DEF\u7EBF"));
+      }
+      return samples;
+    }
+  }, {
+    key: "_sampleRoute",
+    value: function _sampleRoute(feature) {
+      var sourceCoordinates = feature.geometry.coordinates || [];
+      var from = this._normalizeCoordinate(sourceCoordinates[0]);
+      var to = this._normalizeCoordinate(sourceCoordinates[sourceCoordinates.length - 1]);
+      if (!from || !to || this._isSamePosition(from, to)) {
+        return null;
+      }
+      var geodesic = new Cesium.EllipsoidGeodesic(Cesium.Cartographic.fromDegrees(from.lng, from.lat), Cesium.Cartographic.fromDegrees(to.lng, to.lat));
+      var segments = Math.max(2, Math.floor(this.style.segments || 64));
+      var arcHeight = Number(this.style.arcHeight) || 0;
+      var coordinates = [];
+      var positions = [];
+      for (var i = 0; i <= segments; i++) {
+        var ratio = i / segments;
+        var cartographic = geodesic.interpolateUsingFraction(ratio);
+        var lng = utils.toDegrees(cartographic.longitude);
+        var lat = utils.toDegrees(cartographic.latitude);
+        var alt = Cesium.Math.lerp(from.alt, to.alt, ratio) + Math.sin(Math.PI * ratio) * arcHeight;
+        coordinates.push([lng, lat, alt]);
+        positions.push(utils.lngLatAltToCartesian3(lng, lat, alt));
+      }
+      return {
+        feature: feature,
+        coordinates: coordinates,
+        positions: positions
+      };
+    }
+  }, {
+    key: "_normalizeCoordinate",
+    value: function _normalizeCoordinate(coordinate) {
+      if (Array.isArray(coordinate)) {
+        var _coordinate = _slicedToArray(coordinate, 3),
+          lng = _coordinate[0],
+          lat = _coordinate[1],
+          _coordinate$ = _coordinate[2],
+          alt = _coordinate$ === void 0 ? 0 : _coordinate$;
+        return this._createNormalizedPosition(lng, lat, alt);
+      }
+      return null;
+    }
+  }, {
+    key: "_createNormalizedPosition",
+    value: function _createNormalizedPosition(lng, lat) {
+      var alt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+        return null;
+      }
+      return {
+        lng: lng,
+        lat: lat,
+        alt: Number.isFinite(alt) ? alt : 0
+      };
+    }
+  }, {
+    key: "_isSamePosition",
+    value: function _isSamePosition(from, to) {
+      return from.lng === to.lng && from.lat === to.lat && from.alt === to.alt;
+    }
+  }]);
+  return MigrationEffect;
+}();
+export { MigrationEffect as default };

package/dist/esm/visualization/RadarScan.d.ts

@@ -0,0 +1,39 @@
+import { MapContext } from '../map/Map';
+type RadarScanPosition = [number, number] | [number, number, number] | {
+    lng: number;
+    lat: number;
+    alt?: number;
+};
+interface RadarScanOptions {
+    position?: RadarScanPosition;
+    style?: any;
+}
+export default class RadarScan {
+    _mapContext: MapContext | undefined;
+    id: string;
+    position: RadarScanPosition | undefined;
+    style: any;
+    primitive: any;
+    isDestroyed: boolean;
+    private _isAdded;
+    constructor(options?: RadarScanOptions);
+    getMap(): any;
+    addToMap(map: any): this | undefined;
+    remove(): this | undefined;
+    show(isShow: boolean): this | undefined;
+    setPosition(position: RadarScanPosition): this | undefined;
+    setStyle(style?: any): this | undefined;
+    flyTo(options?: any): this | undefined;
+    destroy(): void;
+    private _canOperate;
+    private _rebuildPrimitive;
+    private _createModelMatrix;
+    private _getCenterCartesian;
+    private _normalizePosition;
+    private _normalizeScanPlaneMode;
+    private _normalizeSlice;
+    private _normalizeHalfAngle;
+    private _normalizePositiveNumber;
+    private _normalizeNumber;
+}
+export {};