easy-three-utils 0.0.350 → 0.0.352

package/cesium/components/index.ts

@@ -1,4 +1,5 @@
 import Timeline from './react/Timeline/index.tsx'
+import TerrainLine from './react/TerrainLine/index.tsx'
 import ProFileEcharts from './react/ProFileEcharts/index.tsx'
 
 const components = {
@@ -6,6 +7,7 @@ const components = {
     },
     react: {
         Timeline,
+        TerrainLine,
         ProFileEcharts
     }
 }

package/cesium/components/react/TerrainLine/index.module.less

@@ -0,0 +1,45 @@
+.slider-box {
+    position: absolute;
+    z-index: 2;
+    bottom: 0;
+    width: 360px;
+    padding: 10px;
+    background: rgba(6, 38, 68, 0.7);
+    border: solid 1px #26a1ff;
+    display: flex;
+    left: calc(50vw - 180px);
+
+    .left-content {
+        color: white;
+        font-size: 13px;
+        writing-mode: vertical-rl;
+        display: flex;
+        justify-content: center;
+        padding-right: 12px;
+    }
+
+    .right-content {
+        flex: 1;
+
+        .time-text {
+            color: white;
+            font-size: 12px;
+            display: flex;
+            justify-content: flex-end;
+            width: 98%;
+            margin-bottom: 11px;
+        }
+
+        .control-btn {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+
+            img {
+                padding: 0 12px;
+                cursor: pointer;
+            }
+        }
+    }
+
+}

package/cesium/components/react/TerrainLine/index.tsx

@@ -0,0 +1,53 @@
+import React, { useEffect, useState } from "react";
+import { Slider, ConfigProvider } from "antd";
+import * as Cesium from "cesium";
+
+import Styles from './index.module.less'
+
+const Timeline: React.FC<{
+    getViewer: () => Cesium.Viewer
+}> = (props) => {
+
+    const { getViewer } = props
+    const [percent, setPercent] = useState(1)
+
+    const theme = {
+        components: {
+            Slider: {
+                railBg: '#bfbfbf',
+                railHoverBg: '#bfbfbf',
+                trackBg: '#176fdbff'
+            }
+        }
+    }
+
+    const onSliderChange = (value: number) => {
+        setPercent(() => value);
+        getViewer().scene.verticalExaggeration = value
+    }
+
+    useEffect(() => {
+        return () => {
+        }
+    }, [])
+
+    return (
+        <ConfigProvider theme={{
+            ...theme
+        }}>
+            <div className={Styles['slider-box']}>
+                <div className={Styles['right-content']}>
+                    <Slider
+                        min={0}
+                        max={10}
+                        step={1}
+                        value={percent}
+                        onChange={(value: number) => onSliderChange(value)}
+                    />
+                </div>
+            </div>
+        </ConfigProvider>
+    )
+}
+
+export default Timeline

package/cesium/index.ts

@@ -15,6 +15,8 @@ type TCesiumUtilsType = {
   measure: ReturnType<typeof hooks.useMeasure>;
   slope: ReturnType<typeof hooks.useSlope>;
   profileAnalysis: ReturnType<typeof hooks.useProfileAnalysis>;
+  viewshedAnalysis: ReturnType<typeof hooks.useViewshedAnalysis>;
+  cloud: ReturnType<typeof hooks.useCloud>;
 }
 
 let config;
@@ -77,7 +79,9 @@ const useCesium = () => {
       })
     } else if (config.terrain.status === cesiumConfigDict.ETerrainStatus.ENABLEDOFFLINE) {
       viewer.imageryLayers.get(0).show = false
-      const terrainProvider = Cesium.CesiumTerrainProvider.fromUrl(config.terrain.config.url)
+      const terrainProvider = Cesium.CesiumTerrainProvider.fromUrl(config.terrain.config.url, {
+        requestVertexNormals: true
+      })
       viewer.terrainProvider = await terrainProvider
     }
 
@@ -100,6 +104,10 @@ const useCesium = () => {
     const profileAnalysis = hooks.useProfileAnalysis(viewer, {
       collection: customCollection.addCollection(hooks.dict.ECollectionWhiteListNames.PROFILEANALYSIS)
     })
+    const viewshedAnalysis = hooks.useViewshedAnalysis(viewer, {
+      collection: customCollection.addCollection(hooks.dict.ECollectionWhiteListNames.VIEWSHEDANALYSIS)
+    })
+    const cloud = hooks.useCloud(viewer)
 
     if (config.controllerStyle === cesiumConfigDict.EControllerStyle.THREE) {
       updateController(viewer)
@@ -113,7 +121,9 @@ const useCesium = () => {
       weather,
       measure,
       slope,
-      profileAnalysis
+      profileAnalysis,
+      viewshedAnalysis,
+      cloud
     })
 
     handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)

