deeptwins-engine-3d 0.0.42

package/dist/videoFusion/VideoProject.js

@@ -0,0 +1,230 @@
+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 _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); }
+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_VIDEO_TEXTURE_HLS, DEFAULT_VIDEO_TEXTURE_VIDEO } from "../constant";
+import { ClampToGround } from "../tool/common";
+import * as utils from "../tool/utils";
+import BaseVideo from "./BaseVideo";
+
+// 视频投射
+var VideoProject = /*#__PURE__*/function (_BaseVideo) {
+  _inherits(VideoProject, _BaseVideo);
+  var _super = _createSuper(VideoProject);
+  function VideoProject(options) {
+    var _this;
+    _classCallCheck(this, VideoProject);
+    _this = _super.call(this, options);
+    _defineProperty(_assertThisInitialized(_this), "type", 'fixed');
+    _defineProperty(_assertThisInitialized(_this), "frustum", void 0);
+    _defineProperty(_assertThisInitialized(_this), "frustumLineLayer", void 0);
+    return _this;
+  }
+  _createClass(VideoProject, [{
+    key: "addToMap",
+    value: function addToMap(map) {
+      var _this2 = this;
+      this._canOperate();
+      this._map = map;
+      var videoOptions;
+      if (this.videoType === 'video') {
+        this.options.video.autoPlay && this.play();
+        videoOptions = merge(DEFAULT_VIDEO_TEXTURE_VIDEO(), this.options.video);
+      }
+      if (this.videoType === 'hls') {
+        this.options.hls.autoPlay && this.status === 'READY' && this.play();
+        videoOptions = merge(DEFAULT_VIDEO_TEXTURE_HLS(), this.options.hls);
+      }
+      var _this$options = this.options,
+        _this$options$type = _this$options.type,
+        type = _this$options$type === void 0 ? 'fixed' : _this$options$type,
+        frustum = _this$options.frustum,
+        _this$options$style = _this$options.style,
+        _this$options$style2 = _this$options$style === void 0 ? {
+          edgeFeather: false,
+          clampToGround: 'terrain',
+          showLine: true
+        } : _this$options$style,
+        edgeFeather = _this$options$style2.edgeFeather,
+        clampToGround = _this$options$style2.clampToGround,
+        showLine = _this$options$style2.showLine;
+      frustum.show(false);
+      this.type = type;
+      this.frustum = frustum;
+      // 取后4个点
+      var points = this.frustum.getFrustumVertexPoints().slice(-4);
+      if (this.type === 'projection') {
+        // 交点数组
+        var interPoints = [];
+        points.forEach(function (point) {
+          var interPoint = _this2._getInterPointByLine(_this2.frustum.options.position, point);
+          interPoints.push(interPoint);
+        });
+        if (showLine) {
+          // 绘制线
+          this._drawLine(interPoints);
+        }
+        this.videoPolygonLayer = map.addGraphicLayer({
+          type: 'Feature',
+          geometry: {
+            type: 'Polygon',
+            coordinates: [interPoints]
+          }
+        }, {
+          type: 'polygon',
+          style: {
+            material: edgeFeather ? new Cesium.ImageMaterialProperty({
+              image: new Cesium.CallbackProperty(function () {
+                return _this2._drawCanvas(videoOptions);
+              }, false),
+              transparent: true
+            }) : this.videoElement,
+            heightReference: clampToGround ? Cesium.HeightReference.CLAMP_TO_GROUND : Cesium.HeightReference.NONE,
+            perPositionHeight: !clampToGround
+          }
+        });
+      }
+      if (this.type === 'fixed') {
+        if (showLine) {
+          // 绘制线
+          this._drawLine(points);
+        }
+        this.videoPolygonLayer = map.addGraphicLayer({
+          type: 'Feature',
+          geometry: {
+            type: 'Polygon',
+            coordinates: [points]
+          }
+        }, {
+          type: 'polygon',
+          style: {
+            material: edgeFeather ? new Cesium.ImageMaterialProperty({
+              image: new Cesium.CallbackProperty(function () {
+                return _this2._drawCanvas(videoOptions);
+              }, false),
+              transparent: true
+            }) : this.videoElement,
+            heightReference: Cesium.HeightReference.NONE,
+            perPositionHeight: true
+          }
+        });
+      }
+      this.status = 'START';
+    }
+
+    // 显示隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      this._canOperate();
+      this.frustumLineLayer && this.frustumLineLayer.show(isShow);
+      _get(_getPrototypeOf(VideoProject.prototype), "show", this).call(this, isShow);
+    }
+
+    // 绘制线
+  }, {
+    key: "_drawLine",
+    value: function _drawLine(interPoints) {
+      var _this3 = this,
+        _this$options$style3;
+      var draw = function draw(geoJson) {
+        _this3.frustumLineLayer = _this3._map.addGraphicLayer(geoJson, {
+          type: 'polylineP',
+          style: {
+            color: '#ffffff'
+          }
+        });
+      };
+      var linePoints = [];
+      // 是否计算贴地
+      if ((_this$options$style3 = this.options.style) !== null && _this$options$style3 !== void 0 && _this$options$style3.clampToGround && this.type === 'projection') {
+        var clampToGround = new ClampToGround(this._map);
+        var c3arr = utils.lngLatAltArrayToCartesian3Array(interPoints);
+        clampToGround.getLngLatAltArrToHeight(c3arr, 'terrain').then(function (result) {
+          result.coordinates.forEach(function (point) {
+            linePoints.push({
+              type: 'Feature',
+              geometry: {
+                type: 'LineString',
+                coordinates: [_this3.frustum.options.position, point]
+              }
+            });
+          });
+          draw({
+            type: 'FeatureCollection',
+            features: linePoints
+          });
+        });
+      } else {
+        interPoints.forEach(function (interPoint) {
+          linePoints.push({
+            type: 'Feature',
+            geometry: {
+              type: 'LineString',
+              coordinates: [_this3.frustum.options.position, interPoint]
+            }
+          });
+        });
+        draw({
+          type: 'FeatureCollection',
+          features: linePoints
+        });
+      }
+    }
+
+    // 求射线的交点
+  }, {
+    key: "_getInterPointByLine",
+    value: function _getInterPointByLine(start, end) {
+      var startPoint = utils.lngLatAltToCartographic(start[0], start[1], start[2]);
+      var endPoint = utils.lngLatAltToCartographic(end[0], end[1], end[2]);
+      // 创建起点和终点的笛卡尔坐标
+      var startCartesian = this._map.scene.globe.ellipsoid.cartographicToCartesian(startPoint);
+      var endCartesian = this._map.scene.globe.ellipsoid.cartographicToCartesian(endPoint);
+      // 通过原点和方向 创建射线
+      var direction = Cesium.Cartesian3.subtract(endCartesian, startCartesian, new Cesium.Cartesian3());
+      var ray = new Cesium.Ray(startCartesian, direction);
+
+      // 计算射线与地球表面的交点
+      var result = Cesium.IntersectionTests.rayEllipsoid(ray, this._map.scene.globe.ellipsoid);
+      if (result && result.start !== result.stop) {
+        // 计算交点的位置
+        var intersectionPoint = Cesium.Ray.getPoint(ray, result.start);
+        // 将交点的笛卡尔坐标转换为地理坐标
+        var cartographic = Cesium.Cartographic.fromCartesian(intersectionPoint);
+        var lng = utils.toDegrees(cartographic.longitude); //经度
+        var lat = utils.toDegrees(cartographic.latitude); //纬度
+        var alt = cartographic.height || 0;
+        return [lng, lat, alt];
+      } else {
+        return null;
+      }
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._canOperate();
+      this.frustum && this.frustum.destroy();
+      this.frustum = null;
+      this.frustumLineLayer && this._map.removeGraphicSource(this.frustumLineLayer.id);
+      this.frustumLineLayer = null;
+      _get(_getPrototypeOf(VideoProject.prototype), "destroy", this).call(this);
+    }
+  }]);
+  return VideoProject;
+}(BaseVideo);
+export { VideoProject as default };

