deeptwins-engine-3d 0.1.49 → 0.1.51

package/dist/esm/drawCommand/viewShed/ViewShedAnalyserLayer.js

@@ -0,0 +1,466 @@
+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 RectangularSensorPrimitive from "./RectangularSensorPrimitive";
+import ViewShadowPrimitive from "./ViewShadowPrimitive";
+import ViewshedMap from "./ViewShedMap";
+var ViewShedAnalyserLayer = /*#__PURE__*/function () {
+  function ViewShedAnalyserLayer(viewer, options) {
+    _classCallCheck(this, ViewShedAnalyserLayer);
+    /**
+     * <p>视域分析</p>
+     * @extends BaseAnalyser
+     * @param {Cesium.Viewer} viewer  viewer对象
+     * @param {Object} options 具有以下属性
+     * @param {Cesium.Cartesian3} options.observe 观察位置，即视点所在的位置
+     * @param {Cesium.Cartesian3} options.viewPosition 相机方法向视锥机远裁剪面的交点
+     * @param {Number} [options.far] 远裁剪面的距离
+     * @param {Number} [options.near=0.001*options.far] 近裁剪面的距离
+     * @param {Number} [options.aspectRatio=1.5] 视锥宽高比
+     * @param {Number} [options.fov=120] 视锥体的水面夹角,单位度
+     *
+     */
+    _defineProperty(this, "viewer", void 0);
+    _defineProperty(this, "options", void 0);
+    _defineProperty(this, "_observe", void 0);
+    _defineProperty(this, "_viewPosition", void 0);
+    _defineProperty(this, "_debug", void 0);
+    _defineProperty(this, "_far", void 0);
+    _defineProperty(this, "_near", void 0);
+    _defineProperty(this, "_aspectRatio", void 0);
+    _defineProperty(this, "_fov", void 0);
+    _defineProperty(this, "_direction", void 0);
+    _defineProperty(this, "_up", void 0);
+    _defineProperty(this, "_heading", void 0);
+    _defineProperty(this, "_pitch", void 0);
+    _defineProperty(this, "_roll", void 0);
+    _defineProperty(this, "_frustum", void 0);
+    _defineProperty(this, "_viewCamera", void 0);
+    _defineProperty(this, "_shadowMap", void 0);
+    _defineProperty(this, "preAnalysis", void 0);
+    _defineProperty(this, "preDo", void 0);
+    _defineProperty(this, "postAnalysis", void 0);
+    _defineProperty(this, "postDo", void 0);
+    if (!(viewer && viewer instanceof Cesium.Viewer)) {
+      throw new Error('viewer is required.');
+    }
+    this.viewer = viewer;
+    options = Cesium.defaultValue(options, {});
+    this.options = options;
+    if (!Cesium.defined(options.observe)) {
+      throw new Error('parameter options.observe is required.');
+    }
+    if (!Cesium.defined(options.viewPosition)) {
+      throw new Error('parameter options.viewPosition is required.');
+    }
+    this._observe = options.observe;
+    this._viewPosition = options.viewPosition;
+    this._debug = Cesium.defaultValue(options.debug, false);
+    this._far = Cesium.defaultValue(options.far, Cesium.Cartesian3.distance(this._observe, this._viewPosition));
+    this._near = Cesium.defaultValue(options.near, 0.001 * this._far);
+    this._aspectRatio = Cesium.defaultValue(options.aspectRatio, 1.5);
+    this._fov = Cesium.defaultValue(options.fov, 120);
+    var direction = Cesium.Cartesian3.subtract(this._viewPosition, this._observe, new Cesium.Cartesian3());
+    this._direction = Cesium.Cartesian3.normalize(direction, direction);
+    this._up = viewer.scene.mapProjection.ellipsoid.geodeticSurfaceNormal(this._observe, new Cesium.Cartesian3());
+    this._heading = undefined;
+    this._pitch = undefined;
+    this._roll = undefined;
+  }
+  /**
+   * 视锥体
+   * @type {any}
+   */
+  _createClass(ViewShedAnalyserLayer, [{
+    key: "frustum",
+    get: function get() {
+      return this._frustum;
+    }
+    /**
+     * 是否显示辅助调试的元素
+     * @type {Boolean}
+     */
+  }, {
+    key: "debug",
+    get: function get() {
+      return this._debug;
+    },
+    set: function set(val) {
+      if (this._debug !== val) {
+        this._debug = val;
+        this._frustum.show = val;
+        //   this.createOrUpdateFrustum();
+      }
+    }
+    /**
+     * 观察位置，即相机所在的位置
+     * @type {Cesium.Cartesian3}
+     */
+  }, {
+    key: "observe",
+    get: function get() {
+      return this._observe;
+    },
+    set: function set(val) {
+      if (this._observe !== val) {
+        this._observe = val;
+        this.update();
+      }
+    }
+    /**
+     * 相机方法向视锥机远裁剪面的交点
+     * @type {Cesium.Cartesian3}
+     */
+  }, {
+    key: "viewPosition",
+    get: function get() {
+      return this._viewPosition;
+    },
+    set: function set(val) {
+      if (this._viewPosition !== val) {
+        this._viewPosition = val;
+        this.update();
+      }
+    }
+
+    /**
+     * 相机方向，由viewPosition和observe决定
+     * @readonly
+     * @type {Cesium.Cartesian3}
+     */
+  }, {
+    key: "direction",
+    get: function get() {
+      return this._direction;
+    }
+    /**
+     * 相机远裁剪面到视点的距离
+     * @type {Number}
+     */
+  }, {
+    key: "far",
+    get: function get() {
+      return this._far;
+    },
+    set: function set(val) {
+      if (this._far !== val) {
+        this._far = val;
+        this.update();
+      }
+    }
+    /**
+     * 相机近裁剪面到视点的距离
+     * @type {Number}
+     */
+  }, {
+    key: "near",
+    get: function get() {
+      return this._near;
+    },
+    set: function set(val) {
+      if (this._near !== val) {
+        this._near = val;
+        this.update();
+      }
+    }
+    /**
+     * 视锥体水平夹角，单位：度
+     * @type {Number}
+     */
+  }, {
+    key: "fov",
+    get: function get() {
+      return this._fov;
+    },
+    set: function set(val) {
+      if (this._fov !== val) {
+        this._fov = val;
+        this.update();
+      }
+    }
+    /**
+     * 视锥宽高比
+     *  @type {Number}
+     */
+  }, {
+    key: "aspectRatio",
+    get: function get() {
+      return this._aspectRatio;
+    },
+    set: function set(val) {
+      if (this._aspectRatio !== val) {
+        this._aspectRatio = val;
+        this.update();
+      }
+    }
+    /**
+     * 旋转角，单位：度
+     * @type {Number}
+     * @readonly
+     */
+  }, {
+    key: "heading",
+    get: function get() {
+      this.updateHeadingPitchRoll();
+      return Cesium.Math.toDegrees(this._heading);
+    }
+    /**
+     * 俯仰角，单位：度
+     * @type {Number}
+     * @readonly
+     */
+  }, {
+    key: "pitch",
+    get: function get() {
+      this.updateHeadingPitchRoll();
+      return Cesium.Math.toDegrees(this._pitch);
+    }
+    /**
+     * 翻滚角，单位：度
+     * @type {Number}
+     * @readonly
+     */
+  }, {
+    key: "roll",
+    get: function get() {
+      this.updateHeadingPitchRoll();
+      return Cesium.Math.toDegrees(this._roll);
+    }
+  }, {
+    key: "update",
+    value: function update() {
+      this.createOrupdateCamera();
+      this.createOrUpdateFrustum();
+      this.createOrUpdateShadowMap();
+    }
+    /**
+     * 更新视角
+     */
+  }, {
+    key: "updateHeadingPitchRoll",
+    value: function updateHeadingPitchRoll() {
+      var oldTransform = Cesium.Matrix4.clone(this._viewCamera._transform, new Cesium.Matrix4());
+      var transform = Cesium.Transforms.eastNorthUpToFixedFrame(this._viewCamera.positionWC, this._viewCamera._projection.ellipsoid);
+      this._viewCamera._setTransform(transform);
+      this._pitch = this.getPitch(this._viewCamera.direction);
+      this._heading = this.getHeading(this._viewCamera.direction, this._viewCamera.up);
+      this._roll = this.getRoll(this._viewCamera.direction, this._viewCamera.up, this._viewCamera.right);
+      this._viewCamera._setTransform(oldTransform);
+    }
+
+    /**
+     * 获取俯仰角
+     * @param direction: Cesium.Cartesian3
+     * @returns {number}
+     */
+  }, {
+    key: "getPitch",
+    value: function getPitch(direction) {
+      return Cesium.Math.PI_OVER_TWO - Cesium.Math.acosClamped(direction.z);
+    }
+
+    /**
+     * 获取偏航角
+     * @param direction: Cesium.Cartesian3
+     * @param up: Cesium.Cartesian3
+     * @returns {number}
+     */
+  }, {
+    key: "getHeading",
+    value: function getHeading(direction, up) {
+      var heading;
+      if (!Cesium.Math.equalsEpsilon(Math.abs(direction.z), 1.0, Cesium.Math.EPSILON3)) {
+        heading = Math.atan2(direction.y, direction.x) - Cesium.Math.PI_OVER_TWO;
+      } else {
+        heading = Math.atan2(up.y, up.x) - Cesium.Math.PI_OVER_TWO;
+      }
+      return Cesium.Math.TWO_PI - Cesium.Math.zeroToTwoPi(heading);
+    }
+
+    /**
+     * 获取横滚角
+     * @param direction: Cesium.Cartesian3
+     * @param up: Cesium.Cartesian3
+     * @param right: Cesium.Cartesian3
+     * @returns {number}
+     */
+  }, {
+    key: "getRoll",
+    value: function getRoll(direction, up, right) {
+      var roll = 0.0;
+      if (!Cesium.Math.equalsEpsilon(Math.abs(direction.z), 1.0, Cesium.Math.EPSILON3)) {
+        roll = Math.atan2(-right.z, up.z);
+        roll = Cesium.Math.zeroToTwoPi(roll + Cesium.Math.TWO_PI);
+      }
+      return roll;
+    }
+    /**
+     * 创建或更新相机
+     */
+  }, {
+    key: "createOrupdateCamera",
+    value: function createOrupdateCamera() {
+      if (!Cesium.defined(this._viewCamera)) {
+        this._viewCamera = new Cesium.Camera(this.viewer.scene);
+      }
+      this._viewCamera.frustum.near = this._near;
+      this._viewCamera.frustum.far = this._far;
+      this._viewCamera.frustum.aspectRatio = this._aspectRatio;
+      this._viewCamera.frustum.fov = Cesium.Math.toRadians(this.fov);
+      this._viewCamera.direction = Cesium.Cartesian3.normalize(this._direction, this._viewCamera.direction);
+      this._viewCamera.position = Cesium.Cartesian3.clone(this._observe, this._viewCamera.position);
+      this._viewCamera.up = this._up;
+      this._viewCamera.right = Cesium.Cartesian3.cross(this._viewCamera.up, this._viewCamera.direction, new Cesium.Cartesian3());
+      if (!Cesium.defined(this._heading) && !Cesium.defined(this._pitch) && !Cesium.defined(this._roll)) {
+        this.updateHeadingPitchRoll();
+      }
+    }
+    /**
+     * 创建或更新视锥体
+     * @returns {void}
+     */
+  }, {
+    key: "createOrUpdateFrustum",
+    value: function createOrUpdateFrustum() {
+      var position = this._viewCamera.positionWC;
+      var rotation = new Cesium.Matrix3();
+      var up = this._up;
+      var direction = this.direction;
+      var right = Cesium.Cartesian3.cross(up, direction, new Cesium.Cartesian3());
+      Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
+      Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
+      Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);
+      var orientation = Cesium.Quaternion.fromRotationMatrix(rotation, new Cesium.Quaternion());
+      var modelMatrix = Cesium.Matrix4.fromTranslationQuaternionRotationScale(position, orientation, new Cesium.Cartesian3(1, 1, 1), new Cesium.Matrix4());
+      if (this._frustum) {
+        this._frustum.modelMatrix = modelMatrix;
+        this._frustum.xHalfAngle = this._fov / 2;
+        this._frustum.yHalfAngle = this._fov / 2 / this._aspectRatio;
+        this._frustum.radius = this._far;
+        return;
+      }
+      this._frustum = new RectangularSensorPrimitive({
+        radius: this._far,
+        modelMatrix: modelMatrix,
+        xHalfAngle: this._fov / 2,
+        yHalfAngle: this._fov / 2 / this._aspectRatio,
+        showScanPlane: false,
+        showLateralSurfaces: false,
+        material: Cesium.Material.fromType(Cesium.Material.ColorType, {
+          color: Cesium.Color.AQUA.withAlpha(0.3)
+        }),
+        show: this.debug
+      });
+      this.viewer.scene.primitives.add(this._frustum);
+    }
+    /**
+     * 创建或更新Shadow
+     * @returns
+     */
+  }, {
+    key: "createOrUpdateShadowMap",
+    value: function createOrUpdateShadowMap() {
+      if (Cesium.defined(this._shadowMap)) {
+        this.viewer.scene.primitives.remove(this._shadowMap);
+      }
+      if (!(this._viewCamera && this._frustum._boundingSphereWC)) {
+        return;
+      }
+      this._frustum._boundingSphereWC;
+      var options = this.options;
+      options.lightCamera = this._viewCamera;
+      options.context = this.viewer.scene.context;
+      var shadowMap = new ViewshedMap(options);
+      var primitive = new ViewShadowPrimitive(shadowMap);
+      this._shadowMap = this.viewer.scene.primitives.add(primitive);
+      return this._shadowMap;
+    }
+
+    /**
+     * 相机向左旋转
+     * @param  {Number} angle 旋转角度，单位：度
+     */
+  }, {
+    key: "rotateLeft",
+    value: function rotateLeft(angle) {
+      var oldTransform = Cesium.Matrix4.clone(this._viewCamera._transform, new Cesium.Matrix4());
+      var transform = Cesium.Transforms.eastNorthUpToFixedFrame(this._viewCamera.position, this._viewCamera._projection.ellipsoid);
+      this._viewCamera._setTransform(transform);
+      this._viewCamera.rotateLeft(Cesium.Math.toRadians(angle));
+      this._viewCamera._setTransform(oldTransform);
+      Cesium.Cartesian3.clone(this._viewCamera.directionWC, this._direction);
+      this.update();
+    }
+    /**
+     * 相机向右旋转
+     * @param  {Number} angle 旋转角度，单位：度
+     */
+  }, {
+    key: "rotateRight",
+    value: function rotateRight(angle) {
+      this.rotateLeft(-angle);
+    }
+    /**
+     * 相机向下旋转
+     * @param  {Number} angle 旋转角度，单位：度
+     */
+  }, {
+    key: "rotateDown",
+    value: function rotateDown(angle) {
+      var oldTransform = Cesium.Matrix4.clone(this._viewCamera._transform, new Cesium.Matrix4());
+      var transform = Cesium.Transforms.eastNorthUpToFixedFrame(this._viewCamera.position, this._viewCamera._projection.ellipsoid);
+      this._viewCamera._setTransform(transform);
+      this._viewCamera.rotateDown(Cesium.Math.toRadians(angle));
+      this._viewCamera._setTransform(oldTransform);
+      Cesium.Cartesian3.clone(this._viewCamera.directionWC, this._direction);
+      this.update();
+    }
+    /**
+     * 相机向上旋转
+     * @param  {Number} angle 旋转角度，单位：度
+     */
+  }, {
+    key: "rotateUp",
+    value: function rotateUp(angle) {
+      this.rotateDown(-angle);
+    }
+    /**
+     * 执行视域分析
+     */
+  }, {
+    key: "do",
+    value: function _do() {
+      this.update();
+    }
+    /**
+     * 清除视域分析
+     */
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.viewer.scene.primitives.remove(this._frustum);
+      this.viewer.scene.primitives.remove(this._shadowMap);
+    }
+    /**
+     * 销毁视域分析
+     */
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      this.clear();
+      if (this._frustum && !this._frustum.isDestroyed()) {
+        this._frustum.destroy();
+      }
+      if (this._shadowMap && !this._shadowMap.isDestroyed()) {
+        this._shadowMap.destroy();
+      }
+    }
+  }]);
+  return ViewShedAnalyserLayer;
+}();
+export default ViewShedAnalyserLayer;