package/cesium/plot/usePlot.d.ts

@@ -58,8 +58,10 @@ export interface Plot {
         id: string;
         graphic: Record<'options', GraphicOptions>
     }) => void;
+    
     /** 根据Id删除矢量 */
     removeGraphicById(id: string): void;
+
     /** 删除当前选中的矢量 */
     removeCurrentGraphic(): void;
 

package/cesium/utils/index.ts

@@ -5,6 +5,8 @@ import { useWeather, EWeatherType } from './useWeather'
 import { useMeasure } from './useMeasure'
 import { useSlope } from './useSlope'
 import { useProfileAnalysis } from './useProfileAnalysis'
+import { useViewshedAnalysis } from './useViewshedAnalysis'
+import { useCloud } from './useCloud'
 
 const dict = {
   ECollectionWhiteListNames,
@@ -19,6 +21,8 @@ export {
   useMeasure,
   useSlope,
   useProfileAnalysis,
+  useViewshedAnalysis,
+  useCloud,
 
   dict
 }

package/cesium/utils/useCloud.ts

@@ -1,4 +1,5 @@
 import * as Cesium from 'cesium'
+import { v7 as uuidv7 } from 'uuid'
 
 const useCloud = (viewer: Cesium.Viewer) => {
 
@@ -11,7 +12,7 @@ const useCloud = (viewer: Cesium.Viewer) => {
             return {
                 lon: Cesium.Math.toDegrees(cartographic.longitude),
                 lat: Cesium.Math.toDegrees(cartographic.latitude),
-                height: cartographic.height + h,
+                height: cartographic.height + h
             }
         })
 
@@ -45,7 +46,7 @@ const useCloud = (viewer: Cesium.Viewer) => {
             return inside;
         }
 
-        const points = [];
+        const points = []
         while (points.length < numPoints) {
             const lon = Math.random() * (maxLon - minLon) + minLon
             const lat = Math.random() * (maxLat - minLat) + minLat
@@ -57,20 +58,39 @@ const useCloud = (viewer: Cesium.Viewer) => {
         return points;
     }
 
-    const activateDrawCloud = (cloudWidth: number, cloudLength: number, density: number, points: Cesium.Cartesian3[]) => {
+    const draw = (points: Cesium.Cartesian3[], params: {
+        cloudWidth?: number,
+        cloudLength?: number,
+        density?: number,
+        color?: string
+    } = {
+            cloudWidth: 100000,
+            cloudLength: 100000,
+            density: 0.8,
+            color: 'rgba(255, 255, 255, 0.8)'
+        }) => {
+
+        const options = Object.assign({}, {
+            cloudWidth: 100000,
+            cloudLength: 100000,
+            density: 0.8,
+            color: 'rgba(255, 255, 255, 0.8)'
+        }, params)
+
         const clouds = viewer.scene.primitives.add(new Cesium.CloudCollection())
 
-        // cloudsCollection.push({
-        //   id: 
-        // })
+        cloudsCollection.push({
+            id: uuidv7(),
+            clouds
+        })
 
         const width = Math.max(...points.map(p => p.x)) - Math.min(...points.map(p => p.x))
         const length = Math.max(...points.map(p => p.y)) - Math.min(...points.map(p => p.y))
-        const num = Math.floor(width * length / (cloudLength * cloudWidth)) * density
-        const _points = getRandomPoints(points, num, 5000 + (cloudLength + cloudWidth) / 2)
+        const num = Math.floor(width * length / (options.cloudLength * options.cloudWidth)) * options.density
+        const _points = getRandomPoints(points, num, 5000 + (options.cloudLength + options.cloudWidth) / 2)
 
         _points.forEach(point => {
-            const r = Math.random();
+            const r = Math.random()
             clouds.add({
                 show: true,
                 position: point,
@@ -80,17 +100,12 @@ const useCloud = (viewer: Cesium.Viewer) => {
                     3 + r * 5
                 ),
                 scale: new Cesium.Cartesian2(
-                    cloudWidth * (0.8 + Math.random() * 0.4),
-                    cloudLength * (0.8 + Math.random() * 0.4)
+                    options.cloudWidth * (0.8 + Math.random() * 0.4),
+                    options.cloudLength * (0.8 + Math.random() * 0.4)
                 ),
                 slice: 0.2 + Math.random() * 0.3,
                 brightness: 0.8 + Math.random() * 0.4,
-                color: new Cesium.Color(
-                    0.9 + Math.random() * 0.1,
-                    0.7 + Math.random() * 0.2,
-                    0.6 + Math.random() * 0.2,
-                    0.8
-                ),
+                color: Cesium.Color.fromCssColorString(options.color),
                 noiseDetail: 3.0 + Math.random(),
                 noiseOffset: new Cesium.Cartesian3(
                     Math.random() * 100,
@@ -103,11 +118,20 @@ const useCloud = (viewer: Cesium.Viewer) => {
                 )
             })
         })
-
     }
 
-    const clearAll = () => {
+    const removeAll = () => {
+        cloudsCollection.forEach(item => item.clouds.removeAll())
+        viewer.scene.primitives.removeAll()
+        cloudsCollection = []
+    }
 
+    return {
+        draw,
+        removeAll
     }
+}
 
+export {
+    useCloud
 }

package/cesium/utils/useCustomCollection.ts

@@ -8,7 +8,9 @@ enum ECollectionWhiteListNames {
   MEASURE_HEIGHT = 'measure_height',
   MEASURE_AREA = 'measure_area',
   MEASURE_ALTITUDE = 'measure_altitude',
+
   PROFILEANALYSIS = 'profileAnalysis',
+  VIEWSHEDANALYSIS = 'viewshedAnalysis',
 
   SLOPE = 'slope'
 }
@@ -24,6 +26,7 @@ const useCustomCollection = (viewer: Cesium.Viewer) => {
     'measure_area',
     'measure_altitude',
     'profileAnalysis',
+    'viewshedAnalysis',
     'slope'
   ]
 

package/cesium/utils/useDrawPolygon.ts

@@ -10,7 +10,10 @@ const useDrawPolygon = (viewer: Cesium.Viewer, options: {
   const moveHandler: Cesium.ScreenSpaceEventHandler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)
   let pointPosData: Cesium.Cartesian3[][] = []
 
-  const start = (cb: (geoJSONData: string) => void) => {
+  const start = (cb: (data: {
+    geoJSON: string;
+    points: Cesium.Cartesian3[];
+  }) => void) => {
 
     const points: Cesium.Cartesian3[] = []
 
@@ -69,12 +72,15 @@ const useDrawPolygon = (viewer: Cesium.Viewer, options: {
         return [lon, lat]
       })
 
-      cb(JSON.stringify({
-        "type": "Polygon",
-        "coordinates": [
-          [...coordinates, coordinates[0]]
-        ]
-      }))
+      cb({
+        geoJSON: JSON.stringify({
+          "type": "Polygon",
+          "coordinates": [
+            [...coordinates, coordinates[0]]
+          ]
+        }),
+        points: [...points, points[0]]
+      })
     }, Cesium.ScreenSpaceEventType.RIGHT_CLICK)
   }
 

package/cesium/utils/useProfileAnalysis.ts

@@ -110,13 +110,14 @@ const useProfileAnalysis = (viewer: Cesium.Viewer, options: {
                 },
                 label: {
                     text: textDisance,
-                    font: '18px sans-serif',
-                    fillColor: Cesium.Color.GOLD,
+                    scale: 0.5,
+                    font: "normal 28px MicroSoft YaHei",
                     style: Cesium.LabelStyle.FILL_AND_OUTLINE,
-                    outlineWidth: 2,
-                    verticalOrigin: Cesium.VerticalOrigin.BOTTOM,
-                    pixelOffset: new Cesium.Cartesian2(20, -20),
-                    heightReference: Cesium.HeightReference.NONE
+                    pixelOffset: new Cesium.Cartesian2(0, -30),
+                    outlineWidth: 9,
+                    outlineColor: Cesium.Color.WHITE,
+                    heightReference: Cesium.HeightReference.RELATIVE_TO_GROUND,
+                    disableDepthTestDistance: Number.POSITIVE_INFINITY
                 }
             })
         }) as Cesium.ScreenSpaceEventHandler.PositionedEventCallback, Cesium.ScreenSpaceEventType.LEFT_CLICK)

