@vcmap/core 5.0.0-rc.23 → 5.0.0-rc.25

package/src/util/math.js

@@ -1,4 +1,5 @@
-import { Math as CesiumMath, Cartesian3 } from '@vcmap/cesium';
+import { Math as CesiumMath, Cartesian3, Cartographic } from '@vcmap/cesium';
+import Projection from './projection.js';
 
 /**
  * returns a new coordinate ([lon, lat] in degrees) from a distance, bearing and starting coordinate
@@ -21,7 +22,6 @@ export function coordinateAtDistance(coord, d, brng) {
   return [parseFloat(CesiumMath.toDegrees(lon2).toFixed(5)), parseFloat(CesiumMath.toDegrees(lat2).toFixed(5))];
 }
 
-
 /**
  * returns the initial bearing in degrees (0-360) between two coordinates
  * @param {Array.<number>} coords1 [lon, lat] in degrees
@@ -45,6 +45,16 @@ export function initialBearingBetweenCoords(coords1, coords2) {
   return brng;
 }
 
+/**
+ * @param {import("ol/coordinate").Coordinate} p1 - mercator
+ * @param {import("ol/coordinate").Coordinate} p2 - mercator
+ * @returns {number} in radians
+ */
+export function getCartesianBearing(p1, p2) {
+  let theta = Math.atan2(p2[0] - p1[0], p2[1] - p1[1]);
+  theta = theta < 0 ? theta + CesiumMath.TWO_PI : theta;
+  return theta;
+}
 
 /**
  * returns distance between two coordinates
@@ -78,3 +88,90 @@ export function cartesian3DDistance(p1, p2) {
 export function modulo(n, m) {
   return ((n % m) + m) % m;
 }
+
+/**
+ * @param {import("@vcmap/cesium").Cartographic} cartographic
+ * @returns {number[]}
+ */
+export function cartographicToWgs84(cartographic) {
+  return [
+    CesiumMath.toDegrees(cartographic.longitude),
+    CesiumMath.toDegrees(cartographic.latitude),
+    cartographic.height,
+  ];
+}
+
+/**
+ * @param {import("ol/coordinate").Coordinate} mercatorCoordinates
+ * @param {import("@vcmap/cesium").Cartesian3=} result
+ * @returns {import("@vcmap/cesium").Cartesian3}
+ */
+export function mercatorToCartesian(mercatorCoordinates, result) {
+  const wgs84Coords = Projection.mercatorToWgs84(mercatorCoordinates);
+  return Cartesian3.fromDegrees(wgs84Coords[0], wgs84Coords[1], wgs84Coords[2], null, result ?? new Cartesian3());
+}
+
+/**
+ * @param {import("@vcmap/cesium").Cartesian3} cartesian
+ * @returns {import("ol/coordinate").Coordinate}
+ */
+export function cartesianToMercator(cartesian) {
+  const cartographic = Cartographic.fromCartesian(cartesian);
+  const wgs84 = cartographicToWgs84(cartographic);
+  return Projection.wgs84ToMercator(wgs84);
+}
+
+/**
+ * @param {import("ol/coordinate").Coordinate} p1
+ * @param {import("ol/coordinate").Coordinate} p2
+ * @returns {import("ol/coordinate").Coordinate}
+ */
+export function getMidPoint(p1, p2) {
+  if (p1.length < 3 && p2.length < 3) {
+    return [
+      p1[0] + ((p2[0] - p1[0]) / 2),
+      p1[1] + ((p2[1] - p1[1]) / 2),
+      0,
+    ];
+  }
+  return [
+    p1[0] + ((p2[0] - p1[0]) / 2),
+    p1[1] + ((p2[1] - p1[1]) / 2),
+    p1[2] + ((p2[2] - p1[2]) / 2),
+  ];
+}
+
+/**
+ * Gets the pitch between two points in degrees.
+ * @param {import("ol/coordinate").Coordinate} p1 - mercator
+ * @param {import("ol/coordinate").Coordinate} p2 - mercator
+ * @returns {number} in degrees
+ */
+export function getCartesianPitch(p1, p2) {
+  let thirdPoint;
+  if (p1[2] > p2[2]) {
+    thirdPoint = p1.slice();
+    thirdPoint[2] = p2[2];
+  } else {
+    thirdPoint = p2.slice();
+    thirdPoint[2] = p1[2];
+  }
+  const scratch1 = mercatorToCartesian(p1);
+  const scratch2 = mercatorToCartesian(p2);
+  const scratch3 = mercatorToCartesian(thirdPoint);
+
+  Cartesian3.subtract(scratch2, scratch1, scratch2);
+  Cartesian3.subtract(scratch3, scratch1, scratch3);
+
+  Cartesian3.normalize(scratch2, scratch2);
+  Cartesian3.normalize(scratch3, scratch3);
+
+  let pitch;
+  if (p1[2] > p2[2]) {
+    pitch = CesiumMath.toDegrees(Math.acos(Cartesian3.dot(scratch2, scratch3))) - 90;
+  } else {
+    pitch = CesiumMath.toDegrees(Math.acos(Cartesian3.dot(scratch2, scratch3)));
+  }
+
+  return pitch;
+}

