easy-three-utils 0.0.350 → 0.0.351

package/cesium/index.ts

@@ -15,6 +15,7 @@ type TCesiumUtilsType = {
   measure: ReturnType<typeof hooks.useMeasure>;
   slope: ReturnType<typeof hooks.useSlope>;
   profileAnalysis: ReturnType<typeof hooks.useProfileAnalysis>;
+  viewshedAnalysis: ReturnType<typeof hooks.useViewshedAnalysis>;
 }
 
 let config;
@@ -100,6 +101,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)
+    })
+
 
     if (config.controllerStyle === cesiumConfigDict.EControllerStyle.THREE) {
       updateController(viewer)
@@ -113,7 +118,8 @@ const useCesium = () => {
       weather,
       measure,
       slope,
-      profileAnalysis
+      profileAnalysis,
+      viewshedAnalysis
     })
 
     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,7 @@ import { useWeather, EWeatherType } from './useWeather'
 import { useMeasure } from './useMeasure'
 import { useSlope } from './useSlope'
 import { useProfileAnalysis } from './useProfileAnalysis'
+import { useViewshedAnalysis } from './useViewshedAnalysis'
 
 const dict = {
   ECollectionWhiteListNames,
@@ -19,6 +20,7 @@ export {
   useMeasure,
   useSlope,
   useProfileAnalysis,
+  useViewshedAnalysis,
 
   dict
 }

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/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.351",
   "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));
-  }
-}