package/cesium/utils/useViewshedAnalysis.ts

@@ -0,0 +1,303 @@
+import * as Cesium from 'cesium'
+import glsl from "../glsl/viewable"
+
+const useViewshedAnalysis = (viewer: Cesium.Viewer, options: {
+  collection: Cesium.CustomDataSource
+}) => {
+
+  let i = 0
+  let handler: Cesium.ScreenSpaceEventHandler | null = null
+  let viewPosition = null
+  let viewDistance = 100.0
+  let viewHeading = 0.0
+  let viewPitch = 0.0
+  let horizontalViewAngle = 90.0
+  let verticalViewAngle = 60.0
+  let visibleAreaColor = Cesium.Color.GREEN
+  let invisibleAreaColor = Cesium.Color.RED
+  let enabled = true
+  let softShadows = true
+  let size = 2048
+  let lightCamera = null
+  let shadowMap = null
+  let sketch = null
+  let postStage = null
+  let frustumOutline = null
+
+  const add = () => {
+    createLightCamera()
+    createShadowMap()
+    drawFrustumOutline()
+    drawSketch()
+    createPostStage()
+  }
+
+  const update = () => {
+    removeAll()
+    add()
+  }
+
+  const removeAll = () => {
+    stopDraw()
+
+    if (sketch) {
+      options.collection.entities.remove(sketch)
+      sketch = null
+    }
+    if (postStage) {
+      viewer.scene.postProcessStages.remove(postStage)
+      postStage = null
+    }
+    if (frustumOutline) {
+      viewer.scene.primitives.remove(frustumOutline)
+      frustumOutline = null
+    }
+  }
+
+  const updatePosition = (position) => {
+    viewDistance = Cesium.Cartesian3.distance(viewPosition, position)
+    viewHeading = getHeading(viewPosition, position)
+    viewPitch = getPitch(viewPosition, position)
+  }
+
+  const createLightCamera = () => {
+    const camera = new Cesium.Camera(viewer.scene)
+    camera.position = viewPosition
+    camera.frustum.near = viewDistance * 0.001
+    camera.frustum.far = viewDistance
+
+    const hr = Cesium.Math.toRadians(horizontalViewAngle)
+    const vr = Cesium.Math.toRadians(verticalViewAngle)
+    const aspectRatio = (viewDistance * Math.tan(hr / 2) * 2) / (viewDistance * Math.tan(vr / 2) * 2);
+    (camera.frustum as any).aspectRatio = aspectRatio;
+    (camera.frustum as any).fov = Math.max(hr, vr)
+
+    camera.setView({
+      destination: viewPosition,
+      orientation: {
+        heading: Cesium.Math.toRadians(viewHeading || 0),
+        pitch: Cesium.Math.toRadians(viewPitch || 0),
+        roll: 0
+      }
+    })
+    lightCamera = camera
+  }
+
+  const createShadowMap = () => {
+    const shadow = new (Cesium.ShadowMap as any)({
+      context: (viewer.scene as any).context,
+      lightCamera: lightCamera,
+      enabled: enabled,
+      isPointLight: true,
+      pointLightRadius: viewDistance,
+      cascadesEnabled: false,
+      size: size,
+      softShadows: softShadows,
+      normalOffset: false,
+      fromLightSource: false
+    })
+    viewer.scene.shadowMap = shadow
+    shadowMap = shadow
+  }
+
+  const createPostStage = () => {
+    const fs = glsl
+    const cutomPostStage = new Cesium.PostProcessStage({
+      fragmentShader: fs,
+      uniforms: {
+        shadowMap_textureCube: () => {
+          shadowMap.update(Reflect.get(viewer.scene, '_frameState'))
+          return Reflect.get(shadowMap, '_shadowMapTexture')
+        },
+        shadowMap_matrix: () => {
+          shadowMap.update(Reflect.get(viewer.scene, '_frameState'))
+          return Reflect.get(shadowMap, '_shadowMapMatrix')
+        },
+        shadowMap_lightPositionEC: () => {
+          shadowMap.update(Reflect.get(viewer.scene, '_frameState'))
+          return Reflect.get(shadowMap, '_lightPositionEC')
+        },
+        shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: () => {
+          shadowMap.update(Reflect.get(viewer.scene, '_frameState'))
+          const bias = shadowMap._pointBias
+          return Cesium.Cartesian4.fromElements(
+            bias.normalOffsetScale,
+            shadowMap._distance,
+            shadowMap.maximumDistance,
+            0.0,
+            new Cesium.Cartesian4()
+          )
+        },
+        shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: () => {
+          shadowMap.update(Reflect.get(viewer.scene, '_frameState'))
+          const bias = shadowMap._pointBias
+          const texelStepSize = new Cesium.Cartesian2(
+            1.0 / shadowMap._textureSize.x,
+            1.0 / shadowMap._textureSize.y
+          )
+          return Cesium.Cartesian4.fromElements(
+            texelStepSize.x,
+            texelStepSize.y,
+            bias.depthBias,
+            bias.normalShadingSmooth,
+            new Cesium.Cartesian4()
+          )
+        },
+        camera_projection_matrix: lightCamera.frustum.projectionMatrix,
+        camera_view_matrix: lightCamera.viewMatrix,
+        helsing_viewDistance: () => viewDistance,
+        helsing_visibleAreaColor: visibleAreaColor,
+        helsing_invisibleAreaColor: invisibleAreaColor
+      }
+    })
+    postStage = viewer.scene.postProcessStages.add(cutomPostStage)
+  }
+
+  const drawFrustumOutline = () => {
+    const direction = lightCamera.directionWC
+    const up = lightCamera.upWC
+    const right = Cesium.Cartesian3.negate(lightCamera.rightWC, new Cesium.Cartesian3())
+    const rotation = Cesium.Matrix3.setColumn(
+      new Cesium.Matrix3(),
+      0,
+      right,
+      new Cesium.Matrix3()
+    )
+    Cesium.Matrix3.setColumn(rotation, 1, up, rotation)
+    Cesium.Matrix3.setColumn(rotation, 2, direction, rotation)
+    const orientation = Cesium.Quaternion.fromRotationMatrix(rotation, new Cesium.Quaternion())
+
+    const instance = new Cesium.GeometryInstance({
+      geometry: new Cesium.FrustumOutlineGeometry({
+        frustum: lightCamera.frustum,
+        origin: viewPosition,
+        orientation
+      }),
+      attributes: {
+        color: Cesium.ColorGeometryInstanceAttribute.fromColor(Cesium.Color.YELLOWGREEN),
+        show: new Cesium.ShowGeometryInstanceAttribute(true)
+      }
+    })
+
+    frustumOutline = viewer.scene.primitives.add(
+      new Cesium.Primitive({
+        geometryInstances: [instance],
+        appearance: new Cesium.PerInstanceColorAppearance({
+          flat: true,
+          translucent: false
+        })
+      })
+    )
+  }
+
+  const drawSketch = () => {
+    sketch = options.collection.entities.add({
+      name: 'sketch',
+      position: viewPosition,
+      orientation: new Cesium.CallbackProperty(() => {
+        return Cesium.Transforms.headingPitchRollQuaternion(
+          viewPosition,
+          Cesium.HeadingPitchRoll.fromDegrees(
+            viewHeading - horizontalViewAngle,
+            viewPitch,
+            0.5
+          )
+        )
+      }, false),
+      ellipsoid: {
+        radii: new Cesium.CallbackProperty(
+          () => new Cesium.Cartesian3(viewDistance, viewDistance, viewDistance),
+          false
+        ),
+        innerRadii: new Cesium.Cartesian3(2.0, 2.0, 2.0),
+        minimumClock: Cesium.Math.toRadians(-horizontalViewAngle / 2),
+        maximumClock: Cesium.Math.toRadians(horizontalViewAngle / 2),
+        minimumCone: Cesium.Math.toRadians(verticalViewAngle + 7.75),
+        maximumCone: Cesium.Math.toRadians(180 - verticalViewAngle - 7.75),
+        fill: false,
+        outline: true,
+        subdivisions: 256,
+        stackPartitions: 64,
+        slicePartitions: 64,
+        outlineColor: Cesium.Color.YELLOWGREEN
+      }
+    })
+  }
+
+  const getHeading = (from, to) => {
+    const result = new Cesium.Cartesian3()
+    const matrix4 = Cesium.Matrix4.inverse(Cesium.Transforms.eastNorthUpToFixedFrame(from), new Cesium.Matrix4())
+    Cesium.Matrix4.multiplyByPoint(matrix4, to, result)
+    Cesium.Cartesian3.normalize(result, result)
+    return Cesium.Math.toDegrees(Math.atan2(result.x, result.y))
+  }
+
+  const getPitch = (from, to) => {
+    const result = new Cesium.Cartesian3()
+    const matrix4 = Cesium.Matrix4.inverse(Cesium.Transforms.eastNorthUpToFixedFrame(from), new Cesium.Matrix4())
+    Cesium.Matrix4.multiplyByPoint(matrix4, to, result)
+    Cesium.Cartesian3.normalize(result, result)
+    return Cesium.Math.toDegrees(Math.asin(result.z))
+  }
+
+  const leftClickEvent = () => {
+    handler.setInputAction(((movement) => {
+      i++
+      if (i === 1) {
+        let startPosition = viewer.scene.pickPosition(movement.position)
+        if (!startPosition) return
+        viewPosition = startPosition
+        mouseMoveEvent()
+      }
+      if (i === 2) {
+        i = 0
+        let endPosition = viewer.scene.pickPosition(movement.position)
+        updatePosition(endPosition)
+        update()
+        stopDraw()
+      }
+    }) as Cesium.ScreenSpaceEventHandler.PositionedEventCallback, Cesium.ScreenSpaceEventType.LEFT_CLICK)
+  }
+
+  const mouseMoveEvent = () => {
+    handler.setInputAction(((movement) => {
+      const endPosition = viewer.scene.pickPosition(movement.endPosition)
+      if (!endPosition) return
+      updatePosition(endPosition)
+      if (!sketch) {
+        drawSketch()
+      }
+    }) as Cesium.ScreenSpaceEventHandler.MotionEventCallback, Cesium.ScreenSpaceEventType.MOUSE_MOVE)
+  }
+
+  const draw = () => {
+    if (handler) {
+      console.log('请先结束上次测量！')
+      return
+    }
+    handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas)
+    leftClickEvent()
+    viewer.scene.camera.frustum.near = 100.0
+    viewer.scene.logarithmicDepthBuffer = true
+    viewer.scene.globe.enableLighting = false
+    viewer.scene.globe.showGroundAtmosphere = false
+  }
+
+  const stopDraw = () => {
+    if (handler) {
+      handler.removeInputAction(Cesium.ScreenSpaceEventType.LEFT_CLICK)
+      handler.removeInputAction(Cesium.ScreenSpaceEventType.MOUSE_MOVE)
+      handler.destroy()
+      handler = null
+    }
+  }
+
+  return {
+    draw,
+    removeAll
+  }
+}
+
+export {
+  useViewshedAnalysis
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-three-utils",
-  "version": "0.0.350",
+  "version": "0.0.352",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -8,5 +8,5 @@
   "author": "",
   "license": "ISC",
   "types": "./index.d.ts",
-  "description": "更新j标完成绘制回显功能和按照id删除功能"
+  "description": "新增区域云和地形测量"
 }

