deeptwins-engine-3d 0.1.69 → 0.1.70

package/dist/esm/constant.d.ts

@@ -108,6 +108,64 @@ export declare const DEFAULT_HEATMAP_STYLE: () => {
         '.95': string;
     };
 };
+export declare const DEFAULT_DYNAMIC_WATER_STYLE: () => {
+    show: boolean;
+    height: number;
+    stRotation: number;
+    baseWaterColor: string;
+    blendColor: string;
+    specularMap: string;
+    normalMap: string;
+    frequency: number;
+    animationSpeed: number;
+    amplitude: number;
+    specularIntensity: number;
+    fadeFactor: number;
+};
+export declare const DEFAULT_MIGRATION_EFFECT_STYLE: () => {
+    show: boolean;
+    arcHeight: number;
+    segments: number;
+    width: number;
+    lineColor: string;
+    duration: number;
+    repeat: number[];
+    repeatPixel: number;
+    mixRatio: number;
+    image: string;
+    endpoint: {
+        show: boolean;
+        showStart: boolean;
+        showEnd: boolean;
+        pixelSize: number;
+        startColor: string;
+        endColor: string;
+        outlineColor: string;
+        outlineWidth: number;
+    };
+};
+export declare const DEFAULT_RADAR_SCAN_STYLE: () => {
+    show: boolean;
+    radius: number;
+    xHalfAngle: number;
+    yHalfAngle: number;
+    heading: number;
+    pitch: number;
+    roll: number;
+    speed: number;
+    scanPlaneMode: string;
+    color: string;
+    lineColor: string;
+    scanPlaneColor: string;
+    slice: number;
+    showLateralSurfaces: boolean;
+    showDomeSurfaces: boolean;
+    showDomeLines: boolean;
+    showSectorLines: boolean;
+    showSectorSegmentLines: boolean;
+    showScanPlane: boolean;
+    showThroughEllipsoid: boolean;
+};
 export declare const DEFAULT_POINT_CLUSTER_STYLE: () => {
     pixelRange: number;
     enabled: boolean;
@@ -235,6 +293,36 @@ export declare const DEFAULT_VIEWSHED_ANALYSIS_OPTIONS: () => {
     softShadows: boolean;
     size: number;
 };
+export declare const DEFAULT_LINE_OF_SIGHT_ANALYSIS_OPTIONS: () => {
+    position: null;
+    positionEnd: null;
+    visibleColor: string;
+    invisibleColor: string;
+    pointColor: string;
+    obstructionPointColor: string;
+    lineWidth: number;
+    pointPixelSize: number;
+    pickWidth: number;
+    tolerance: number;
+    showLine: boolean;
+    showPoint: boolean;
+    showObstructionPoint: boolean;
+    objectsToExclude: undefined;
+};
+export declare const DEFAULT_TERRAIN_EXCAVATION_ANALYSIS_OPTIONS: () => {
+    depth: number;
+    bottomHeight: undefined;
+    sampleTerrain: boolean;
+    edgeSplitNum: number;
+    showBottom: boolean;
+    showWall: boolean;
+    showEdge: boolean;
+    bottomColor: string;
+    wallColor: string;
+    edgeColor: string;
+    edgeWidth: number;
+    enabled: boolean;
+};
 export declare const DEFAULT_BASE_LAYER_TYPE: any;
 export declare const DEFAULT_BASE_LAYER: any;
 export declare const LAYER_TYPE_TO_CLASS: any;

package/dist/esm/constant.js

@@ -167,6 +167,76 @@ export var DEFAULT_HEATMAP_STYLE = function DEFAULT_HEATMAP_STYLE() {
   };
 };
 
+// 默认动态水面样式
+export var DEFAULT_DYNAMIC_WATER_STYLE = function DEFAULT_DYNAMIC_WATER_STYLE() {
+  return {
+    show: true,
+    height: 0,
+    stRotation: 0,
+    baseWaterColor: 'rgba(22, 92, 145, 0.7)',
+    blendColor: 'rgba(12, 160, 210, 0.45)',
+    specularMap: Cesium.Material.DefaultImageId,
+    normalMap: Cesium.buildModuleUrl('Assets/Textures/waterNormals.jpg'),
+    frequency: 1000,
+    animationSpeed: 0.01,
+    amplitude: 10,
+    specularIntensity: 0.7,
+    fadeFactor: 1
+  };
+};
+
+// 默认动态迁徙效果样式
+export var DEFAULT_MIGRATION_EFFECT_STYLE = function DEFAULT_MIGRATION_EFFECT_STYLE() {
+  return {
+    show: true,
+    arcHeight: 60000,
+    segments: 64,
+    width: 4,
+    lineColor: '#00d9ff',
+    duration: 4,
+    repeat: [2, 1],
+    repeatPixel: 1000,
+    mixRatio: 0.65,
+    image: utils.getDeepTwinsFile('Image/line.png'),
+    endpoint: {
+      show: false,
+      showStart: true,
+      showEnd: true,
+      pixelSize: 8,
+      startColor: '#00d9ff',
+      endColor: '#ffffff',
+      outlineColor: '#001f33',
+      outlineWidth: 2
+    }
+  };
+};
+
+// 默认雷达扫描样式
+export var DEFAULT_RADAR_SCAN_STYLE = function DEFAULT_RADAR_SCAN_STYLE() {
+  return {
+    show: true,
+    radius: 5000,
+    xHalfAngle: 35,
+    yHalfAngle: 25,
+    heading: 0,
+    pitch: 0,
+    roll: 0,
+    speed: 6,
+    scanPlaneMode: 'H',
+    color: 'rgba(0, 217, 255, 0.22)',
+    lineColor: 'rgba(160, 245, 255, 0.9)',
+    scanPlaneColor: 'rgba(0, 255, 180, 0.45)',
+    slice: 48,
+    showLateralSurfaces: true,
+    showDomeSurfaces: true,
+    showDomeLines: true,
+    showSectorLines: true,
+    showSectorSegmentLines: true,
+    showScanPlane: true,
+    showThroughEllipsoid: false
+  };
+};
+
 // 默认点聚合样式
 export var DEFAULT_POINT_CLUSTER_STYLE = function DEFAULT_POINT_CLUSTER_STYLE() {
   return {
@@ -402,6 +472,68 @@ export var DEFAULT_VIEWSHED_ANALYSIS_OPTIONS = function DEFAULT_VIEWSHED_ANALYSI
   };
 };
 