package/dist/videoFusion/VideoTexture.d.ts

@@ -0,0 +1,5 @@
+import BaseVideo from './BaseVideo';
+export default class VideoTexture extends BaseVideo {
+    constructor(options: any);
+    addToMap(map: any): void;
+}

package/dist/videoFusion/VideoTexture.js

@@ -0,0 +1,70 @@
+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 = ["edgeFeather"];
+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 _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 _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 { merge } from 'lodash';
+import { DEFAULT_VIDEO_TEXTURE_HLS, DEFAULT_VIDEO_TEXTURE_VIDEO } from "../constant";
+import BaseVideo from "./BaseVideo";
+
+// 视频纹理
+var VideoTexture = /*#__PURE__*/function (_BaseVideo) {
+  _inherits(VideoTexture, _BaseVideo);
+  var _super = _createSuper(VideoTexture);
+  function VideoTexture(options) {
+    _classCallCheck(this, VideoTexture);
+    return _super.call(this, options);
+  }
+  _createClass(VideoTexture, [{
+    key: "addToMap",
+    value: function addToMap(map) {
+      var _this = this;
+      this._canOperate();
+      this._map = map;
+      var videoOptions;
+      if (this.videoType === 'video') {
+        this.options.video.autoPlay && this.play();
+        videoOptions = merge(DEFAULT_VIDEO_TEXTURE_VIDEO(), this.options.video);
+      }
+      if (this.videoType === 'hls') {
+        this.options.hls.autoPlay && this.status === 'READY' && this.play();
+        videoOptions = merge(DEFAULT_VIDEO_TEXTURE_HLS(), this.options.hls);
+      }
+      var _this$options$style = this.options.style,
+        _this$options$style2 = _this$options$style === void 0 ? {
+          edgeFeather: false
+        } : _this$options$style,
+        edgeFeather = _this$options$style2.edgeFeather,
+        style = _objectWithoutProperties(_this$options$style2, _excluded);
+      this.videoPolygonLayer = map.addGraphicLayer(this.options.data, {
+        type: 'polygon',
+        style: _objectSpread({
+          material: edgeFeather ? new Cesium.ImageMaterialProperty({
+            image: new Cesium.CallbackProperty(function () {
+              return _this._drawCanvas(videoOptions);
+            }, false),
+            transparent: true
+          }) : this.videoElement
+        }, style || {})
+      });
+      this.status = 'START';
+    }
+  }]);
+  return VideoTexture;
+}(BaseVideo);
+export { VideoTexture as default };

