@vcmap/core 6.1.11 → 6.2.0-rc.1

package/src/map/cesiumMapHelpers.ts

@@ -0,0 +1,219 @@
+import type {
+  Camera,
+  Scene,
+  ScreenSpaceEventHandler,
+} from '@vcmap-cesium/engine';
+import {
+  Cartesian3,
+  Cartographic,
+  Ellipsoid,
+  KeyboardEventModifier,
+  Math as CesiumMath,
+  Ray,
+  ScreenSpaceEventType,
+} from '@vcmap-cesium/engine';
+import {
+  ModificationKeyType,
+  PointerEventType,
+  PointerKeyType,
+} from '../interaction/interactionType.js';
+import Viewpoint from '../util/viewpoint.js';
+import type VcsMap from './vcsMap.js';
+
+function raisePointerInteraction(
+  map: VcsMap,
+  key: ModificationKeyType,
+  pointer: number,
+  pointerEvent: PointerEventType,
+  csEvent:
+    | ScreenSpaceEventHandler.PositionedEvent
+    | ScreenSpaceEventHandler.MotionEvent,
+  screenSpaceEventHandler: ScreenSpaceEventHandler,
+): void {
+  const multipleTouch =
+    // eslint-disable-next-line no-underscore-dangle
+    (screenSpaceEventHandler?._positions?.length ?? 0) > 1;
+  const windowPosition = (csEvent as ScreenSpaceEventHandler.PositionedEvent)
+    .position
+    ? (csEvent as ScreenSpaceEventHandler.PositionedEvent).position
+    : (csEvent as ScreenSpaceEventHandler.MotionEvent).endPosition;
+
+  map.pointerInteractionEvent.raiseEvent({
+    map,
+    windowPosition,
+    key,
+    pointer,
+    multipleTouch,
+    pointerEvent,
+  });
+}
+
+export function setupCesiumInteractions(
+  map: VcsMap,
+  scene: Scene,
+  screenSpaceEventHandler: ScreenSpaceEventHandler,
+): () => void {
+  const mods = [
+    {
+      csModifier: KeyboardEventModifier.ALT,
+      vcsModifier: ModificationKeyType.ALT,
+    },
+    {
+      csModifier: KeyboardEventModifier.CTRL,
+      vcsModifier: ModificationKeyType.CTRL,
+    },
+    {
+      csModifier: KeyboardEventModifier.SHIFT,
+      vcsModifier: ModificationKeyType.SHIFT,
+    },
+    { csModifier: undefined, vcsModifier: ModificationKeyType.NONE },
+  ];
+
+  const types = [
+    {
+      type: ScreenSpaceEventType.LEFT_DOWN,
+      pointerEvent: PointerEventType.DOWN,
+      pointer: PointerKeyType.LEFT,
+    },
+    {
+      type: ScreenSpaceEventType.LEFT_UP,
+      pointerEvent: PointerEventType.UP,
+      pointer: PointerKeyType.LEFT,
+    },
+    {
+      type: ScreenSpaceEventType.RIGHT_DOWN,
+      pointerEvent: PointerEventType.DOWN,
+      pointer: PointerKeyType.RIGHT,
+    },
+    {
+      type: ScreenSpaceEventType.RIGHT_UP,
+      pointerEvent: PointerEventType.UP,
+      pointer: PointerKeyType.RIGHT,
+    },
+    {
+      type: ScreenSpaceEventType.MIDDLE_DOWN,
+      pointerEvent: PointerEventType.DOWN,
+      pointer: PointerKeyType.MIDDLE,
+    },
+    {
+      type: ScreenSpaceEventType.MIDDLE_UP,
+      pointerEvent: PointerEventType.UP,
+      pointer: PointerKeyType.MIDDLE,
+    },
+    {
+      type: ScreenSpaceEventType.MOUSE_MOVE,
+      pointerEvent: PointerEventType.MOVE,
+      pointer: PointerKeyType.ALL,
+    },
+  ];
+  let lastEventFrameNumber = 0;
+  const screenSpaceListeners = types
+    .map(({ pointerEvent, pointer, type }) => {
+      return mods.map(({ csModifier, vcsModifier }) => {
+        const handler:
+          | ScreenSpaceEventHandler.PositionedEventCallback
+          | ScreenSpaceEventHandler.MotionEventCallback =
+          type === ScreenSpaceEventType.MOUSE_MOVE
+            ? (csEvent: ScreenSpaceEventHandler.MotionEvent): void => {
+                if (scene.frameState.frameNumber !== lastEventFrameNumber) {
+                  lastEventFrameNumber = scene.frameState.frameNumber;
+                  raisePointerInteraction(
+                    map,
+                    vcsModifier,
+                    pointer,
+                    pointerEvent,
+                    csEvent,
+                    screenSpaceEventHandler,
+                  );
+                }
+              }
+            : (csEvent: ScreenSpaceEventHandler.PositionedEvent): void => {
+                raisePointerInteraction(
+                  map,
+                  vcsModifier,
+                  pointer,
+                  pointerEvent,
+                  csEvent,
+                  screenSpaceEventHandler,
+                );
+              };
+
+        screenSpaceEventHandler.setInputAction?.(handler, type, csModifier);
+        return (): void => {
+          screenSpaceEventHandler.removeInputAction?.(type, csModifier);
+        };
+      });
+    })
+    .flat();
+
+  return (): void => {
+    screenSpaceListeners.forEach((removeListener) => {
+      removeListener();
+    });
+  };
+}
+
+export function getViewpointFromScene(scene: Scene): Viewpoint {
+  const cam = scene.camera;
+  const cameraPositionCartesian = cam.position;
+  let groundPosition;
+  let distance;
+
+  const groundPositionCartesian = scene.globe?.pick(
+    new Ray(cam.position, cam.direction),
+    scene,
+  );
+
+  if (groundPositionCartesian) {
+    distance = Cartesian3.distance(
+      groundPositionCartesian,
+      cameraPositionCartesian,
+    );
+    const groundPositionCartographic = Ellipsoid.WGS84.cartesianToCartographic(
+      groundPositionCartesian,
+    );
+    groundPosition = [
+      CesiumMath.toDegrees(groundPositionCartographic.longitude),
+      CesiumMath.toDegrees(groundPositionCartographic.latitude),
+      groundPositionCartographic.height,
+    ];
+  }
+
+  const cameraPositionCartographic = cam.positionCartographic;
+  const cameraPosition = [
+    CesiumMath.toDegrees(cameraPositionCartographic.longitude),
+    CesiumMath.toDegrees(cameraPositionCartographic.latitude),
+    cameraPositionCartographic.height,
+  ];
+
+  return new Viewpoint({
+    groundPosition,
+    cameraPosition,
+    distance,
+    heading: CesiumMath.toDegrees(cam.heading),
+    pitch: CesiumMath.toDegrees(cam.pitch),
+    roll: CesiumMath.toDegrees(cam.roll),
+  });
+}
+
+export function getResolution(
+  cartesian: Cartesian3,
+  camera: Camera,
+  mapElement: HTMLElement,
+  latitude?: number,
+): number {
+  const distance = Cartesian3.distance(cartesian, camera.position);
+  const usedLatitude =
+    latitude ?? Cartographic.fromCartesian(cartesian).latitude;
+
+  const fov = Math.PI / 3.0;
+  const width = mapElement.offsetWidth;
+  const height = mapElement.offsetHeight;
+  const aspectRatio = width / height;
+  const fovy = Math.atan(Math.tan(fov * 0.5) / aspectRatio) * 2.0;
+  const visibleMeters = 2 * distance * Math.tan(fovy / 2);
+  const relativeCircumference = Math.cos(Math.abs(usedLatitude));
+  const visibleMapUnits = visibleMeters / relativeCircumference;
+
+  return visibleMapUnits / height;
+}