+// 默认通视分析
+export var DEFAULT_LINE_OF_SIGHT_ANALYSIS_OPTIONS = function DEFAULT_LINE_OF_SIGHT_ANALYSIS_OPTIONS() {
+  return {
+    position: null,
+    // 观察点位置
+    positionEnd: null,
+    // 目标点位置
+    visibleColor: '#00ff66',
+    // 通视线段颜色
+    invisibleColor: '#ff3333',
+    // 遮挡线段颜色
+    pointColor: '#ffffff',
+    // 起终点颜色
+    obstructionPointColor: '#ffd400',
+    // 遮挡点颜色
+    lineWidth: 4,
+    // 线宽
+    pointPixelSize: 10,
+    // 点大小
+    pickWidth: 3,
+    // 射线拾取宽度
+    tolerance: 1,
+    // 判定容差（米）
+    showLine: true,
+    // 是否显示分析线
+    showPoint: true,
+    // 是否显示起终点
+    showObstructionPoint: true,
+    // 是否显示遮挡点
+    objectsToExclude: undefined // 排除的场景对象
+  };
+};
+
+// 默认地形开挖分析
+export var DEFAULT_TERRAIN_EXCAVATION_ANALYSIS_OPTIONS = function DEFAULT_TERRAIN_EXCAVATION_ANALYSIS_OPTIONS() {
+  return {
+    depth: 50,
+    // 开挖深度（米）
+    bottomHeight: undefined,
+    // 坑底绝对高度；不传时使用边界最低高程减去depth
+    sampleTerrain: true,
+    // 是否采样地形高程
+    edgeSplitNum: 8,
+    // 边界分段采样数
+    showBottom: true,
+    // 是否显示坑底
+    showWall: true,
+    // 是否显示侧壁
+    showEdge: true,
+    // 是否显示边界线
+    bottomColor: 'rgba(76, 64, 52, 0.85)',
+    // 坑底颜色
+    wallColor: 'rgba(176, 124, 72, 0.65)',
+    // 侧壁颜色
+    edgeColor: '#f8d26a',
+    // 裁剪边缘和边界颜色
+    edgeWidth: 2,
+    // 边缘宽度
+    enabled: true // 是否启用裁剪
+  };
+};
+
 // 默认的底图类型
 export var DEFAULT_BASE_LAYER_TYPE = {
   GAO_DE_IMG: 'gd_img',

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

@@ -175,6 +175,9 @@ declare class RectangularSensorPrimitive {
         zoy: Cesium.Cartesian3[];
         zox: Cesium.Cartesian3[];
     };
+    private computeFullScanPlanePositions;
+    private isHemisphereAngles;
+    private isFullSphereAngles;
     /**
      * 计算扇面位置
      * @param primitive: any

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

@@ -537,22 +537,21 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
         }
         var angle;
         var matrix3Scratch = new Cesium.Matrix3();
+        var isFullSphere = this.isFullSphereAngles(xHalfAngle, yHalfAngle);
         if (this.scanPlaneMode == 'H') {
-          angle = 2 * yHalfAngle * percentage - yHalfAngle;
+          angle = isFullSphere ? Cesium.Math.TWO_PI * percentage : 2 * yHalfAngle * percentage - yHalfAngle;
           var cosYHalfAngle = Math.cos(angle);
           var tanXHalfAngle = Math.tan(xHalfAngle);
-          var maxX = Math.atan(cosYHalfAngle * tanXHalfAngle);
-          this._scanePlaneXHalfAngle = maxX;
-          this._scanePlaneYHalfAngle = angle;
-          Cesium.Matrix3.fromRotationX(this._scanePlaneYHalfAngle, matrix3Scratch);
+          this._scanePlaneXHalfAngle = isFullSphere ? Math.PI : this.isHemisphereAngles(xHalfAngle, yHalfAngle) ? Cesium.Math.PI_OVER_TWO : Math.atan(cosYHalfAngle * tanXHalfAngle);
+          this._scanePlaneYHalfAngle = isFullSphere ? Math.PI : angle;
+          Cesium.Matrix3.fromRotationX(angle, matrix3Scratch);
         } else {
-          angle = 2 * xHalfAngle * percentage - xHalfAngle;
+          angle = isFullSphere ? Cesium.Math.TWO_PI * percentage : 2 * xHalfAngle * percentage - xHalfAngle;
           var tanYHalfAngle = Math.tan(yHalfAngle);
           var cosXHalfAngle = Math.cos(angle);
-          var maxY = Math.atan(cosXHalfAngle * tanYHalfAngle);
-          this._scanePlaneXHalfAngle = angle;
-          this._scanePlaneYHalfAngle = maxY;
-          Cesium.Matrix3.fromRotationY(this._scanePlaneXHalfAngle, matrix3Scratch);
+          this._scanePlaneXHalfAngle = isFullSphere ? Math.PI : angle;
+          this._scanePlaneYHalfAngle = isFullSphere ? Math.PI : this.isHemisphereAngles(xHalfAngle, yHalfAngle) ? Cesium.Math.PI_OVER_TWO : Math.atan(cosXHalfAngle * tanYHalfAngle);
+          Cesium.Matrix3.fromRotationY(angle, matrix3Scratch);
         }
         Cesium.Matrix4.multiplyByMatrix3(this.modelMatrix, matrix3Scratch, this._computedScanPlaneModelMatrix);
         Cesium.Matrix4.multiplyByUniformScale(this._computedScanPlaneModelMatrix, this.radius, this._computedScanPlaneModelMatrix);
@@ -589,21 +588,25 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
     key: "createVertexArray",
     value: function createVertexArray(primitive, frameState) {
       var context = frameState.context;
-      var unitSectorPositions = this.computeUnitPosition(primitive, primitive._xHalfAngle, primitive._yHalfAngle);
-      var positions = this.computeSectorPositions(primitive, unitSectorPositions);
+      var isFullSphere = this.isFullSphereAngles(primitive._xHalfAngle, primitive._yHalfAngle);
+      var unitSectorPositions = isFullSphere ? {
+        zoy: [],
+        zox: []
+      } : this.computeUnitPosition(primitive, primitive._xHalfAngle, primitive._yHalfAngle);
+      var positions = isFullSphere ? [] : this.computeSectorPositions(primitive, unitSectorPositions);
 
       //显示扇面
-      if (primitive.showLateralSurfaces) {
+      if (!isFullSphere && primitive.showLateralSurfaces) {
         primitive._sectorVA = this.createSectorVertexArray(context, positions);
       }
 
       //显示扇面线
-      if (primitive.showSectorLines) {
+      if (!isFullSphere && primitive.showSectorLines) {
         primitive._sectorLineVA = this.createSectorLineVertexArray(context, positions);
       }
 
       //显示扇面圆顶面的交线
-      if (primitive.showSectorSegmentLines) {
+      if (!isFullSphere && primitive.showSectorSegmentLines) {
         primitive._sectorSegmentLineVA = this.createSectorSegmentLineVertexArray(context, positions);
       }
 
@@ -619,7 +622,10 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
 
       //显示扫描面
       if (primitive.showScanPlane) {
-        if (primitive.scanPlaneMode == 'H') {
+        if (isFullSphere) {
+          var scanPlanePositions = this.computeFullScanPlanePositions(primitive, primitive.scanPlaneMode);
+          primitive._scanPlaneVA = this.createScanPlaneVertexArray(context, scanPlanePositions);
+        } else if (primitive.scanPlaneMode == 'H') {
           var unitScanPlanePositions = this.computeUnitPosition(primitive, Cesium.Math.PI_OVER_TWO, 0);
           primitive._scanPlaneVA = this.createScanPlaneVertexArray(context, unitScanPlanePositions.zox);
         } else {
@@ -706,19 +712,20 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
     key: "createCommands",
     value: function createCommands(primitive, translucent) {
       primitive._colorCommands.length = 0;
+      var isFullSphere = this.isFullSphereAngles(primitive._xHalfAngle, primitive._yHalfAngle);
       var pass = translucent ? Cesium.Pass.TRANSLUCENT : Cesium.Pass.OPAQUE;
 
       //显示扇面
-      if (primitive.showLateralSurfaces) {
+      if (!isFullSphere && primitive.showLateralSurfaces) {
         this.createCommand(primitive, primitive._sectorFrontCommand, primitive._sectorBackCommand, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass);
       }
       //显示扇面线
-      if (primitive.showSectorLines) {
+      if (!isFullSphere && primitive.showSectorLines) {
         this.createCommand(primitive, primitive._sectorLineCommand, undefined, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorLineVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass, true);
       }
 
       //显示扇面交接线
-      if (primitive.showSectorSegmentLines) {
+      if (!isFullSphere && primitive.showSectorSegmentLines) {
         this.createCommand(primitive, primitive._sectorSegmentLineCommand, undefined, primitive._frontFaceRS, primitive._backFaceRS, primitive._sp, primitive._sectorSegmentLineVA, primitive._uniforms, primitive._computedModelMatrix, translucent, pass, true);
       }
 
@@ -749,13 +756,14 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
     key: "computeUnitPosition",
     value: function computeUnitPosition(primitive, xHalfAngle, yHalfAngle) {
       var slice = primitive.slice;
+      var isHemisphere = this.isHemisphereAngles(xHalfAngle, yHalfAngle);
       //以中心为角度
       var cosYHalfAngle = Math.cos(yHalfAngle);
       var tanYHalfAngle = Math.tan(yHalfAngle);
       var cosXHalfAngle = Math.cos(xHalfAngle);
       var tanXHalfAngle = Math.tan(xHalfAngle);
-      var maxY = Math.atan(cosXHalfAngle * tanYHalfAngle);
-      var maxX = Math.atan(cosYHalfAngle * tanXHalfAngle);
+      var maxY = isHemisphere ? Cesium.Math.PI_OVER_TWO : Math.atan(cosXHalfAngle * tanYHalfAngle);
+      var maxX = isHemisphere ? Cesium.Math.PI_OVER_TWO : Math.atan(cosYHalfAngle * tanXHalfAngle);
 
       //ZOY面单位圆
       var zoy = [];
@@ -774,6 +782,33 @@ var RectangularSensorPrimitive = /*#__PURE__*/function () {
         zox: zox
       };
     }