package/cesium/utils/useDrawTools.ts

@@ -1,50 +0,0 @@
-import * as Cesium from 'cesium'
-
-enum ECollectionWhiteListNames {
-    POLYGON = 'polygon',
-    POLYGON_NODE = 'polygon_node'
-}
-
-const useCustomCollection = (viewer: Cesium.Viewer) => {
-
-    let collectionNames: string[] = ([])
-    let whiteList: string[] = ['polygon', 'polygon_node']
-
-    const addCollection = (name: string) => {
-        const index = collectionNames.findIndex(item => item === name)
-        if (index !== -1) return
-        collectionNames.push(name)
-        const dataSource = new Cesium.CustomDataSource(name);
-        viewer.dataSources.add(dataSource);
-        return dataSource
-    }
-
-    const getCollection = (name: ECollectionWhiteListNames | string) => {
-        const collection = viewer.dataSources.getByName(name)
-        if (collection.length) {
-            return collection[0]
-        }
-    }
-
-    const removeCollection = (name: string) => {
-        const collection = viewer.dataSources.getByName(name)
-        viewer.dataSources.remove(collection[0], false)
-        collectionNames = collectionNames.filter(item => item !== name && !whiteList.includes(item))
-    }
-
-    const getCollectionNames = () => {
-        return collectionNames.filter(item => !whiteList.includes(item))
-    }
-
-    return {
-        addCollection,
-        getCollection,
-        removeCollection,
-        getCollectionNames
-    }
-}
-
-export {
-    ECollectionWhiteListNames,
-    useCustomCollection
-}