package/dist/visualization/Airspace.d.ts

@@ -0,0 +1,11 @@
+export default class Airspace {
+    private _map;
+    options: any;
+    primitives: any[];
+    isDestroyed: boolean;
+    constructor(map: any, geoJson: any, options?: any);
+    private _canOperate;
+    sliceArrayAsync(data: any[], chunkSize?: number): void;
+    create(source: any[]): void;
+    destroy(): void;
+}

package/dist/visualization/Airspace.js

@@ -0,0 +1,87 @@
+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_AIRSPACE_STYLE } from "../constant";
+import BaseSource from "../graphicLayer/BaseSource";
+import BoxPrimitive from "../graphicLayer/BoxPrimitive";
+import BoxPrimitiveInstance from "../graphicLayer/BoxPrimitiveInstance";
+
+// 空域绘制
+var Airspace = /*#__PURE__*/function () {
+  function Airspace(map, geoJson) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    _classCallCheck(this, Airspace);
+    _defineProperty(this, "_map", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "primitives", []);
+    _defineProperty(this, "isDestroyed", false);
+    this._map = map;
+    this.options = merge(DEFAULT_AIRSPACE_STYLE(), options);
+    var source = BaseSource.geoJsonToGeoCartesian3Array(geoJson);
+    this.sliceArrayAsync(source, this.options.chunkSize);
+  }
+
+  // 是否能进行操作
+  _createClass(Airspace, [{
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        throw new Error('BaseLayer实例已销毁');
+      }
+    }
+
+    // 每10w条数据切片
+  }, {
+    key: "sliceArrayAsync",
+    value: function sliceArrayAsync(data) {
+      var _this = this;
+      var chunkSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10000;
+      var processChunk = function processChunk() {
+        if (data.length === 0) return;
+        _this.create(data.splice(0, chunkSize));
+        setTimeout(processChunk, 0); // 让出主线程，下一帧继续
+      };
+      processChunk();
+    }
+  }, {
+    key: "create",
+    value: function create(source) {
+      var boxPrimitive = new BoxPrimitive(this._map);
+      this.primitives.push(boxPrimitive);
+      for (var i = 0; i < source.length; i++) {
+        new BoxPrimitiveInstance({
+          positions: source[i].positions,
+          style: {
+            color: source[i].properties.color,
+            dimensions: this.options.dimensions,
+            scale: this.options.scale
+          },
+          primitiveCollection: boxPrimitive
+        });
+      }
+      boxPrimitive.createPrimitive({
+        style: this.options
+      });
+      boxPrimitive.primitiveInstance = [];
+      this._map.scene.primitives.add(boxPrimitive.primitive);
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._canOperate();
+      this.isDestroyed = true;
+      for (var i = 0; i < this.primitives.length; i++) {
+        this.primitives[i].removeAll();
+      }
+      this.primitives = [];
+      this._map = null;
+    }
+  }]);
+  return Airspace;
+}();
+export { Airspace as default };