package/dist/esm/drawCommand/viewShed/ViewShedMap.d.ts

@@ -0,0 +1,22 @@
+/**
+ *
+ * @alias ViewshedMap
+ * @param {Object} options An object containing the following properties:
+ * @param {Cesium.Camera} options.lightCamera A camera representing the light source.
+ * @param {Boolean} [options.enabled=true] Whether the shadow map is enabled.
+ * @param {Boolean} [options.isPointLight=false] Whether the light source is a point light. Point light shadows do not use cascades.
+ * @param {Boolean} [options.pointLightRadius=100.0] Radius of the point light.
+ * @param {Boolean} [options.cascadesEnabled=true] Use multiple shadow maps to cover different partitions of the view frustum.
+ * @param {Number} [options.numberOfCascades=4] The number of cascades to use for the shadow map. Supported values are one and four.
+ * @param {Number} [options.maximumDistance=5000.0] The maximum distance used for generating cascaded shadows. Lower values improve shadow quality.
+ * @param {Number} [options.size=2048] The width and height, in pixels, of each shadow map.
+ * @param {Boolean} [options.softShadows=false] Whether percentage-closer-filtering is enabled for producing softer shadows.
+ * @param {Number} [options.darkness=0.3] The shadow darkness.
+ * @param {Boolean} [options.normalOffset=true] Whether a normal bias is applied to shadows.
+ * @demo {@link https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Shadows.html|Cesium Sandcastle Shadows Demo}
+ */
+declare function ViewshedMap(this: any, options: any): void;
+declare namespace ViewshedMap {
+    var MAXIMUM_DISTANCE: number;
+}
+export default ViewshedMap;