package/tests/unit/helpers/cesiumHelpers.js

@@ -19,6 +19,7 @@ import {
 import CesiumTilesetLayer from '../../../src/layer/cesiumTilesetLayer.js';
 import DataSourceLayer from '../../../src/layer/dataSourceLayer.js';
 import CesiumMap from '../../../src/map/cesiumMap.js';
+import { Viewpoint } from '../../../index.js';
 
 export const tilesetJSON = {
   asset: {
@@ -110,12 +111,12 @@ export function createEntities(numberOfEntities = 1) {
 }
 
 /**
- * @param {sinon.sandbox} sandbox
- * @param {Cesium/Event} event
+ * @param {import("@vcmap/core").VcsEvent} event
+ * @param {sinon.sandbox} [sandbox]
  * @returns {sinon.spy}
  */
-export function getCesiumEventSpy(sandbox, event) {
-  const spy = sandbox.spy();
+export function getVcsEventSpy(event, sandbox) {
+  const spy = (sandbox ?? sinon).spy();
   const listener = event.addEventListener(function callback() {
     listener();
     // eslint-disable-next-line prefer-rest-params
@@ -162,6 +163,7 @@ export function getMockScene() {
     },
     pick() {},
     pickPosition() {},
+    drillPick() { return []; },
     destroy() {
       this.primitives.destroy();
       this.groundPrimitives.destroy();
@@ -210,6 +212,14 @@ export function getCesiumMap(mapOptions) {
     },
   };
   map.initialized = true;
+  const originalGetViewpointSync = map.getViewpointSync.bind(map);
+  map.getViewpointSync = function patchedGetVPSync() {
+    const vp = originalGetViewpointSync();
+    if (vp) {
+      return vp;
+    }
+    return new Viewpoint({});
+  };
 
   return map;
 }

package/tests/unit/helpers/helpers.js

@@ -1,3 +1,5 @@
+import { Math as CesiumMath } from '@vcmap/cesium';
+
 /**
  * helper function to wait for a timeout use: await timeout(1);
  * @param {number} ms
@@ -9,3 +11,14 @@ export function timeout(ms) {
     setTimeout(resolve, ms);
   });
 }
+
+/**
+ * @param {Array<number>} numbers
+ * @param {Array<number>} expectedNumbers
+ * @param {number} [epsilon=CesiumMath.EPSILON8]
+ */
+export function arrayCloseTo(numbers, expectedNumbers, epsilon = CesiumMath.EPSILON8) {
+  numbers.forEach((c, index) => {
+    expect(c).to.be.closeTo(expectedNumbers[index], epsilon, `Array at index ${index}`);
+  });
+}

package/src/featureProvider/featureProviderHelpers.js

@@ -1,50 +0,0 @@
-import { getCenter } from 'ol/extent.js';
-import Projection from '../util/projection.js';
-import Extent3D from '../util/featureconverter/extent3D.js';
-
-/**
- * @param {VectorClickedObject} feature
- * @param {import("@vcmap/core").Layer} layer
- * @returns {?GenericFeature}
- */
-// eslint-disable-next-line import/prefer-default-export
-export function getGenericFeatureFromProvidedFeature(feature, layer) {
-  const attributes = feature.getProperties();
-  delete attributes[feature.getGeometryName()];
-
-  let { clickedPosition } = feature;
-  const geometry = feature.getGeometry();
-  const isModel = feature.get('olcs_modelUrl');
-  if (
-    geometry &&
-    (
-      (geometry.getType() === 'Point' && !isModel) ||
-      (clickedPosition && !clickedPosition.exactPosition) ||
-      (!clickedPosition && geometry)
-    )
-  ) {
-    const center = getCenter(geometry.getExtent());
-    if (center) {
-      Projection.mercatorToWgs84(center, true);
-      clickedPosition = { longitude: center[0], latitude: center[1] };
-    }
-  }
-
-  let heightOffset = clickedPosition.height;
-  if (!isModel) {
-    const extent = Extent3D.fromGeometry(geometry);
-    heightOffset = Number.isFinite(extent.maxZ) ? extent.maxZ : 0;
-  }
-  const relativeToGround = !isModel && feature.get('olcs_altitudeMode') === 'relativeToGround';
-
-  delete attributes.clickedPosition;
-  return {
-    layerName: layer.name,
-    layerClass: layer.className,
-    attributes,
-    longitude: clickedPosition.longitude,
-    latitude: clickedPosition.latitude,
-    height: heightOffset,
-    relativeToGround,
-  };
-}

package/src/util/splitScreen.js

@@ -1,233 +0,0 @@
-import {
-  Cartesian3,
-  Matrix4,
-  Plane,
-  ClippingPlane,
-  ClippingPlaneCollection,
-  SplitDirection,
-} from '@vcmap/cesium';
-
-import { check } from '@vcsuite/check';
-import CesiumMap from '../map/cesiumMap.js';
-import ClippingObject from './clipping/clippingObject.js';
-import OpenlayersMap from '../map/openlayersMap.js';
-
-/**
- * @class
- * @api
- */
-class SplitScreen {
-  /**
-   * @param {import("@vcmap/core").ClippingObjectManager} clippingObjectManager
-   */
-  constructor(clippingObjectManager) {
-    /**
-     * @type {number}
-     * @private
-     */
-    this._position = 0.5;
-    /**
-     * @type {import("@vcmap/cesium").Scene|null}
-     */
-    this.scene = null;
-    /**
-     * @type {import("ol/Map").default|null}
-     */
-    this.olMap = null;
-    /**
-     * @type {boolean}
-     * @api
-     */
-    this.initialized = false;
-    /**
-     * @type {ClippingObject}
-     */
-    this.leftScreenClippingObject = new ClippingObject();
-    /**
-     * @type {ClippingObject}
-     */
-    this.rightScreenClippingObject = new ClippingObject();
-    /**
-     * @type {Function|null}
-     * @private
-     */
-    this._cameraListener = null;
-    /**
-     * @type {number|null}
-     */
-    this.originalCameraPercentageChanged = null;
-    /**
-     * @type {Array<Function>}
-     * @private
-     */
-    this._targetsChangedListeners = [];
-
-    this._targetsChangedListeners = [
-      this.rightScreenClippingObject.targetsUpdated.addEventListener(() => { this._targetsChanged(); }),
-      this.leftScreenClippingObject.targetsUpdated.addEventListener(() => { this._targetsChanged(); }),
-    ];
-
-    /**
-     * @type {import("@vcmap/core").ClippingObjectManager}
-     * @private
-     */
-    this._clippingObjectManager = clippingObjectManager;
-    this._clippingObjectManager.addClippingObject(this.rightScreenClippingObject);
-    this._clippingObjectManager.addClippingObject(this.leftScreenClippingObject);
-  }
-
-  /**
-   * @type {number}
-   * @api
-   */
-  get position() { return this._position; }
-
-  /**
-   * @param {number} position
-   */
-  set position(position) {
-    check(position, Number);
-    if (position < 0 || position > 1) {
-      throw new Error('Position must be between 0 and 1');
-    }
-
-    if (Math.abs(this._position - position) > 0.0001) {
-      this._updatePosition(position);
-    }
-  }
-
-  _targetsChanged() {
-    if (this.scene) {
-      const numTargets = this.rightScreenClippingObject.targets.size + this.leftScreenClippingObject.targets.size;
-      const { camera } = this.scene;
-
-      if (this._cameraListener && numTargets === 0) {
-        this._cameraListener();
-        this._cameraListener = null;
-        camera.percentageChanged = this.originalCameraPercentageChanged;
-      } else if (!this._cameraListener && numTargets > 0) {
-        this.originalCameraPercentageChanged = camera.percentageChanged;
-        camera.percentageChanged = 0;
-        this._cameraListener = camera.changed.addEventListener(this._updateClippingPlanes.bind(this));
-        this._updateClippingPlanes();
-      }
-    }
-  }
-
-  /**
-   * @param {number} position
-   * @private
-   */
-  _updatePosition(position) {
-    this._position = position;
-    if (this.scene) {
-      this.scene.splitPosition = position;
-      this._updateClippingPlanes();
-    } else if (this.olMap) {
-      this.olMap.render();
-    }
-  }
-
-  /**
-   * @param {import("@vcmap/core").VcsMap} map
-   */
-  mapActivated(map) {
-    if (map instanceof CesiumMap) {
-      this.scene = map.getScene();
-      this.olMap = null;
-      this._targetsChanged();
-    } else if (map instanceof OpenlayersMap) {
-      this.scene = null;
-      this.olMap = map.olMap;
-    }
-    this._updatePosition(this.position);
-  }
-
-  /**
-   * calculate a clipping plane from the current swipe position for the given Cesium3DTileset
-   * @returns {import("@vcmap/cesium").ClippingPlane}
-   * @private
-   */
-  _calcClippingPlane() {
-    const { camera } = this.scene;
-    const { fov, near } = /** @type {import("@vcmap/cesium").PerspectiveFrustum} */ (camera.frustum);
-    const screenWidth = this.scene.canvas.width || 1;
-    const screenHeight = this.scene.canvas.height || 1;
-    let pixelSize;
-    if (screenHeight > screenWidth) {
-      pixelSize = (near * Math.tan(0.5 * fov) * 2.0) / screenHeight;
-    } else {
-      pixelSize = (near * Math.tan(0.5 * fov) * 2.0) / screenWidth;
-    }
-
-    // extract 3 points lying on swipe plane
-    const screenX = (screenWidth * this.position) - (screenWidth / 2);
-    const screenY = screenHeight / 2;
-    const p1 = new Cartesian3(pixelSize * screenX, pixelSize * screenY, -1 * near);
-    const p2 = new Cartesian3(pixelSize * screenX, -1 * pixelSize * screenY, -1 * near);
-    Matrix4.multiplyByPoint(camera.inverseViewMatrix, p1, p1);
-    Matrix4.multiplyByPoint(camera.inverseViewMatrix, p2, p2);
-    const p3WC = camera.positionWC;
-
-    Cartesian3.subtract(p3WC, p1, p1);
-    Cartesian3.subtract(p3WC, p2, p2);
-    const normal = Cartesian3.cross(p1, p2, new Cartesian3());
-    Cartesian3.normalize(normal, normal);
-    const planeInFixedFrame = Plane.fromPointNormal(p3WC, normal);
-
-    return ClippingPlane.fromPlane(planeInFixedFrame);
-  }
-
-  /**
-   * update the clipping planes for all Cesium3DTilesets loaded in the vcMap
-   * @private
-   */
-  _updateClippingPlanes() {
-    const plane = this._calcClippingPlane();
-    this.leftScreenClippingObject.clippingPlaneCollection = new ClippingPlaneCollection({ planes: [plane] });
-    const revClippingPlane = ClippingPlane.clone(plane);
-    revClippingPlane.normal = Cartesian3.negate(revClippingPlane.normal, revClippingPlane.normal);
-    revClippingPlane.distance *= -1;
-    this.rightScreenClippingObject.clippingPlaneCollection =
-      new ClippingPlaneCollection({ planes: [revClippingPlane] });
-  }
-
-  /**
-   * Gets the clipping object for a split direction
-   * @param {import("@vcmap/cesium").SplitDirection} splitDirection
-   * @returns {ClippingObject|null}
-   * @api
-   */
-  getClippingObjectForDirection(splitDirection) {
-    check(splitDirection, [
-      SplitDirection.LEFT,
-      SplitDirection.RIGHT,
-      SplitDirection.NONE,
-    ]);
-
-    if (splitDirection === SplitDirection.LEFT) {
-      return this.leftScreenClippingObject;
-    }
-    if (splitDirection === SplitDirection.RIGHT) {
-      return this.rightScreenClippingObject;
-    }
-
-    return null;
-  }
-
-  destroy() {
-    if (this._clippingObjectManager) {
-      this._clippingObjectManager.removeClippingObject(this.rightScreenClippingObject);
-      this._clippingObjectManager.removeClippingObject(this.leftScreenClippingObject);
-    }
-    this._targetsChangedListeners.forEach((cb) => { cb(); });
-    this._targetsChangedListeners = [];
-    this._clippingObjectManager = null;
-    if (this._cameraListener) {
-      this._cameraListener();
-      this._cameraListener = null;
-    }
-  }
-}
-
-export default SplitScreen;