+  }, {
+    key: "computeFullScanPlanePositions",
+    value: function computeFullScanPlanePositions(primitive, mode) {
+      var slice = Math.max(primitive.slice, 32);
+      var positions = [];
+      for (var i = 0; i <= slice; i++) {
+        var angle = Cesium.Math.TWO_PI * i / slice;
+        if (mode === 'H') {
+          positions.push(new Cesium.Cartesian3(Math.cos(angle), 0, Math.sin(angle)));
+        } else {
+          positions.push(new Cesium.Cartesian3(0, Math.cos(angle), Math.sin(angle)));
+        }
+      }
+      return positions;
+    }
+  }, {
+    key: "isHemisphereAngles",
+    value: function isHemisphereAngles(xHalfAngle, yHalfAngle) {
+      var rightAngle = Cesium.Math.PI_OVER_TWO - 1e-10;
+      return xHalfAngle >= rightAngle && yHalfAngle >= rightAngle;
+    }
+  }, {
+    key: "isFullSphereAngles",
+    value: function isFullSphereAngles(xHalfAngle, yHalfAngle) {
+      var straightAngle = Math.PI - 1e-10;
+      return xHalfAngle >= straightAngle && yHalfAngle >= straightAngle;
+    }
 
     /**
      * 计算扇面位置

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

@@ -12,9 +12,9 @@ export declare const sensorVS = "\nin vec4 position;\nin vec3 normal;\nout vec3
  * FS着色器
  * @returns {ShaderSource}
  */
-export declare const sensorFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform float u_type;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{   \n    czm_materialInput materialInput;   \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz; \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   \n    materialInput.str = pointMC / sensorRadius;   \n\n    vec3 positionToEyeEC = -v_positionEC;   \n    materialInput.positionToEyeEC = positionToEyeEC;    \n\n    vec3 normalEC = normalize(v_normalEC);  \n    materialInput.normalEC = u_normalDirection * normalEC; \n\n    czm_material material = czm_getMaterial(materialInput);   \n\n     return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC),vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();  \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value))); \n    float pixels = width * delta;   \n    float temp = abs(value);    \n    // There are a couple things going on here.   \n    // First we test the value at the current fragment to see if it is within the tolerance.   \n    // We also want to check if the value of an adjacent pixel is within the tolerance,    \n    // but we don't want to admit points that are obviously not on the surface.    \n    // For example, if we are looking for \"value\" to be close to 0, but value is 1 and the adjacent value is 2,  \n    // then the delta would be 1 and \"temp - delta\" would be \"1 - 1\" which is zero even though neither of   \n    // the points is close to zero.   \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n{   \n\n    if (u_showIntersection && isOnBoundary) \n        {      \n            return getIntersectionColor();  \n        }   \n    if(u_type == 1.0)\n        {       \n            return getLineColor(); \n        }   \n\n    return getColor(u_radius, v_positionEC);\n\n}\n                   \nfloat ellipsoidSurfaceFunction(vec3 point)\n{   \n    vec3 scaled = czm_ellipsoidInverseRadii * point;  \n    return dot(scaled, scaled) - 1.0;\n}\n\nvoid main()\n{    \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    //vec3 pixDir = normalize(v_position);    \n    float positionX = v_position.x;  \n    float positionY = v_position.y;  \n    float positionZ = v_position.z;  \n    vec3 zDir = vec3(0.0, 0.0, 1.0); \n    vec3 lineX = vec3(positionX, 0 ,positionZ);  \n    vec3 lineY = vec3(0, positionY, positionZ);  \n    float resX = dot(normalize(lineX), zDir);  \n    if(resX < cos(u_xHalfAngle)-0.00001)\n    {       \n        discard; \n    }    \n    float resY = dot(normalize(lineY), zDir);  \n    if(resY < cos(u_yHalfAngle)-0.00001)\n    {    \n        discard;  \n    } \n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);\n    // Occluded by the ellipsoid?\n    if (!u_showThroughEllipsoid)\n  {   \n    // Discard if in the ellipsoid  \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first. \n    if (ellipsoidValue < 0.0) \n    {       \n        discard;  \n    }   \n    // Discard if in the sensor's shadow   \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {      \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error. \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);   \n    //isOnEllipsoid = false;   \n    // if((resX >= 0.8 && resX <= 0.81)||(resY >= 0.8 && resY <= 0.81))\n    // {     \n    //     out_FragColor = shade(false);\n    // }\n    out_FragColor = shade(isOnEllipsoid);\n}\n";
+export declare const sensorFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform float u_type;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{   \n    czm_materialInput materialInput;   \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz; \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   \n    materialInput.str = pointMC / sensorRadius;   \n\n    vec3 positionToEyeEC = -v_positionEC;   \n    materialInput.positionToEyeEC = positionToEyeEC;    \n\n    vec3 normalEC = normalize(v_normalEC);  \n    materialInput.normalEC = u_normalDirection * normalEC; \n\n    czm_material material = czm_getMaterial(materialInput);   \n\n     return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC),vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();  \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value))); \n    float pixels = width * delta;   \n    float temp = abs(value);    \n    // There are a couple things going on here.   \n    // First we test the value at the current fragment to see if it is within the tolerance.   \n    // We also want to check if the value of an adjacent pixel is within the tolerance,    \n    // but we don't want to admit points that are obviously not on the surface.    \n    // For example, if we are looking for \"value\" to be close to 0, but value is 1 and the adjacent value is 2,  \n    // then the delta would be 1 and \"temp - delta\" would be \"1 - 1\" which is zero even though neither of   \n    // the points is close to zero.   \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n{   \n\n    if (u_showIntersection && isOnBoundary) \n        {      \n            return getIntersectionColor();  \n        }   \n    if(u_type == 1.0)\n        {       \n            return getLineColor(); \n        }   \n\n    return getColor(u_radius, v_positionEC);\n\n}\n                   \nfloat ellipsoidSurfaceFunction(vec3 point)\n{   \n    vec3 scaled = czm_ellipsoidInverseRadii * point;  \n    return dot(scaled, scaled) - 1.0;\n}\n\nvoid main()\n{    \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    bool isFullSphere = u_xHalfAngle >= czm_pi - 0.0001 && u_yHalfAngle >= czm_pi - 0.0001;\n    //vec3 pixDir = normalize(v_position);    \n    if (!isFullSphere)\n    {\n        float positionX = v_position.x;  \n        float positionY = v_position.y;  \n        float positionZ = v_position.z;  \n        vec3 zDir = vec3(0.0, 0.0, 1.0); \n        vec3 lineX = vec3(positionX, 0 ,positionZ);  \n        vec3 lineY = vec3(0, positionY, positionZ);  \n        float resX = dot(normalize(lineX), zDir);  \n        if(resX < cos(u_xHalfAngle)-0.00001)\n        {       \n            discard; \n        }    \n        float resY = dot(normalize(lineY), zDir);  \n        if(resY < cos(u_yHalfAngle)-0.00001)\n        {    \n            discard;  \n        } \n    }\n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);\n    // Occluded by the ellipsoid?\n    if (!u_showThroughEllipsoid && !isFullSphere)\n  {   \n    // Discard if in the ellipsoid  \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first. \n    if (ellipsoidValue < 0.0) \n    {       \n        discard;  \n    }   \n    // Discard if in the sensor's shadow   \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {      \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error. \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);   \n    //isOnEllipsoid = false;   \n    // if((resX >= 0.8 && resX <= 0.81)||(resY >= 0.8 && resY <= 0.81))\n    // {     \n    //     out_FragColor = shade(false);\n    // }\n    out_FragColor = shade(isOnEllipsoid);\n}\n";
 /**
  * 扫描面FS着色器
  * @returns {ShaderSource}
  */