package/dist/visualization/BaseFrustum.d.ts

@@ -0,0 +1,12 @@
+export default class BaseFrustum {
+    _map: any;
+    options: any;
+    frustumPrimitive: any;
+    frustumLinePrimitive: any;
+    isDestroyed: boolean;
+    constructor(map: any, options: any);
+    private _canOperate;
+    getFrustumVertexPoints(): any;
+    show(isShow: boolean): void;
+    destroy(): void;
+}

package/dist/visualization/BaseFrustum.js

@@ -0,0 +1,82 @@
+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 * as utils from "../tool/utils";
+
+// 视锥体
+var BaseFrustum = /*#__PURE__*/function () {
+  function BaseFrustum(map, options) {
+    _classCallCheck(this, BaseFrustum);
+    _defineProperty(this, "_map", void 0);
+    // 参数
+    _defineProperty(this, "options", void 0);
+    // 视锥面
+    _defineProperty(this, "frustumPrimitive", void 0);
+    // 视锥线
+    _defineProperty(this, "frustumLinePrimitive", void 0);
+    _defineProperty(this, "isDestroyed", false);
+    this._map = map;
+    this.options = options;
+  }
+
+  // 是否能进行操作
+  _createClass(BaseFrustum, [{
+    key: "_canOperate",
+    value: function _canOperate() {
+      if (this.isDestroyed) {
+        throw new Error('BaseLayer实例已销毁');
+      }
+    }
+
+    // 获取顶点坐标
+  }, {
+    key: "getFrustumVertexPoints",
+    value: function getFrustumVertexPoints() {
+      this._canOperate();
+      var geometry = Cesium.FrustumOutlineGeometry.createGeometry(this.frustumPrimitive.geometryInstances.geometry);
+      var positions = geometry.attributes.position.values;
+
+      // 获取模型变换矩阵
+      var modelMatrix = this.frustumPrimitive.geometryInstances.modelMatrix;
+      var result = [];
+      for (var i = 0; i < positions.length; i += 3) {
+        var localPosition = new Cesium.Cartesian3(positions[i], positions[i + 1], positions[i + 2]);
+        // 转换为世界坐标
+        var worldPosition = Cesium.Matrix4.multiplyByPoint(modelMatrix, localPosition, new Cesium.Cartesian3());
+        var _utils$cartesian3ToLn = utils.cartesian3ToLngLatAlt(worldPosition),
+          lng = _utils$cartesian3ToLn.lng,
+          lat = _utils$cartesian3ToLn.lat,
+          alt = _utils$cartesian3ToLn.alt;
+        result.push([lng, lat, alt]);
+      }
+      return result;
+    }
+
+    // 显示隐藏
+  }, {
+    key: "show",
+    value: function show(isShow) {
+      this.frustumPrimitive && (this.frustumPrimitive.show = isShow);
+      this.frustumLinePrimitive && (this.frustumLinePrimitive.show = isShow);
+    }
+
+    // 销毁
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this._canOperate();
+      this.isDestroyed = true;
+      this.frustumPrimitive && this._map.scene.primitives.remove(this.frustumPrimitive);
+      this.frustumPrimitive = null;
+      this.frustumLinePrimitive && this._map.scene.primitives.remove(this.frustumLinePrimitive);
+      this.frustumLinePrimitive = null;
+    }
+  }]);
+  return BaseFrustum;
+}();
+export { BaseFrustum as default };

package/dist/visualization/BaseHeatmap.d.ts

@@ -0,0 +1,23 @@
+export default class BaseHeatmap {
+    id: any;
+    heatmapInstance: any;
+    positions: any[];
+    hierarchy: any[];
+    sources: any[];
+    boundRect: any;
+    boundBox: any;
+    style: any;
+    isDestroyed: boolean;
+    canvasW: number;
+    canvasH: number;
+    _map: any;
+    heatmapEntity: any;
+    heatmapPrimitive: any;
+    constructor(options?: any);
+    canOperate(): void;
+    flyTo(options: any): void;
+    _translatePositions(): void;
+    private _computeBound;
+    private _toRectangle;
+    destroy(): void;
+}