package/cesium/utils/useViewShed.ts

@@ -1,199 +0,0 @@
-import glsl from "../glsl/viewable";
-import * as Cesium from 'cesium'
-
-export default class viewShader {
-  constructor(viewer, options) {
-    this.viewer = viewer;
-    this.viewPosition = options.viewPosition;
-    this.viewPositionEnd = options.viewPositionEnd;
-    this.viewDistance = this.viewPositionEnd ? Cesium.Cartesian3.distance(this.viewPosition, this.viewPositionEnd) : (options.viewDistance || 100.0);
-    this.viewHeading = this.viewPositionEnd ? this.getHeading(this.viewPosition, this.viewPositionEnd) : (options.viewHeading || 0.0);
-    this.viewPitch = this.viewPositionEnd ? this.getPitch(this.viewPosition, this.viewPositionEnd) : (options.viewPitch || 0.0);
-    this.horizontalViewAngle = options.horizontalViewAngle || 90.0;
-    this.verticalViewAngle = options.verticalViewAngle || 60.0;
-    this.visibleAreaColor = options.visibleAreaColor || Cesium.Color.GREEN;
-    this.invisibleAreaColor = options.invisibleAreaColor || Cesium.Color.RED;
-    this.enabled = (typeof options.enabled === "boolean") ? options.enabled : true;
-    this.softShadows = (typeof options.softShadows === "boolean") ? options.softShadows : true;
-    this.size = options.size || 2048;
-
-    this.update();
-  }
-
-  add() {
-    this.createLightCamera();
-    this.createShadowMap();
-    this.createPostStage();
-    this.drawSketch();
-  }
-
-  update() {
-    this.clear();
-    this.add();
-  }
-
-  updatePosition(viewPositionEnd) {
-    this.viewPositionEnd = viewPositionEnd
-    this.viewDistance = Cesium.Cartesian3.distance(this.viewPosition, this.viewPositionEnd)
-    this.viewHeading = this.getHeading(this.viewPosition, this.viewPositionEnd)
-    this.viewPitch = this.getPitch(this.viewPosition, this.viewPositionEnd)
-  }
-
-  clear() {
-    if (this.sketch) {
-      this.viewer.entities.removeById(this.sketch.id);
-      this.sketch = null;
-    }
-    if (this.postStage) {
-      this.viewer.scene.postProcessStages.remove(this.postStage);
-      this.postStage = null;
-    }
-  }
-
-  createLightCamera() {
-    this.lightCamera = new Cesium.Camera(this.viewer.scene);
-    this.lightCamera.position = this.viewPosition;
-    if (this.viewDistance == 0) {
-      this.viewDistance = 1
-    }
-    this.lightCamera.frustum.near = this.viewDistance * 0.001;
-    this.lightCamera.frustum.far = this.viewDistance;
-    const hr = Cesium.Math.toRadians(this.horizontalViewAngle);
-    const vr = Cesium.Math.toRadians(this.verticalViewAngle);
-    const aspectRatio =
-      (this.viewDistance * Math.tan(hr / 2) * 2) /
-      (this.viewDistance * Math.tan(vr / 2) * 2);
-    this.lightCamera.frustum.aspectRatio = aspectRatio;
-    if (hr > vr) {
-      this.lightCamera.frustum.fov = hr;
-    } else {
-      this.lightCamera.frustum.fov = vr;
-    }
-    this.lightCamera.setView({
-      destination: this.viewPosition,
-      orientation: {
-        heading: Cesium.Math.toRadians(this.viewHeading || 0),
-        pitch: Cesium.Math.toRadians(this.viewPitch || 0),
-        roll: 0
-      }
-    });
-  }
-
-  createShadowMap() {
-    this.shadowMap = new Cesium.ShadowMap({
-      context: (this.viewer.scene).context,
-      lightCamera: this.lightCamera,
-      enabled: this.enabled,
-      isPointLight: true,
-      pointLightRadius: this.viewDistance,
-      cascadesEnabled: false,
-      size: this.size,
-      softShadows: this.softShadows,
-      normalOffset: false,
-      fromLightSource: false
-    });
-    this.viewer.scene.shadowMap = this.shadowMap;
-  }
-
-  createPostStage() {
-    const postStage = new Cesium.PostProcessStage({
-      fragmentShader: glsl,
-      uniforms: {
-        shadowMap_textureCube: () => {
-          this.shadowMap.update(Reflect.get(this.viewer.scene, "_frameState"));
-          return Reflect.get(this.shadowMap, "_shadowMapTexture");
-        },
-        shadowMap_matrix: () => {
-          this.shadowMap.update(Reflect.get(this.viewer.scene, "_frameState"));
-          return Reflect.get(this.shadowMap, "_shadowMapMatrix");
-        },
-        shadowMap_lightPositionEC: () => {
-          this.shadowMap.update(Reflect.get(this.viewer.scene, "_frameState"));
-          return Reflect.get(this.shadowMap, "_lightPositionEC");
-        },
-        shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: () => {
-          this.shadowMap.update(Reflect.get(this.viewer.scene, "_frameState"));
-          const bias = this.shadowMap._pointBias;
-          return Cesium.Cartesian4.fromElements(
-            bias.normalOffsetScale,
-            this.shadowMap._distance,
-            this.shadowMap.maximumDistance,
-            0.0,
-            new Cesium.Cartesian4()
-          );
-        },
-        shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: () => {
-          this.shadowMap.update(Reflect.get(this.viewer.scene, "_frameState"));
-          const bias = this.shadowMap._pointBias;
-          const scratchTexelStepSize = new Cesium.Cartesian2();
-          const texelStepSize = scratchTexelStepSize;
-          texelStepSize.x = 1.0 / this.shadowMap._textureSize.x;
-          texelStepSize.y = 1.0 / this.shadowMap._textureSize.y;
-
-          return Cesium.Cartesian4.fromElements(
-            texelStepSize.x,
-            texelStepSize.y,
-            bias.depthBias,
-            bias.normalShadingSmooth,
-            new Cesium.Cartesian4()
-          );
-        },
-        camera_projection_matrix: this.lightCamera.frustum.projectionMatrix,
-        camera_view_matrix: this.lightCamera.viewMatrix,
-        helsing_viewDistance: () => {
-          return this.viewDistance;
-        },
-        helsing_visibleAreaColor: this.visibleAreaColor,
-        helsing_invisibleAreaColor: this.invisibleAreaColor,
-      }
-    });
-
-    this.postStage = this.viewer.scene.postProcessStages.add(postStage);
-  }
-
-  drawSketch() {
-    this.sketch = this.viewer.entities.add({
-      name: 'sketch',
-      position: this.viewPosition,
-      orientation: Cesium.Transforms.headingPitchRollQuaternion(
-        this.viewPosition,
-        Cesium.HeadingPitchRoll.fromDegrees(this.viewHeading - this.horizontalViewAngle, this.viewPitch, 0.0)
-      ),
-      ellipsoid: {
-        radii: new Cesium.Cartesian3(
-          this.viewDistance,
-          this.viewDistance,
-          this.viewDistance
-        ),
-        minimumClock: Cesium.Math.toRadians(-this.horizontalViewAngle / 2),
-        maximumClock: Cesium.Math.toRadians(this.horizontalViewAngle / 2),
-        minimumCone: Cesium.Math.toRadians(this.verticalViewAngle + 7.75),
-        maximumCone: Cesium.Math.toRadians(180 - this.verticalViewAngle - 7.75),
-        fill: false,
-        outline: true,
-        subdivisions: 256,
-        stackPartitions: 64,
-        slicePartitions: 64,
-        outlineColor: Cesium.Color.YELLOWGREEN
-      }
-    });
-  }
-
-  getHeading(fromPosition, toPosition) {
-    let finalPosition = new Cesium.Cartesian3();
-    let matrix4 = Cesium.Transforms.eastNorthUpToFixedFrame(fromPosition);
-    Cesium.Matrix4.inverse(matrix4, matrix4);
-    Cesium.Matrix4.multiplyByPoint(matrix4, toPosition, finalPosition);
-    Cesium.Cartesian3.normalize(finalPosition, finalPosition);
-    return Cesium.Math.toDegrees(Math.atan2(finalPosition.x, finalPosition.y));
-  }
-
-  getPitch(fromPosition, toPosition) {
-    let finalPosition = new Cesium.Cartesian3();
-    let matrix4 = Cesium.Transforms.eastNorthUpToFixedFrame(fromPosition);
-    Cesium.Matrix4.inverse(matrix4, matrix4);
-    Cesium.Matrix4.multiplyByPoint(matrix4, toPosition, finalPosition);
-    Cesium.Cartesian3.normalize(finalPosition, finalPosition);
-    return Cesium.Math.toDegrees(Math.asin(finalPosition.z));
-  }
-}