-export declare const scanPlaneFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform vec4 u_color;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{    \n    czm_materialInput materialInput;    \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;  \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);\n    materialInput.str = pointMC / sensorRadius;    \n    vec3 positionToEyeEC = -v_positionEC;    \n    materialInput.positionToEyeEC = positionToEyeEC;    \n    vec3 normalEC = normalize(v_normalEC);   \n    materialInput.normalEC = u_normalDirection * normalEC;    \n    czm_material material = czm_getMaterial(materialInput);   \n    material.diffuse = u_color.rgb;    \n    material.alpha = u_color.a;    \n    return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC), vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();   \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value)));    \n    float pixels = width * delta;    \n    float temp = abs(value);    \n    // There are a couple things going on here.    \n    //  First we test the value at the current fragment to see if it is within the tolerance.    \n    //  We also want to check if the value of an adjacent pixel is within the tolerance,   \n    //  but we don't want to admit points that are obviously not on the surface.    \n    //  For example, if we are looking for value to be close to 0, but value is 1 and the adjacent value is 2,    \n    //  then the delta would be 1 and temp - delta would be 1 - 1 which is zero even though neither of    \n    //  the points is close to zero.    \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n    {   \n    if (u_showIntersection && isOnBoundary)  \n    {    \n        return getIntersectionColor(); \n    }   \n    return getColor(u_radius, v_positionEC);\n}\n\n\nfloat ellipsoidSurfaceFunction(vec3 point)\n{    \n    vec3 scaled = czm_ellipsoidInverseRadii * point;   \n    return dot(scaled, scaled) - 1.0;\n}\n\n\nvoid main()\n{  \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    //vec3 pixDir = normalize(v_position);    \n    float positionX = v_position.x;    \n    float positionY = v_position.y;    \n    float positionZ = v_position.z;    \n    vec3 zDir = vec3(0.0, 0.0, 1.0);    \n    vec3 lineX = vec3(positionX, 0 ,positionZ);    \n    vec3 lineY = vec3(0, positionY, positionZ);    \n    float resX = dot(normalize(lineX), zDir);    \n    if(resX < cos(u_xHalfAngle) - 0.0001)\n    {       \n        discard;  \n    }    \n    float resY = dot(normalize(lineY), zDir);  \n    if(resY < cos(u_yHalfAngle)- 0.0001)\n    {   \n        discard;  \n    }   \n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);  \n    // Occluded by the ellipsoid\n    if (!u_showThroughEllipsoid)\n  {   \n    // Discard if in the ellipsoid   \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.  \n    if (ellipsoidValue < 0.0)  \n    {      \n        discard;  \n    }   \n    // Discard if in the sensor's shadow \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {    \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error.  \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);  \n    out_FragColor = shade(isOnEllipsoid);\n}\n    ";
+export declare const scanPlaneFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform vec4 u_color;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{    \n    czm_materialInput materialInput;    \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;  \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);\n    materialInput.str = pointMC / sensorRadius;    \n    vec3 positionToEyeEC = -v_positionEC;    \n    materialInput.positionToEyeEC = positionToEyeEC;    \n    vec3 normalEC = normalize(v_normalEC);   \n    materialInput.normalEC = u_normalDirection * normalEC;    \n    czm_material material = czm_getMaterial(materialInput);   \n    material.diffuse = u_color.rgb;    \n    material.alpha = u_color.a;    \n    return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC), vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();   \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value)));    \n    float pixels = width * delta;    \n    float temp = abs(value);    \n    // There are a couple things going on here.    \n    //  First we test the value at the current fragment to see if it is within the tolerance.    \n    //  We also want to check if the value of an adjacent pixel is within the tolerance,   \n    //  but we don't want to admit points that are obviously not on the surface.    \n    //  For example, if we are looking for value to be close to 0, but value is 1 and the adjacent value is 2,    \n    //  then the delta would be 1 and temp - delta would be 1 - 1 which is zero even though neither of    \n    //  the points is close to zero.    \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n    {   \n    if (u_showIntersection && isOnBoundary)  \n    {    \n        return getIntersectionColor(); \n    }   \n    return getColor(u_radius, v_positionEC);\n}\n\n\nfloat ellipsoidSurfaceFunction(vec3 point)\n{    \n    vec3 scaled = czm_ellipsoidInverseRadii * point;   \n    return dot(scaled, scaled) - 1.0;\n}\n\n\nvoid main()\n{  \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    bool isFullSphere = u_xHalfAngle >= czm_pi - 0.0001 && u_yHalfAngle >= czm_pi - 0.0001;\n    //vec3 pixDir = normalize(v_position);    \n    if (!isFullSphere)\n    {\n        float positionX = v_position.x;    \n        float positionY = v_position.y;    \n        float positionZ = v_position.z;    \n        vec3 zDir = vec3(0.0, 0.0, 1.0);    \n        vec3 lineX = vec3(positionX, 0 ,positionZ);    \n        vec3 lineY = vec3(0, positionY, positionZ);    \n        float resX = dot(normalize(lineX), zDir);    \n        if(resX < cos(u_xHalfAngle) - 0.0001)\n        {       \n            discard;  \n        }    \n        float resY = dot(normalize(lineY), zDir);  \n        if(resY < cos(u_yHalfAngle)- 0.0001)\n        {   \n            discard;  \n        }   \n    }\n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);  \n    // Occluded by the ellipsoid\n    if (!u_showThroughEllipsoid && !isFullSphere)\n  {   \n    // Discard if in the ellipsoid   \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.  \n    if (ellipsoidValue < 0.0)  \n    {      \n        discard;  \n    }   \n    // Discard if in the sensor's shadow \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {    \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error.  \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);  \n    out_FragColor = shade(isOnEllipsoid);\n}\n    ";

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

