deeptwins-engine-3d 0.1.42 → 0.1.44

package/dist/esm/{tileLayer → lowAltitude}/BarrierLayer.js

@@ -1,91 +1,38 @@
 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 _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 _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 _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); }
+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 * as utils from "../tool/utils";
+import BaseGridMvtLayer from "./BaseGridMvtLayer";
 
 /**
  * 障碍物图层 - 基于MVT数据渲染障碍物网格
- *
- * 使用方式：
- * ```js
- * const DeepTwins = new DeepTwinsEngine3D.DeepTwins();
- * DeepTwins.onLoad(async ({ gridVTLayer }) => {
- *   const barrierLayer = new BarrierLayer(viewer, {
- *     gridVTLayer: gridVTLayer,
- *     url: 'https://...',
- *   });
- * });
- * ```
  */
-var BarrierLayer = /*#__PURE__*/function () {
-  /**
-   * 创建障碍物图层
-   * @param map Cesium Viewer实例
-   * @param options 配置选项
-   * @param options.gridVTLayer GridVTLayer类（从DeepTwins.onLoad中获取）
-   * @param options.url MVT数据URL模板，默认为障碍物数据地址
-   * @param options.dataType 数据类型，默认为'barrier'
-   * @param options.zooms 缩放级别范围，默认[10, 22]
-   * @param options.dataZooms 数据缩放级别，默认[16, 16]
-   * @param options.cacheSize 缓存大小，默认20
-   * @param options.heightColors 高度颜色映射数组，默认使用内置颜色
-   * @param options.minHeight 最小高度（米），低于此高度的障碍物不渲染，默认0
-   * @param options.maxHeight 最大高度（米），高于此高度的障碍物不渲染，默认Infinity
-   */
+var BarrierLayer = /*#__PURE__*/function (_BaseGridMvtLayer) {
+  _inherits(BarrierLayer, _BaseGridMvtLayer);
+  var _super = _createSuper(BarrierLayer);
   function BarrierLayer(map) {
-    var _this = this;
+    var _this;
     var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     _classCallCheck(this, BarrierLayer);
-    _defineProperty(this, "_mapContext", void 0);
-    _defineProperty(this, "isDestroyed", false);
-    _defineProperty(this, "_gridVTLayer", null);
-    _defineProperty(this, "_options", {});
-    _defineProperty(this, "_heightColors", []);
-    this._mapContext = map._mapContext;
-    if (!options.gridVTLayer) {
-      console.error('BarrierLayer: 请提供gridVTLayer参数，可通过DeepTwins.onLoad获取');
-      return;
-    }
-    var GridVTLayer = options.gridVTLayer;
-
-    // 验证并设置 dataZooms
-    var dataZooms = options.dataZooms || [16, 16];
-    if (!Array.isArray(dataZooms) || dataZooms.length !== 2) {
-      console.warn('BarrierLayer: dataZooms 应该是 [minZoom, maxZoom] 格式的数组，使用默认值 [16, 16]');
-      dataZooms = [16, 16];
-    }
-
-    // 设置颜色配置
-    if (options.heightColors && Array.isArray(options.heightColors)) {
-      this._heightColors = options.heightColors;
-    } else {
-      this._heightColors = _toConsumableArray(BarrierLayer.DEFAULT_HEIGHT_COLORS);
-    }
-    this._options = _objectSpread({
-      url: options.url || 'https://amappc.oss-cn-zhangjiakou.aliyuncs.com/yunjing/data/dikong/barrier/mvt/{z}_{x}_{y}.mvt',
-      dataType: options.dataType || 'barrier',
-      zooms: options.zooms || [10, 22],
-      dataZooms: dataZooms,
-      cacheSize: options.cacheSize || 20,
-      minHeight: options.minHeight !== undefined ? options.minHeight : 0,
-      maxHeight: options.maxHeight !== undefined ? options.maxHeight : Infinity
-    }, options);
+    _this = _super.call(this, map, _objectSpread({
+      dataType: 'barrier'
+    }, options));
 
     // 创建 GridVTLayer
-    var customPrimitiveCallbacks = {
+    _this.createMvtLayer({
       createPrimitives: function createPrimitives(tileNum, renderData, viewer) {
         var targetViewer = viewer || _this.getMap();
         return _this._createPrimitives(tileNum, renderData, targetViewer);
@@ -102,52 +49,24 @@ var BarrierLayer = /*#__PURE__*/function () {
       updatePrimitives: function updatePrimitives(tileNum, primitives) {
         return _this._updatePrimitives(tileNum, primitives);
       }
-    };
-    this._gridVTLayer = new GridVTLayer({
-      viewer: this.getMap(),
-      url: this._options.url,
-      cacheSize: this._options.cacheSize,
-      dataZooms: this._options.dataZooms,
-      zooms: this._options.zooms,
-      dataType: this._options.dataType,
-      customPrimitive: customPrimitiveCallbacks
     });
-
-    // 默认显示图层
-    if (typeof this._gridVTLayer.show === 'function') {
-      this._gridVTLayer.show();
-    } else if (this._gridVTLayer.visible !== undefined) {
-      this._gridVTLayer.visible = true;
-    }
+    return _this;
   }
 
-  // 是否能进行操作
+  /**
+   * 创建primitives
+   * 按照示例代码的逻辑实现，每个feature创建一个障碍物实例
+   */
   _createClass(BarrierLayer, [{
-    key: "_canOperate",
-    value: function _canOperate() {
-      if (this.isDestroyed) {
-        utils.error('SubmergenceAnalysis实例已销毁');
-        return false;
-      }
-      return true;
-    }
-  }, {
-    key: "getMap",
-    value: function getMap() {
-      return this._mapContext && this._mapContext.getMap();
-    }
-
-    /**
-     * 创建primitives
-     * 按照示例代码的逻辑实现，每个feature创建一个障碍物实例
-     */
-  }, {
     key: "_createPrimitives",
     value: function _createPrimitives(tileNum, renderData, viewer) {
+      if (!this._isViewerReady()) {
+        return [];
+      }
       var features = (renderData === null || renderData === void 0 ? void 0 : renderData.default) || [];
       var instances = [];
-      var minHeight = this._options.minHeight || 0;
-      var maxHeight = this._options.maxHeight !== undefined ? this._options.maxHeight : Infinity;
+      var minHeight = this.options.minHeight || 0;
+      var maxHeight = this.options.maxHeight !== undefined ? this.options.maxHeight : Infinity;
       for (var i = 0; i < features.length; i++) {
         var feature = features[i];
         if (!feature || !feature.lnglat || !feature.gridSize) {
@@ -164,8 +83,8 @@ var BarrierLayer = /*#__PURE__*/function () {
 
         // 根据高度计算颜色索引
         var colorIndex = Math.floor(feature.lnglat[2] / 7.66 / 3);
-        var clampedIndex = Math.max(0, Math.min(colorIndex, this._heightColors.length - 1));
-        var color = this._heightColors[clampedIndex] || '#d8daeb';
+        var clampedIndex = Math.max(0, Math.min(colorIndex, this.options.heightColors.length - 1));
+        var color = this.options.heightColors[clampedIndex] || '#d8daeb';
         var instance = new Cesium.GeometryInstance({
           geometry: Cesium.BoxGeometry.fromDimensions({
             vertexFormat: Cesium.VertexFormat.POSITION_AND_NORMAL,
@@ -178,6 +97,9 @@ var BarrierLayer = /*#__PURE__*/function () {
         });
         instances.push(instance);
       }
+      if (!this._isViewerReady() || instances.length === 0) {
+        return [];
+      }
       var primitives = [];
       if (instances.length > 0) {
         var primitive = new Cesium.Primitive({
@@ -187,9 +109,11 @@ var BarrierLayer = /*#__PURE__*/function () {
             closed: true
           })
         });
-        var targetViewer = viewer || this.getMap();
-        targetViewer.scene.primitives.add(primitive);
-        primitives.push(primitive);
+        if (this._isViewerReady()) {
+          var targetViewer = viewer || this.getMap();
+          targetViewer.scene.primitives.add(primitive);
+          primitives.push(primitive);
+        }
       }
       return primitives;
     }
@@ -242,57 +166,7 @@ var BarrierLayer = /*#__PURE__*/function () {
     value: function _updatePrimitives(_tileNum, _primitives) {
       // 预留接口，可根据需要实现更新逻辑
     }
-
-    /**
-     * 显示图层
-     */
-  }, {
-    key: "show",
-    value: function show() {
-      if (this._gridVTLayer) {
-        if (typeof this._gridVTLayer.show === 'function') {
-          this._gridVTLayer.show();
-        } else if (this._gridVTLayer.visible !== undefined) {
-          this._gridVTLayer.visible = true;
-        }
-      }
-    }
-
-    /**
-     * 隐藏图层
-     */
-  }, {
-    key: "hide",
-    value: function hide() {
-      if (this._gridVTLayer) {
-        this._gridVTLayer.hide();
-      }
-    }
-
-    /**
-     * 销毁图层
-     */
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      if (this._gridVTLayer) {
-        var _this$_gridVTLayer$de, _this$_gridVTLayer;
-        (_this$_gridVTLayer$de = (_this$_gridVTLayer = this._gridVTLayer).destroy) === null || _this$_gridVTLayer$de === void 0 || _this$_gridVTLayer$de.call(_this$_gridVTLayer);
-        this._gridVTLayer = null;
-      }
-    }
-
-    /**
-     * 获取底层GridVTLayer实例
-     */
-  }, {
-    key: "getGridVTLayer",
-    value: function getGridVTLayer() {
-      return this._gridVTLayer;
-    }
   }]);
   return BarrierLayer;
-}();
-// 默认高度颜色映射（从低到高）
-_defineProperty(BarrierLayer, "DEFAULT_HEIGHT_COLORS", ['#9e0142', '#d53e4f', '#f46d43', '#fdae61', '#fee08b', '#ffffbf', '#e6f598', '#abdda4', '#66c2a5', '#3288bd', '#5e4fa2'].reverse());
-export { BarrierLayer as default };
+}(BaseGridMvtLayer);
+export default BarrierLayer;

package/dist/esm/lowAltitude/BaseGridMvtLayer.d.ts

@@ -0,0 +1,34 @@
+declare class BaseGridMvtLayer {
+    private readonly _mapContext;
+    isDestroyed: boolean;
+    options: any;
+    _gridVTLayer: any;
+    /**
+     * 创建网格mvt图层
+     * @param map Cesium Viewer实例
+     * @param options 配置选项
+     * @param options.gridVTLayer GridVTLayer类（从DeepTwins.onLoad中获取）
+     * @param options.url MVT数据URL模板，默认为障碍物数据地址
+     * @param options.dataType 数据类型，默认为'flow'
+     * @param options.zooms 缩放级别范围，默认[10, 22]
+     * @param options.dataZooms 数据缩放级别，默认[16, 16]
+     * @param options.cacheSize 缓存大小，默认20
+     * @param options.heightColors 高度颜色映射数组，默认使用内置颜色
+     * @param options.minHeight 最小高度（米），低于此高度的障碍物不渲染，默认0
+     * @param options.maxHeight 最大高度（米），高于此高度的障碍物不渲染，默认Infinity
+     */
+    constructor(map: any, options?: any);
+    createMvtLayer(customPrimitive: any): void;
+    private _canOperate;
+    getMap(): any;
+    _isViewerReady(): boolean;
+    /**
+     * 显示/隐藏图层
+     */
+    show(isShow: boolean): void;
+    /**
+     * 销毁图层
+     */
+    destroy(): void;
+}
+export default BaseGridMvtLayer;

package/dist/esm/lowAltitude/BaseGridMvtLayer.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 _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 { merge } from 'lodash';
+import { DEFAULT_GRID_VT_OPTIONS } from "../constant";
+import * as utils from "../tool/utils";
+var BaseGridMvtLayer = /*#__PURE__*/function () {
+  /**
+   * 创建网格mvt图层
+   * @param map Cesium Viewer实例
+   * @param options 配置选项
+   * @param options.gridVTLayer GridVTLayer类（从DeepTwins.onLoad中获取）
+   * @param options.url MVT数据URL模板，默认为障碍物数据地址
+   * @param options.dataType 数据类型，默认为'flow'
+   * @param options.zooms 缩放级别范围，默认[10, 22]
+   * @param options.dataZooms 数据缩放级别，默认[16, 16]
+   * @param options.cacheSize 缓存大小，默认20
+   * @param options.heightColors 高度颜色映射数组，默认使用内置颜色
+   * @param options.minHeight 最小高度（米），低于此高度的障碍物不渲染，默认0
+   * @param options.maxHeight 最大高度（米），高于此高度的障碍物不渲染，默认Infinity
+   */
+  function BaseGridMvtLayer(map) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, BaseGridMvtLayer);
+    _defineProperty(this, "_mapContext", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    _defineProperty(this, "options", {});
+    _defineProperty(this, "_gridVTLayer", null);
+    this._mapContext = map._mapContext;
+    if (!options.gridVTLayer) {
+      utils.error('VisitLayer: 请提供gridVTLayer参数，可通过DeepTwins.onLoad获取');
+      return;
+    }
+    this.options = merge(DEFAULT_GRID_VT_OPTIONS(), options);
+  }
+
+  // 创建GridVTLayer
+  _createClass(BaseGridMvtLayer, [{
+    key: "createMvtLayer",
+    value: function createMvtLayer(customPrimitive) {
+      var GridVTLayer = this.options.gridVTLayer;
+      // 创建 GridVTLayer
+      this._gridVTLayer = new GridVTLayer({
+        viewer: this.getMap(),
+        url: this.options.url,
+        cacheSize: this.options.cacheSize,
+        dataZooms: this.options.dataZooms,
+        zooms: this.options.zooms,
+        dataType: this.options.dataType,
+        customPrimitive: customPrimitive
+      });
+    }
+
+    // 是否能进行操作
+  }, {
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        utils.error('SubmergenceAnalysis实例已销毁');
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "getMap",
+    value: function getMap() {
+      return this._mapContext && this._mapContext.getMap();
+    }
+
+    // 检查 viewer 是否就绪
+  }, {
+    key: "_isViewerReady",
+    value: function _isViewerReady() {
+      if (!this.getMap() || this.getMap().isDestroyed()) {
+        return false;
+      }
+      try {
+        var scene = this.getMap().scene;
+        var imageryLayers = this.getMap().imageryLayers;
+        return Boolean(scene && imageryLayers);
+      } catch (error) {
+        return false;
+      }
+    }
+
+    /**
+     * 显示/隐藏图层
+     */
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      if (!this._canOperate()) return;
+      if (this._gridVTLayer) {
+        if (typeof this._gridVTLayer.show === 'function') {
+          isShow ? this._gridVTLayer.show() : this._gridVTLayer.hide();
+        } else if (this._gridVTLayer.visible !== undefined) {
+          this._gridVTLayer.visible = isShow;
+        }
+      }
+    }
+
+    /**
+     * 销毁图层
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (!this._canOperate()) return;
+      this.isDestroyed = true;
+      if (this._gridVTLayer) {
+        this._gridVTLayer.destroy();
+        this._gridVTLayer = null;
+      }
+    }
+  }]);
+  return BaseGridMvtLayer;
+}();
+export default BaseGridMvtLayer;

package/dist/esm/lowAltitude/FlightPlanning.d.ts

@@ -0,0 +1,27 @@
+declare class FlightPlanning {
+    private readonly _mapContext;
+    isDestroyed: boolean;
+    options: any;
+    currentRoute: any;
+    routeGrid: any;
+    pipelinePlanningLayer: any;
+    routePointsLayer: any;
+    routePointsLabelLayer: any;
+    constructor(map: any, options: any);
+    private _canOperate;
+    getMap(): any;
+    createPlan(value: any): Promise<any>;
+    private _buildPayload;
+    private _normalizeRouteData;
+    private _createRoute;
+    private _clearRoute;
+    private _renderRouteGrids;
+    _clearRouteGrids(): void;
+    private _getColorByLayerHeight;
+    private _calculateGridCenterHeight;
+    private _getGridSizeByLevel;
+    private _calculateSphericalDistance;
+    clear(): void;
+    destroy(): void;
+}
+export default FlightPlanning;