package/src/map/navigation/cameraHelper.ts

@@ -1,15 +1,14 @@
+import type { Camera, Scene } from '@vcmap-cesium/engine';
 import {
-  Camera,
   Cartesian3,
   HeadingPitchRoll,
   Math as CesiumMath,
   Matrix3,
   Matrix4,
   PerspectiveFrustum,
-  Scene,
   Transforms,
 } from '@vcmap-cesium/engine';
-import { ControllerInput } from './controller/controllerInput.js';
+import type { ControllerInput } from './controller/controllerInput.js';
 
 const EPSILON3_SQURD = CesiumMath.EPSILON3 * CesiumMath.EPSILON3;
 

package/src/map/navigation/cesiumNavigation.ts

@@ -1,11 +1,11 @@
 import { parseNumber } from '@vcsuite/parsers';
+import type { Scene } from '@vcmap-cesium/engine';
 import {
   Cartesian3,
   HeadingPitchRoll,
   Math as CesiumMath,
-  Scene,
 } from '@vcmap-cesium/engine';
-import CesiumMap from '../cesiumMap.js';
+import type CesiumMap from '../cesiumMap.js';
 import {
   lookTwoDof,
   moveFiveDOF,
@@ -13,8 +13,9 @@ import {
   getScaledTranslation,
   getEnuVector,
 } from './cameraHelper.js';
-import NavigationImpl, { NavigationImplOptions } from './navigationImpl.js';
-import { Movement } from './navigation.js';
+import type { NavigationImplOptions } from './navigationImpl.js';
+import NavigationImpl from './navigationImpl.js';
+import type { Movement } from './navigation.js';
 
 const translationScratch = new Cartesian3();
 const rotationScratch = new HeadingPitchRoll();

package/src/map/navigation/controller/controller.ts

@@ -1,10 +1,7 @@
 import { Math as CesiumMath } from '@vcmap-cesium/engine';
 import { v4 as uuidv4 } from 'uuid';
-import {
-  ControllerInput,
-  checkThreshold,
-  multiplyComponents,
-} from './controllerInput.js';
+import type { ControllerInput } from './controllerInput.js';
+import { checkThreshold, multiplyComponents } from './controllerInput.js';
 
 export type ControllerOptions = {
   id: string;
@@ -40,7 +37,7 @@ class Controller {
       options.inputThreshold || defaultOptions.inputThreshold!;
   }
 
-  // eslint-disable-next-line class-methods-use-this
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
   setMapTarget(_target: HTMLElement | null): void {}
 
   // eslint-disable-next-line class-methods-use-this

package/src/map/navigation/controller/keyboardController.ts

@@ -1,9 +1,7 @@
-import Controller, { ControllerOptions } from './controller.js';
-import {
-  ControllerInput,
-  getZeroInput,
-  clearInput,
-} from './controllerInput.js';
+import type { ControllerOptions } from './controller.js';
+import Controller from './controller.js';
+import type { ControllerInput } from './controllerInput.js';
+import { getZeroInput, clearInput } from './controllerInput.js';
 
 export enum DIRECTIONS {
   FORWARD = 0,
@@ -102,7 +100,9 @@ class KeyboardController extends Controller {
       }
 
       const clicked = (): void => this._target?.focus();
-      const focusin = (): void => this._setupKeyListener();
+      const focusin = (): void => {
+        this._setupKeyListener();
+      };
       const focusout = (): void => {
         this._removeKeyListeners();
         this._removeKeyListeners = (): void => {};

package/src/map/navigation/easingHelper.ts

@@ -1,9 +1,6 @@
 import { type Movement } from './navigation.js';
-import {
-  ControllerInput,
-  getZeroInput,
-  lerpRound,
-} from './controller/controllerInput.js';
+import type { ControllerInput } from './controller/controllerInput.js';
+import { getZeroInput, lerpRound } from './controller/controllerInput.js';
 
 const inputScratch = getZeroInput();
 

package/src/map/navigation/navigation.ts

@@ -1,17 +1,17 @@
 import { getLogger } from '@vcsuite/logger';
-import VcsMap from '../vcsMap.js';
+import type VcsMap from '../vcsMap.js';
 import CesiumMap from '../cesiumMap.js';
 import OpenlayersMap from '../openlayersMap.js';
 import ObliqueMap from '../obliqueMap.js';
 import VcsEvent from '../../vcsEvent.js';
-import NavigationImpl from './navigationImpl.js';
-import Controller from './controller/controller.js';
+import type NavigationImpl from './navigationImpl.js';
+import type Controller from './controller/controller.js';
 import CesiumNavigation from './cesiumNavigation.js';
 import OpenlayersNavigation from './openlayersNavigation.js';
 import ObliqueNavigation from './obliqueNavigation.js';
 import { createEasing, type NavigationEasing } from './easingHelper.js';
+import type { ControllerInput } from './controller/controllerInput.js';
 import {
-  ControllerInput,
   getZeroInput,
   isNonZeroInput,
   inputEquals,
@@ -52,23 +52,23 @@ function getDefaultNavigationImplForMap(
  * Manages the active navigation and the controllers.
  */
 class Navigation {
-  private _defaultNavigationImpls: Map<
+  private _defaultNavigationImpls = new Map<
     VcsMap,
     NavigationImpl<VcsMap> | undefined
-  > = new Map();
+  >();
 
-  private _customNavigationImpls: Map<
+  private _customNavigationImpls = new Map<
     VcsMap,
     { impl: NavigationImpl<VcsMap>; cb: () => void }
-  > = new Map();
+  >();
 
   private _currentNavigation: NavigationImpl<VcsMap> | undefined = undefined;
 
-  public currentNavigationChanged: VcsEvent<
+  public currentNavigationChanged = new VcsEvent<
     NavigationImpl<VcsMap> | undefined
-  > = new VcsEvent();
+  >();
 
-  private _controller: Map<string, Controller> = new Map();
+  private _controller = new Map<string, Controller>();
 
   private _movement: Movement = getZeroMovement();
 
@@ -161,7 +161,7 @@ class Navigation {
    * Removes custom implementations and resets the original default NavigationImpl for the map
    * @param map
    */
-  resetNavigationImplForMap<M extends VcsMap>(map: M): void {
+  resetNavigationImplForMap(map: VcsMap): void {
     if (this._customNavigationImpls.has(map)) {
       const { cb } = this._customNavigationImpls.get(map)!;
       cb();
@@ -257,9 +257,13 @@ class Navigation {
 
   destroy(): void {
     this._stopInputLoop();
-    this._controller.forEach((c) => c.destroy());
+    this._controller.forEach((c) => {
+      c.destroy();
+    });
     this._controller.clear();
-    this._customNavigationImpls.forEach(({ cb }) => cb());
+    this._customNavigationImpls.forEach(({ cb }) => {
+      cb();
+    });
     this._customNavigationImpls.clear();
     this._defaultNavigationImpls.clear();
     this._currentNavigation = undefined;

package/src/map/navigation/navigationImpl.ts

@@ -1,5 +1,5 @@
-import VcsMap from '../vcsMap.js';
-import { Movement } from './navigation.js';
+import type VcsMap from '../vcsMap.js';
+import type { Movement } from './navigation.js';
 
 export type NavigationImplOptions = {
   /**

package/src/map/navigation/obliqueNavigation.ts

@@ -1,8 +1,9 @@
 import { getLogger } from '@vcsuite/logger';
 import { parseNumber } from '@vcsuite/parsers';
-import ObliqueMap from '../obliqueMap.js';
-import { Movement } from './navigation.js';
-import NavigationImpl, { NavigationImplOptions } from './navigationImpl.js';
+import type ObliqueMap from '../obliqueMap.js';
+import type { Movement } from './navigation.js';
+import type { NavigationImplOptions } from './navigationImpl.js';
+import NavigationImpl from './navigationImpl.js';
 import { moveView } from './viewHelper.js';
 
 export type ObliqueNavigationOptions = NavigationImplOptions & {
@@ -57,9 +58,9 @@ class ObliqueNavigation extends NavigationImpl<ObliqueMap> {
   update(movement: Movement): void {
     moveView(this._map, movement.input, this.baseTranSpeed);
     if (Math.abs(movement.input.turnRight) > this.rotatingThreshold) {
-      this._rotate(Math.sign(movement.input.turnRight)).catch((e) =>
-        getLogger('ObliqueNavigation').error(String(e)),
-      );
+      this._rotate(Math.sign(movement.input.turnRight)).catch((e: unknown) => {
+        getLogger('ObliqueNavigation').error(String(e));
+      });
     }
   }
 

package/src/map/navigation/openlayersNavigation.ts

@@ -1,6 +1,7 @@
-import OpenlayersMap from '../openlayersMap.js';
-import NavigationImpl, { NavigationImplOptions } from './navigationImpl.js';
-import { Movement } from './navigation.js';
+import type OpenlayersMap from '../openlayersMap.js';
+import type { NavigationImplOptions } from './navigationImpl.js';
+import NavigationImpl from './navigationImpl.js';
+import type { Movement } from './navigation.js';
 import { moveView } from './viewHelper.js';
 
 export type OpenlayersNavigationOptions = NavigationImplOptions;

package/src/map/navigation/viewHelper.ts

@@ -1,8 +1,7 @@
-import BaseOLMap from '../baseOLMap.js';
+import type BaseOLMap from '../baseOLMap.js';
 import { getScaleFromDistance } from './cameraHelper.js';
-import { ControllerInput } from './controller/controllerInput.js';
+import type { ControllerInput } from './controller/controllerInput.js';
 
-// eslint-disable-next-line import/prefer-default-export
 export function moveView(
   map: BaseOLMap,
   input: ControllerInput,

package/src/map/obliqueMap.ts

@@ -1,6 +1,6 @@
 import { boundingExtent, containsXY } from 'ol/extent.js';
 import { getTransform, transform, transformExtent } from 'ol/proj.js';
-import { Map as OLMap } from 'ol';
+import type { Map as OLMap } from 'ol';
 import type { Coordinate } from 'ol/coordinate.js';
 
 import { check } from '@vcsuite/check';
@@ -13,15 +13,13 @@ import {
 } from '../layer/oblique/obliqueHelpers.js';
 import Viewpoint from '../util/viewpoint.js';
 import BaseOLMap from './baseOLMap.js';
-import VcsMap, { VcsMapOptions } from './vcsMap.js';
+import type { VcsMapOptions } from './vcsMap.js';
+import VcsMap from './vcsMap.js';
 import VcsEvent from '../vcsEvent.js';
-import {
-  ObliqueViewDirection,
-  ObliqueViewDirection as ViewDirection,
-} from '../oblique/obliqueViewDirection.js';
-import ObliqueProvider, {
-  ObliqueProviderMapChangeEventType,
-} from '../oblique/obliqueProvider.js';
+import type { ObliqueViewDirection } from '../oblique/obliqueViewDirection.js';
+import { ObliqueViewDirection as ViewDirection } from '../oblique/obliqueViewDirection.js';
+import type { ObliqueProviderMapChangeEventType } from '../oblique/obliqueProvider.js';
+import ObliqueProvider from '../oblique/obliqueProvider.js';
 import ObliqueCollection from '../oblique/obliqueCollection.js';
 import { transformFromImage } from '../oblique/helpers.js';
 import { mapClassRegistry } from '../classRegistry.js';