@@ -13,9 +13,9 @@ export var sensorVS = "\nin vec4 position;\nin vec3 normal;\nout vec3 v_position
  * FS着色器
  * @returns {ShaderSource}
  */
-export var sensorFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform float u_type;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{   \n    czm_materialInput materialInput;   \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz; \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   \n    materialInput.str = pointMC / sensorRadius;   \n\n    vec3 positionToEyeEC = -v_positionEC;   \n    materialInput.positionToEyeEC = positionToEyeEC;    \n\n    vec3 normalEC = normalize(v_normalEC);  \n    materialInput.normalEC = u_normalDirection * normalEC; \n\n    czm_material material = czm_getMaterial(materialInput);   \n\n     return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC),vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();  \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value))); \n    float pixels = width * delta;   \n    float temp = abs(value);    \n    // There are a couple things going on here.   \n    // First we test the value at the current fragment to see if it is within the tolerance.   \n    // We also want to check if the value of an adjacent pixel is within the tolerance,    \n    // but we don't want to admit points that are obviously not on the surface.    \n    // For example, if we are looking for \"value\" to be close to 0, but value is 1 and the adjacent value is 2,  \n    // then the delta would be 1 and \"temp - delta\" would be \"1 - 1\" which is zero even though neither of   \n    // the points is close to zero.   \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n{   \n\n    if (u_showIntersection && isOnBoundary) \n        {      \n            return getIntersectionColor();  \n        }   \n    if(u_type == 1.0)\n        {       \n            return getLineColor(); \n        }   \n\n    return getColor(u_radius, v_positionEC);\n\n}\n                   \nfloat ellipsoidSurfaceFunction(vec3 point)\n{   \n    vec3 scaled = czm_ellipsoidInverseRadii * point;  \n    return dot(scaled, scaled) - 1.0;\n}\n\nvoid main()\n{    \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    //vec3 pixDir = normalize(v_position);    \n    float positionX = v_position.x;  \n    float positionY = v_position.y;  \n    float positionZ = v_position.z;  \n    vec3 zDir = vec3(0.0, 0.0, 1.0); \n    vec3 lineX = vec3(positionX, 0 ,positionZ);  \n    vec3 lineY = vec3(0, positionY, positionZ);  \n    float resX = dot(normalize(lineX), zDir);  \n    if(resX < cos(u_xHalfAngle)-0.00001)\n    {       \n        discard; \n    }    \n    float resY = dot(normalize(lineY), zDir);  \n    if(resY < cos(u_yHalfAngle)-0.00001)\n    {    \n        discard;  \n    } \n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);\n    // Occluded by the ellipsoid?\n    if (!u_showThroughEllipsoid)\n  {   \n    // Discard if in the ellipsoid  \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first. \n    if (ellipsoidValue < 0.0) \n    {       \n        discard;  \n    }   \n    // Discard if in the sensor's shadow   \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {      \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error. \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);   \n    //isOnEllipsoid = false;   \n    // if((resX >= 0.8 && resX <= 0.81)||(resY >= 0.8 && resY <= 0.81))\n    // {     \n    //     out_FragColor = shade(false);\n    // }\n    out_FragColor = shade(isOnEllipsoid);\n}\n";
+export var sensorFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform float u_type;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{   \n    czm_materialInput materialInput;   \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz; \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);   \n    materialInput.str = pointMC / sensorRadius;   \n\n    vec3 positionToEyeEC = -v_positionEC;   \n    materialInput.positionToEyeEC = positionToEyeEC;    \n\n    vec3 normalEC = normalize(v_normalEC);  \n    materialInput.normalEC = u_normalDirection * normalEC; \n\n    czm_material material = czm_getMaterial(materialInput);   \n\n     return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC),vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();  \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value))); \n    float pixels = width * delta;   \n    float temp = abs(value);    \n    // There are a couple things going on here.   \n    // First we test the value at the current fragment to see if it is within the tolerance.   \n    // We also want to check if the value of an adjacent pixel is within the tolerance,    \n    // but we don't want to admit points that are obviously not on the surface.    \n    // For example, if we are looking for \"value\" to be close to 0, but value is 1 and the adjacent value is 2,  \n    // then the delta would be 1 and \"temp - delta\" would be \"1 - 1\" which is zero even though neither of   \n    // the points is close to zero.   \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n{   \n\n    if (u_showIntersection && isOnBoundary) \n        {      \n            return getIntersectionColor();  \n        }   \n    if(u_type == 1.0)\n        {       \n            return getLineColor(); \n        }   \n\n    return getColor(u_radius, v_positionEC);\n\n}\n                   \nfloat ellipsoidSurfaceFunction(vec3 point)\n{   \n    vec3 scaled = czm_ellipsoidInverseRadii * point;  \n    return dot(scaled, scaled) - 1.0;\n}\n\nvoid main()\n{    \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    bool isFullSphere = u_xHalfAngle >= czm_pi - 0.0001 && u_yHalfAngle >= czm_pi - 0.0001;\n    //vec3 pixDir = normalize(v_position);    \n    if (!isFullSphere)\n    {\n        float positionX = v_position.x;  \n        float positionY = v_position.y;  \n        float positionZ = v_position.z;  \n        vec3 zDir = vec3(0.0, 0.0, 1.0); \n        vec3 lineX = vec3(positionX, 0 ,positionZ);  \n        vec3 lineY = vec3(0, positionY, positionZ);  \n        float resX = dot(normalize(lineX), zDir);  \n        if(resX < cos(u_xHalfAngle)-0.00001)\n        {       \n            discard; \n        }    \n        float resY = dot(normalize(lineY), zDir);  \n        if(resY < cos(u_yHalfAngle)-0.00001)\n        {    \n            discard;  \n        } \n    }\n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);\n    // Occluded by the ellipsoid?\n    if (!u_showThroughEllipsoid && !isFullSphere)\n  {   \n    // Discard if in the ellipsoid  \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first. \n    if (ellipsoidValue < 0.0) \n    {       \n        discard;  \n    }   \n    // Discard if in the sensor's shadow   \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {      \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error. \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);   \n    //isOnEllipsoid = false;   \n    // if((resX >= 0.8 && resX <= 0.81)||(resY >= 0.8 && resY <= 0.81))\n    // {     \n    //     out_FragColor = shade(false);\n    // }\n    out_FragColor = shade(isOnEllipsoid);\n}\n";
 /**
  * 扫描面FS着色器
  * @returns {ShaderSource}
  */
