fix: remove the original fixed ellipsoid parameters

Ellipsoid parameters default to viewer.scene.globe.ellipsoid

packages/composables/use-events/index.ts

@@ -123,12 +123,12 @@ export default function (props, vcInstance: VcComponentInternalInstance, logger)
     }
 
     let intersection
-    const scene = viewer.scene
+    const scene = viewer.scene as Cesium.Scene
     if (scene.mode === Cesium.SceneMode.SCENE3D) {
       const ray = scene.camera.getPickRay(position)
       intersection = scene.globe.pick(ray, scene)
     } else {
-      intersection = scene.camera.pickEllipsoid(position, Cesium.Ellipsoid.WGS84)
+      intersection = scene.camera.pickEllipsoid(position, scene.globe.ellipsoid)
     }
 
     let button = -1

packages/controls/compass/use-compass.ts

@@ -123,7 +123,7 @@ export default function(props, { emit }, vcInstance: VcComponentInternalInstance
         status: 'start',
         target: e.currentTarget
       })
-    const rotateFrame = Transforms.eastNorthUpToFixedFrame(center, Ellipsoid.WGS84)
+    const rotateFrame = Transforms.eastNorthUpToFixedFrame(center, viewer.scene.globe.ellipsoid)
     const lookVector = Cartesian3.subtract(center, camera.position, new Cartesian3())
     const flight = CameraFlightPath.createTween(scene, {
       destination: Matrix4.multiplyByPoint(rotateFrame, new Cartesian3(0.0, 0.0, Cartesian3.magnitude(lookVector)), new Cartesian3()),
@@ -178,7 +178,7 @@ export default function(props, { emit }, vcInstance: VcComponentInternalInstance
   }
 
   const orbit = (compassElement: HTMLElement, cursorVector: Cesium.Cartesian2) => {
-    const { Cartesian2, Cartesian3, defined, getTimestamp, Math: CesiumMath, Matrix4, Ellipsoid, Ray, SceneMode, Transforms } = Cesium
+    const { Cartesian2, Cartesian3, defined, getTimestamp, Math: CesiumMath, Matrix4, Ray, SceneMode, Transforms } = Cesium
     let scene = vcInstance.viewer.scene
     let camera = scene.camera
     const sscc = scene.screenSpaceCameraController
@@ -244,10 +244,10 @@ export default function(props, { emit }, vcInstance: VcComponentInternalInstance
 
     const center = scene.globe.pick(ray, scene, centerScratch)
     if (!defined(center)) {
-      orbitFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, Ellipsoid.WGS84, newTransformScratch)
+      orbitFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, scene.globe.ellipsoid, newTransformScratch)
       orbitIsLook = true
     } else {
-      orbitFrame = Transforms.eastNorthUpToFixedFrame(center, Ellipsoid.WGS84, newTransformScratch)
+      orbitFrame = Transforms.eastNorthUpToFixedFrame(center, scene.globe.ellipsoid, newTransformScratch)
       orbitIsLook = false
     }
 
@@ -362,7 +362,7 @@ export default function(props, { emit }, vcInstance: VcComponentInternalInstance
     document.removeEventListener('touchmove', rotateMouseMoveFunction, false)
     document.removeEventListener('mouseup', rotateMouseUpFunction, false)
     document.removeEventListener('touchend', rotateMouseUpFunction, false)
-    const { Cartesian2, Cartesian3, defined, Math: CesiumMath, Matrix4, Ellipsoid, Ray, Transforms } = Cesium
+    const { Cartesian2, Cartesian3, defined, Math: CesiumMath, Matrix4, Ray, Transforms } = Cesium
     rotateMouseMoveFunction = undefined
     rotateMouseUpFunction = undefined
 
@@ -386,10 +386,10 @@ export default function(props, { emit }, vcInstance: VcComponentInternalInstance
 
     const viewCenter = scene.globe.pick(ray, scene, centerScratch)
     if (!defined(viewCenter)) {
-      rotateFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, Ellipsoid.WGS84, newTransformScratch)
+      rotateFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, scene.globe.ellipsoid, newTransformScratch)
       rotateIsLook = true
     } else {
-      rotateFrame = Transforms.eastNorthUpToFixedFrame(viewCenter, Ellipsoid.WGS84, newTransformScratch)
+      rotateFrame = Transforms.eastNorthUpToFixedFrame(viewCenter, scene.globe.ellipsoid, newTransformScratch)
       rotateIsLook = false
     }
 

packages/controls/my-location/index.ts

@@ -225,7 +225,7 @@ export default defineComponent({
       const longitude = position.lng
       const latitude = position.lat
       const address = position.address
-      const { Cartesian3, Rectangle, Ellipsoid, sampleTerrain, defined, SceneMode } = Cesium
+      const { Cartesian3, Rectangle, sampleTerrain, defined, SceneMode } = Cesium
       const { viewer } = $services
       datasource.entities.removeAll()
       const myPositionEntity = datasource.entities.add({
@@ -283,7 +283,7 @@ export default defineComponent({
       const camera = viewer.scene.camera
       // Work out the destination that the camera would naturally fly to
       const destinationCartesian = camera.getRectangleCameraCoordinates(rectangle)
-      const destination = Ellipsoid.WGS84.cartesianToCartographic(destinationCartesian)
+      const destination = viewer.scene.globe.ellipsoid.cartesianToCartographic(destinationCartesian)
       const terrainProvider = viewer.scene.globe.terrainProvider
       const level = props.level // A sufficiently coarse tile level that still has approximately accurate height
       const positions = [Rectangle.center(rectangle)]
@@ -296,8 +296,7 @@ export default defineComponent({
           latitude: destination.latitude,
           height: destination.height + results[0].height
         }
-        // const finalDestination = Ellipsoid.WGS84.cartographicToCartesian(finalDestinationCartographic)
-        const finalDestination = Ellipsoid.WGS84.cartographicToCartesian(finalDestinationCartographic)
+        const finalDestination = viewer.scene.globe.ellipsoid.cartographicToCartesian(finalDestinationCartographic)
         listener &&
           ctx.emit('locationEvt', {
             type: 'zoomIn',

packages/controls/navigation-sm/use-compass.ts

@@ -118,7 +118,7 @@ export default function (props, { emit }, vcInstance: VcComponentInternalInstanc
     }
   }
   const handleDoubleClick = e => {
-    const { Cartesian2, Cartesian3, defined, Ellipsoid, Matrix4, Ray, SceneMode, Transforms } = Cesium
+    const { Cartesian2, Cartesian3, defined, Matrix4, Ray, SceneMode, Transforms } = Cesium
     const { viewer } = vcInstance
     const scene = viewer.scene
     const camera = scene.camera
@@ -162,7 +162,7 @@ export default function (props, { emit }, vcInstance: VcComponentInternalInstanc
         camera: viewer.camera,
         status: 'start'
       })
-    const rotateFrame = Transforms.eastNorthUpToFixedFrame(center, Ellipsoid.WGS84)
+    const rotateFrame = Transforms.eastNorthUpToFixedFrame(center, viewer.scene.globe.ellipsoid)
     const lookVector = Cartesian3.subtract(center, camera.position, new Cartesian3())
     const flight = CameraFlightPath.createTween(scene, {
       destination: Matrix4.multiplyByPoint(rotateFrame, new Cartesian3(0.0, 0.0, Cartesian3.magnitude(lookVector)), new Cartesian3()),
@@ -368,7 +368,7 @@ export default function (props, { emit }, vcInstance: VcComponentInternalInstanc
     document.removeEventListener('touchmove', rotateMouseMoveFunction, false)
     document.removeEventListener('mouseup', rotateMouseUpFunction, false)
     document.removeEventListener('touchend', rotateMouseUpFunction, false)
-    const { Cartesian2, Cartesian3, defined, Math: CesiumMath, Matrix4, Ellipsoid, Ray, Transforms } = Cesium
+    const { Cartesian2, Cartesian3, defined, Math: CesiumMath, Matrix4, Ray, Transforms } = Cesium
     rotateMouseMoveFunction = undefined
     rotateMouseUpFunction = undefined
 
@@ -392,10 +392,10 @@ export default function (props, { emit }, vcInstance: VcComponentInternalInstanc
 
     const viewCenter = scene.globe.pick(ray, scene, centerScratch)
     if (!defined(viewCenter)) {
-      rotateFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, Ellipsoid.WGS84, newTransformScratch)
+      rotateFrame = Transforms.eastNorthUpToFixedFrame(camera.positionWC, scene.globe.ellipsoid, newTransformScratch)
       rotateIsLook = true
     } else {
-      rotateFrame = Transforms.eastNorthUpToFixedFrame(viewCenter, Ellipsoid.WGS84, newTransformScratch)
+      rotateFrame = Transforms.eastNorthUpToFixedFrame(viewCenter, scene.globe.ellipsoid, newTransformScratch)
       rotateIsLook = false
     }
 

packages/controls/selection-indicator/Feature.ts

@@ -77,8 +77,7 @@ class Feature {
     return feature
   }
 
-  static fromImageryLayerFeature (imageryFeature) {
-    const { Ellipsoid } = Cesium
+  static fromImageryLayerFeature (imageryFeature, viewer: Cesium.Viewer) {
     const feature = new Feature({
       id: imageryFeature.name
     })
@@ -88,7 +87,7 @@ class Feature {
     feature.data = imageryFeature.data
 
     feature.imageryLayer = imageryFeature.imageryLayer
-    feature.position = Ellipsoid.WGS84.cartographicToCartesian(
+    feature.position = viewer.scene.globe.ellipsoid.cartographicToCartesian(
       imageryFeature.position
     )
     feature.coords = imageryFeature.coords

packages/controls/selection-indicator/use-selection-indicatior.ts

@@ -89,15 +89,15 @@ export default function (instance: VcComponentInternalInstance, props, $services
   }
 
   const pickFromScreenPosition = (screenPosition: Cesium.Cartesian2) => {
-    const { Ellipsoid, defined } = Cesium
+    const { defined } = Cesium
     const { viewer } = $services
     const scene = viewer.scene
     const pickRay = scene.camera.getPickRay(screenPosition)
     const pickPosition = scene.globe.pick(pickRay, scene)
     if (!defined(pickPosition)) {
       return
     }
-    const pickPositionCartographic = Ellipsoid.WGS84.cartesianToCartographic(
+    const pickPositionCartographic = scene.globe.ellipsoid.cartesianToCartographic(
       pickPosition
     )
 
@@ -116,7 +116,8 @@ export default function (instance: VcComponentInternalInstance, props, $services
       [pickRasterPromise],
       undefined,
       pickPositionCartographic.height,
-      false
+      false,
+      viewer
     )
     pickedFeatures.value = result
   }
@@ -128,8 +129,9 @@ export default function (instance: VcComponentInternalInstance, props, $services
     featurePromises,
     imageryLayers,
     defaultHeight,
-    ignoreSplitter) => {
-    const { Ellipsoid, defined, defaultValue, when } = Cesium
+    ignoreSplitter,
+    viewer) => {
+    const { defined, defaultValue, when } = Cesium
     ignoreSplitter = defaultValue(ignoreSplitter, false)
     const result = new PickedFeatures()
 
@@ -155,7 +157,7 @@ export default function (instance: VcComponentInternalInstance, props, $services
                   }
 
                   if (!defined(feature.position)) {
-                    feature.position = Ellipsoid.WGS84.cartesianToCartographic(
+                    feature.position = viewer.scene.globe.ellipsoid.cartesianToCartographic(
                       pickPosition
                     )
                   }
@@ -168,7 +170,7 @@ export default function (instance: VcComponentInternalInstance, props, $services
                   ) {
                     feature.position.height = defaultHeight
                   }
-                  return Feature.fromImageryLayerFeature(feature)
+                  return Feature.fromImageryLayerFeature(feature, viewer)
                 }.bind(this)
               )
 

packages/controls/zoom-control/use-zoom-control.ts

@@ -174,16 +174,16 @@ export default function (props, { emit }, vcInstance: VcComponentInternalInstanc
     }
   }
 
-  const getCameraFocus = scene => {
-    const { defined, Ellipsoid, IntersectionTests, Ray } = Cesium
+  const getCameraFocus = (scene: Cesium.Scene) => {
+    const { defined, IntersectionTests, Ray } = Cesium
     const ray = new Ray(scene.camera.positionWC, scene.camera.directionWC)
-    const intersections = IntersectionTests.rayEllipsoid(ray, Ellipsoid.WGS84)
+    const intersections = IntersectionTests.rayEllipsoid(ray, scene.globe.ellipsoid)
     if (defined(intersections)) {
       return Ray.getPoint(ray, intersections.start)
     }
     // Camera direction is not pointing at the globe, so use the ellipsoid horizon point as
     // the focal point.
-    return IntersectionTests.grazingAltitudeLocation(ray, Ellipsoid.WGS84)
+    return IntersectionTests.grazingAltitudeLocation(ray, scene.globe.ellipsoid)
   }
 
   return {

packages/drawings/src/rectangle/index.ts

@@ -3,7 +3,7 @@ import { VcComponentInternalInstance, VcComponentPublicInstance } from '@vue-ces
 import { useCommon } from '@vue-cesium/composables'
 import { VcPrimitive, VcPrimitiveGround, VcPrimitiveGroundPolyline } from '@vue-cesium/primitives'
 import { VcCollectionPoint, VcCollectionPrimitive } from '@vue-cesium/primitive-collections'
-import { makeMaterial, setViewerCursor, restoreViewerCursor, getGeodesicDistance, getHeadingPitchRoll, getPolylineSegmentEndpoint } from '@vue-cesium/utils/cesium-helpers'
+import { makeMaterial, setViewerCursor, restoreViewerCursor } from '@vue-cesium/utils/cesium-helpers'
 import { DrawStatus } from '@vue-cesium/shared'
 import VcInstanceGeometry from '@vue-cesium/geometry-instance'
 import { VcGeometryPolygon, VcGeometryPolyline, VcGeometryPolylineGround } from '@vue-cesium/geometries'

packages/drawings/src/regular-polygon/index.ts

@@ -62,9 +62,9 @@ export default defineComponent({
 
           !props.clampToGround && (endCartographic.height = startCartographic.height)
           positions.push(Cartographic.toCartesian(endCartographic))
-          const distance = getGeodesicDistance(startPosition, endPosition)
+          const distance = getGeodesicDistance(startPosition, endPosition, $services.viewer.scene.globe.ellipsoid)
           for (let i = 0; i < props.edge - 1; i++) {
-            const position = getPolylineSegmentEndpoint(startPosition, hpr[0] += Math.PI * 2 / props.edge, distance)
+            const position = getPolylineSegmentEndpoint(startPosition, hpr[0] += Math.PI * 2 / props.edge, distance, $services.viewer.scene.globe.ellipsoid)
             positions.push(position)
           }
 

packages/measurements/src/area/index.ts

@@ -51,7 +51,7 @@ export default defineComponent({
         for (let i = 0; i < positions.length - 1; i++) {
           let s = 0
           if (props.polylineOpts.arcType === 0) {
-            s = getGeodesicDistance(positions[i], positions[i + 1])
+            s = getGeodesicDistance(positions[i], positions[i + 1], $services.viewer.scene.globe.ellipsoid)
           } else {
             s = Cartesian3.distance(positions[i], positions[i + 1])
           }

packages/measurements/src/distance/index.ts

@@ -48,7 +48,8 @@ export default defineComponent({
       polylines.value.forEach((polylineSegment, index) => {
         const startPosition = polylineSegment.positions[0]
         const endPosition = polylineSegment.positions[1]
-        const distance = props.polylineOpts.arcType === 0 ? Cartesian3.distance(startPosition, endPosition) : getGeodesicDistance(startPosition, endPosition)
+        const distance = props.polylineOpts.arcType === 0 ? Cartesian3.distance(startPosition, endPosition)
+          : getGeodesicDistance(startPosition, endPosition, $services.viewer.scene.globe.ellipsoid)
         const labelPosition = Cartesian3.midpoint(startPosition, endPosition, {} as any)
         const polyline: DistanceMeasurementPolylineSegment = {
           ...polylineSegment,

packages/measurements/src/horizontal/index.ts

@@ -58,7 +58,7 @@ export default defineComponent({
         for (let i = 0; i < positions.length - 1; i++) {
           let s = 0
           if (props.polylineOpts.arcType === 0) {
-            s = getGeodesicDistance(positions[i], positions[i + 1])
+            s = getGeodesicDistance(positions[i], positions[i + 1], $services.viewer.scene.globe.ellipsoid)
           } else {
             s = Cartesian3.distance(positions[i], positions[i + 1])
           }

packages/measurements/src/polyline/index.ts

@@ -50,7 +50,7 @@ export default defineComponent({
         for (let i = 0; i < positions.length - 1; i++) {
           let s = 0
           if (props.polylineOpts.arcType === 0) {
-            s = getGeodesicDistance(positions[i], positions[i + 1])
+            s = getGeodesicDistance(positions[i], positions[i + 1], $services.viewer.scene.globe.ellipsoid)
           } else {
             s = Cartesian3.distance(positions[i], positions[i + 1])
           }

packages/utils/cesium-helpers.ts

@@ -820,10 +820,10 @@ export function flyToCamera (viewer: Cesium.Viewer, camera: CameraOption, option
   })
 }
 
-export function getGeodesicDistance (start: Cesium.Cartesian3, end: Cesium.Cartesian3) {
-  const { Ellipsoid, EllipsoidGeodesic } = Cesium
-  const pickedPointCartographic = Ellipsoid.WGS84.cartesianToCartographic(start)
-  const lastPointCartographic = Ellipsoid.WGS84.cartesianToCartographic(end)
+export function getGeodesicDistance (start: Cesium.Cartesian3, end: Cesium.Cartesian3, ellipsoid: Cesium.Ellipsoid) {
+  const { EllipsoidGeodesic } = Cesium
+  const pickedPointCartographic = ellipsoid.cartesianToCartographic(start)
+  const lastPointCartographic = ellipsoid.cartesianToCartographic(end)
   const geodesic = new EllipsoidGeodesic(pickedPointCartographic, lastPointCartographic)
   return geodesic.surfaceDistance
 }
@@ -857,14 +857,14 @@ export function getHeadingPitchRoll (start: Cesium.Cartesian3, end: Cesium.Carte
   return result
 }
 
-export function getPolylineSegmentEndpoint (start: Cesium.Cartesian3, heading: number, distance: number) {
-  const { HeadingPitchRoll, Transforms, Ellipsoid, Matrix4, Cartesian3, Cartesian4, Quaternion, Cartographic } = Cesium
+export function getPolylineSegmentEndpoint (start: Cesium.Cartesian3, heading: number, distance: number, ellipsoid: Cesium.Ellipsoid) {
+  const { HeadingPitchRoll, Transforms, Matrix4, Cartesian3, Cartesian4, Quaternion, Cartographic } = Cesium
   const hpr = new HeadingPitchRoll(heading, 0, 0)
   const scale = new Cartesian3(1, 1, 1)
   const matrix = Transforms.headingPitchRollToFixedFrame(start, hpr)
   const translation = Matrix4.getColumn(matrix, 1, new Cartesian4())
   const axis = new Cartesian3(translation.x, translation.y, translation.z)
-  const quaternion = Quaternion.fromAxisAngle(axis, distance * Ellipsoid.WGS84.oneOverRadii.x)
+  const quaternion = Quaternion.fromAxisAngle(axis, distance * ellipsoid.oneOverRadii.x)
   const hprMatrix = Matrix4.fromTranslationQuaternionRotationScale(Cartesian3.ZERO, quaternion, scale)
   const position = Matrix4.multiplyByPoint(hprMatrix, start, new Cartesian3())
   const startCartographic = Cartographic.fromCartesian(start)