-export var scanPlaneFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform vec4 u_color;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{    \n    czm_materialInput materialInput;    \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;  \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);\n    materialInput.str = pointMC / sensorRadius;    \n    vec3 positionToEyeEC = -v_positionEC;    \n    materialInput.positionToEyeEC = positionToEyeEC;    \n    vec3 normalEC = normalize(v_normalEC);   \n    materialInput.normalEC = u_normalDirection * normalEC;    \n    czm_material material = czm_getMaterial(materialInput);   \n    material.diffuse = u_color.rgb;    \n    material.alpha = u_color.a;    \n    return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC), vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();   \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value)));    \n    float pixels = width * delta;    \n    float temp = abs(value);    \n    // There are a couple things going on here.    \n    //  First we test the value at the current fragment to see if it is within the tolerance.    \n    //  We also want to check if the value of an adjacent pixel is within the tolerance,   \n    //  but we don't want to admit points that are obviously not on the surface.    \n    //  For example, if we are looking for value to be close to 0, but value is 1 and the adjacent value is 2,    \n    //  then the delta would be 1 and temp - delta would be 1 - 1 which is zero even though neither of    \n    //  the points is close to zero.    \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n    {   \n    if (u_showIntersection && isOnBoundary)  \n    {    \n        return getIntersectionColor(); \n    }   \n    return getColor(u_radius, v_positionEC);\n}\n\n\nfloat ellipsoidSurfaceFunction(vec3 point)\n{    \n    vec3 scaled = czm_ellipsoidInverseRadii * point;   \n    return dot(scaled, scaled) - 1.0;\n}\n\n\nvoid main()\n{  \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    //vec3 pixDir = normalize(v_position);    \n    float positionX = v_position.x;    \n    float positionY = v_position.y;    \n    float positionZ = v_position.z;    \n    vec3 zDir = vec3(0.0, 0.0, 1.0);    \n    vec3 lineX = vec3(positionX, 0 ,positionZ);    \n    vec3 lineY = vec3(0, positionY, positionZ);    \n    float resX = dot(normalize(lineX), zDir);    \n    if(resX < cos(u_xHalfAngle) - 0.0001)\n    {       \n        discard;  \n    }    \n    float resY = dot(normalize(lineY), zDir);  \n    if(resY < cos(u_yHalfAngle)- 0.0001)\n    {   \n        discard;  \n    }   \n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);  \n    // Occluded by the ellipsoid\n    if (!u_showThroughEllipsoid)\n  {   \n    // Discard if in the ellipsoid   \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.  \n    if (ellipsoidValue < 0.0)  \n    {      \n        discard;  \n    }   \n    // Discard if in the sensor's shadow \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {    \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error.  \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);  \n    out_FragColor = shade(isOnEllipsoid);\n}\n    ";
+export var scanPlaneFS = "\nuniform bool u_showIntersection;\nuniform bool u_showThroughEllipsoid;\nuniform float u_radius;\nuniform float u_xHalfAngle;\nuniform float u_yHalfAngle;\nuniform float u_normalDirection;\nuniform vec4 u_color;\nin vec3 v_position;\nin vec3 v_positionWC;\nin vec3 v_positionEC;\nin vec3 v_normalEC;\nvec4 getColor(float sensorRadius, vec3 pointEC)\n{    \n    czm_materialInput materialInput;    \n    vec3 pointMC = (czm_inverseModelView * vec4(pointEC, 1.0)).xyz;  \n    materialInput.st = sensor2dTextureCoordinates(sensorRadius, pointMC);\n    materialInput.str = pointMC / sensorRadius;    \n    vec3 positionToEyeEC = -v_positionEC;    \n    materialInput.positionToEyeEC = positionToEyeEC;    \n    vec3 normalEC = normalize(v_normalEC);   \n    materialInput.normalEC = u_normalDirection * normalEC;    \n    czm_material material = czm_getMaterial(materialInput);   \n    material.diffuse = u_color.rgb;    \n    material.alpha = u_color.a;    \n    return mix(czm_phong(normalize(positionToEyeEC), material,czm_lightDirectionEC), vec4(material.diffuse, material.alpha), 0.4);\n}\n\nbool isOnBoundary(float value, float epsilon)\n{    \n    float width = getIntersectionWidth();   \n    float tolerance = width * epsilon;\n    #ifdef GL_OES_standard_derivatives    \n    float delta = max(abs(dFdx(value)), abs(dFdy(value)));    \n    float pixels = width * delta;    \n    float temp = abs(value);    \n    // There are a couple things going on here.    \n    //  First we test the value at the current fragment to see if it is within the tolerance.    \n    //  We also want to check if the value of an adjacent pixel is within the tolerance,   \n    //  but we don't want to admit points that are obviously not on the surface.    \n    //  For example, if we are looking for value to be close to 0, but value is 1 and the adjacent value is 2,    \n    //  then the delta would be 1 and temp - delta would be 1 - 1 which is zero even though neither of    \n    //  the points is close to zero.    \n    return temp < tolerance && temp < pixels || (delta < 10.0 * tolerance && temp - delta < tolerance && temp < pixels);\n    #else    \n    return abs(value) < tolerance;\n    #endif\n}\n\n\nvec4 shade(bool isOnBoundary)\n    {   \n    if (u_showIntersection && isOnBoundary)  \n    {    \n        return getIntersectionColor(); \n    }   \n    return getColor(u_radius, v_positionEC);\n}\n\n\nfloat ellipsoidSurfaceFunction(vec3 point)\n{    \n    vec3 scaled = czm_ellipsoidInverseRadii * point;   \n    return dot(scaled, scaled) - 1.0;\n}\n\n\nvoid main()\n{  \n    vec3 sensorVertexWC = czm_model[3].xyz;      // (0.0, 0.0, 0.0) in model coordinates   \n    vec3 sensorVertexEC = czm_modelView[3].xyz;  // (0.0, 0.0, 0.0) in model coordinates   \n    bool isFullSphere = u_xHalfAngle >= czm_pi - 0.0001 && u_yHalfAngle >= czm_pi - 0.0001;\n    //vec3 pixDir = normalize(v_position);    \n    if (!isFullSphere)\n    {\n        float positionX = v_position.x;    \n        float positionY = v_position.y;    \n        float positionZ = v_position.z;    \n        vec3 zDir = vec3(0.0, 0.0, 1.0);    \n        vec3 lineX = vec3(positionX, 0 ,positionZ);    \n        vec3 lineY = vec3(0, positionY, positionZ);    \n        float resX = dot(normalize(lineX), zDir);    \n        if(resX < cos(u_xHalfAngle) - 0.0001)\n        {       \n            discard;  \n        }    \n        float resY = dot(normalize(lineY), zDir);  \n        if(resY < cos(u_yHalfAngle)- 0.0001)\n        {   \n            discard;  \n        }   \n    }\n    float ellipsoidValue = ellipsoidSurfaceFunction(v_positionWC);  \n    // Occluded by the ellipsoid\n    if (!u_showThroughEllipsoid && !isFullSphere)\n  {   \n    // Discard if in the ellipsoid   \n    // PERFORMANCE_IDEA: A coarse check for ellipsoid intersection could be done on the CPU first.  \n    if (ellipsoidValue < 0.0)  \n    {      \n        discard;  \n    }   \n    // Discard if in the sensor's shadow \n    if (inSensorShadow(sensorVertexWC, v_positionWC)) \n    {    \n        discard;  \n    }   \n  }   \n    // Notes: Each surface functions should have an associated tolerance based on the floating point error.  \n    bool isOnEllipsoid = isOnBoundary(ellipsoidValue, czm_epsilon3);  \n    out_FragColor = shade(isOnEllipsoid);\n}\n    ";

package/dist/esm/drawer/index.d.ts

@@ -7,7 +7,7 @@ export declare const MULTI_POINT_SHAPE_TYPES: {
     readonly PINCER_ARROW: "pincerArrow";
     readonly SECTOR: "sector";
 };
-export declare const MULTI_POINT_SHAPES: ("polygon" | "polyline" | "attackArrow" | "pincerArrow" | "sector" | "curve")[];
+export declare const MULTI_POINT_SHAPES: ("polygon" | "polyline" | "attackArrow" | "curve" | "pincerArrow" | "sector")[];
 declare class Drawer implements DrawContext {
     private readonly _mapContext;
     private readonly _drawContext;

package/dist/esm/graphicLayer/BaseSource.d.ts

@@ -15,7 +15,7 @@ export default class BaseSource {
     remove(): void;
     setData(data: any): this | undefined;
     _toDestroy(): void;
-    static analysisSourceType(data: any): "other" | "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "clampedPolygonGrid";
+    static analysisSourceType(data: any): "wkt" | "sourceId" | "sourceInstance" | "geoJson" | "clampedPolygonGrid" | "other";
     static wktToGeoJon(wkt: string): any;
     static geoJsonToGeoCartesian3Array(geoJson: any): any[];
     static handleFeaturePoint(feature: any): any;

package/dist/esm/index.d.ts

@@ -4,6 +4,7 @@ export declare class DeepTwinsEngine3D {
     static Map: any;
     static GroundSkyBox: any;
     static RasterLayer: any;
+    static CustomRasterLayer: any;
     static WmsLayer: any;
     static WmtsLayer: any;
     static ArcGisLayer: any;
@@ -11,6 +12,10 @@ export declare class DeepTwinsEngine3D {
     static FactorLayer: any;
     static DeepTwins: any;
     static WeatherEffects: any;
+    static BaseParticle: any;
+    static FireParticle: any;
+    static SmokeParticle: any;
+    static FountainParticle: any;
     static Drawer: any;
     static Measure: any;
     static Rotate: any;
@@ -30,7 +35,10 @@ export declare class DeepTwinsEngine3D {
     static VolumeCloud: any;
     static Heatmap2d: any;
     static Heatmap3d: any;
+    static DynamicWater: any;
+    static MigrationEffect: any;
     static PointCluster: any;
+    static RadarScan: any;
     static PositionProperty: any;
     static Frustum: any;
     static GridDraw: any;
@@ -61,12 +69,19 @@ export declare class DeepTwinsEngine3D {
     static DistanceDisplayCondition: any;
     static BoundingRectangle: any;
     static SplitDirection: any;
+    static ParticleEmitter: any;
+    static ParticleBurst: any;
+    static CircleEmitter: any;
+    static ConeEmitter: any;
+    static SphereEmitter: any;
     static ImageGlowingMaterialProperty: any;
     static SubmergenceAnalysis: any;
     static SunLightAnalysis: any;
     static KmlDataSource: any;
     static Compass: any;
     static ViewshedAnalysis: any;
+    static LineOfSightAnalysis: any;
+    static TerrainExcavationAnalysis: any;
     static VisitLayer: any;
     static PoiLayer: any;
     static FlightPlanning: any;