@vcmap/core 5.0.2 → 5.1.0-rc.1

package/src/util/flight/flightPlayer.ts

@@ -0,0 +1,326 @@
+import {
+  Cartesian3,
+  CatmullRomSpline,
+  HeadingPitchRoll,
+  LinearSpline,
+  QuaternionSpline,
+  Scene,
+  ScreenSpaceCameraController,
+} from '@vcmap-cesium/engine';
+import { getLogger } from '@vcsuite/logger';
+import { check } from '@vcsuite/check';
+import CesiumMap from '../../map/cesiumMap.js';
+import { getSplineAndTimesForInstance } from './flightHelpers.js';
+import FlightInstance from './flightInstance.js';
+import VcsEvent from '../../vcsEvent.js';
+import VcsApp from '../../vcsApp.js';
+
+export type FlightPlayerClock = {
+  startTime: number;
+  endTime: number;
+  currentTime: number;
+  times: number[];
+  currentSystemTime?: number;
+};
+
+export type FlightPlayerState = 'playing' | 'paused' | 'stopped';
+
+export type FlightPlayer = {
+  readonly flightInstanceName: string;
+  readonly state: FlightPlayerState;
+  readonly stateChanged: VcsEvent<FlightPlayerState>;
+  readonly destroyed: VcsEvent<void>;
+  clock: FlightPlayerClock;
+  play(): void;
+  stop(): void;
+  pause(): void;
+  /**
+   * jumps to the given time
+   * @param time time in seconds
+   */
+  goToTime(time: number): void;
+  forward(): void;
+  backward(): void;
+  destroy(): void;
+};
+
+function getDefaultFlightPlayerClock(): FlightPlayerClock {
+  return {
+    startTime: 0,
+    endTime: 0,
+    currentTime: 0,
+    times: [],
+  };
+}
+
+export async function createFlightPlayer(
+  instance: FlightInstance,
+  app: VcsApp,
+): Promise<FlightPlayer> {
+  check(instance, FlightInstance);
+  check(app, VcsApp);
+
+  let cesiumMap: CesiumMap =
+    app.maps.activeMap instanceof CesiumMap
+      ? app.maps.activeMap
+      : (app.maps.getByType(CesiumMap.className)[0] as CesiumMap);
+  if (!cesiumMap) {
+    throw new Error('Cannot start a flight player without a cesium map');
+  }
+  await instance.initialize();
+
+  const clock: FlightPlayerClock = getDefaultFlightPlayerClock();
+
+  let playerState: FlightPlayerState = 'stopped';
+
+  const stateChanged = new VcsEvent<FlightPlayerState>();
+
+  const setState = (state: FlightPlayerState): void => {
+    playerState = state;
+    stateChanged.raiseEvent(playerState);
+  };
+
+  let destinationSpline: CatmullRomSpline | LinearSpline | undefined;
+
+  let quaternionSpline: QuaternionSpline | undefined;
+
+  let postRenderListener: (() => void) | undefined;
+
+  let backedBeforeTimeout: number | undefined;
+
+  let screenSpaceCameraController: ScreenSpaceCameraController | undefined;
+
+  const stop = (): void => {
+    if (playerState !== 'stopped') {
+      if (postRenderListener) {
+        postRenderListener();
+        postRenderListener = undefined;
+      }
+
+      if (screenSpaceCameraController) {
+        screenSpaceCameraController.enableInputs = true;
+      }
+
+      setState('stopped');
+
+      clock.currentTime = 0;
+      clock.currentSystemTime = undefined;
+    }
+  };
+
+  const updateSplines = (): void => {
+    if (!instance.isValid()) {
+      stop();
+      Object.assign(clock, getDefaultFlightPlayerClock());
+    } else {
+      const splines = getSplineAndTimesForInstance(instance);
+
+      ({ destinationSpline, quaternionSpline } = splines);
+      const { times } = splines;
+      clock.endTime = times[times.length - 1];
+      clock.times = times;
+    }
+  };
+  updateSplines();
+
+  const listeners = [
+    instance.anchorsChanged.addEventListener(updateSplines),
+    instance.propertyChanged.addEventListener((property) => {
+      if (property === 'interpolation' || property === 'loop') {
+        updateSplines();
+      }
+    }),
+    app.maps.mapActivated.addEventListener(() => {
+      stop();
+      if (app.maps.activeMap instanceof CesiumMap) {
+        cesiumMap = app.maps.activeMap;
+      }
+    }),
+  ];
+
+  const cesiumPostRender = (scene: Scene): void => {
+    const time = Date.now() / 1000;
+    if (!clock.currentSystemTime) {
+      clock.currentSystemTime = time;
+    }
+    const seconds = time - clock.currentSystemTime;
+    clock.currentSystemTime = time;
+    if (playerState === 'paused') {
+      if (screenSpaceCameraController) {
+        screenSpaceCameraController.enableInputs = true;
+      }
+      return;
+    }
+
+    clock.currentTime += seconds * instance.multiplier;
+    if (clock.currentTime > clock.endTime) {
+      if (instance.loop && clock.endTime > 0) {
+        while (clock.currentTime > clock.endTime) {
+          clock.currentTime -= clock.endTime;
+        }
+      } else {
+        stop();
+      }
+    } else if (clock.currentTime < clock.startTime) {
+      if (instance.loop) {
+        clock.currentTime = clock.endTime + clock.currentTime;
+      } else {
+        clock.currentTime = clock.startTime;
+        return;
+      }
+    }
+
+    const view = {
+      destination: destinationSpline!.evaluate(clock.currentTime) as Cartesian3,
+      orientation: HeadingPitchRoll.fromQuaternion(
+        quaternionSpline!.evaluate(clock.currentTime),
+      ),
+    };
+    scene.camera.setView(view);
+    if (playerState === 'playing') {
+      if (screenSpaceCameraController) {
+        screenSpaceCameraController.enableInputs = false;
+      }
+    }
+  };
+
+  const play = (): void => {
+    if (playerState === 'playing') {
+      return;
+    }
+    if (!(app.maps.activeMap instanceof CesiumMap)) {
+      getLogger('FlightPlayer').warning(
+        'cannot play without a cesium map active',
+      );
+      return;
+    }
+    if (playerState === 'paused') {
+      setState('playing');
+      return;
+    }
+    if (postRenderListener) {
+      postRenderListener();
+      postRenderListener = undefined;
+    }
+
+    const scene = cesiumMap.getScene();
+    if (!scene) {
+      return;
+    }
+    ({ screenSpaceCameraController } = scene);
+    postRenderListener = scene.postRender.addEventListener(cesiumPostRender);
+    clock.currentSystemTime = undefined;
+
+    setState('playing');
+  };
+
+  const goToTime = (time: number): void => {
+    if (time > clock.endTime) {
+      getLogger('FlightPlayer').warning(`time: ${time} out of range`);
+      return;
+    }
+    clock.currentTime = time;
+    clock.currentSystemTime = undefined;
+    if (playerState !== 'playing') {
+      const view = {
+        destination: destinationSpline!.evaluate(
+          clock.currentTime,
+        ) as Cartesian3,
+        orientation: HeadingPitchRoll.fromQuaternion(
+          quaternionSpline!.evaluate(clock.currentTime),
+        ),
+      };
+      cesiumMap.getScene()?.camera.setView(view);
+    }
+  };
+  const destroyed = new VcsEvent<void>();
+  const destroy = (): void => {
+    if (postRenderListener) {
+      postRenderListener();
+      postRenderListener = undefined;
+    }
+
+    if (screenSpaceCameraController) {
+      screenSpaceCameraController.enableInputs = true;
+      screenSpaceCameraController = undefined;
+    }
+
+    if (backedBeforeTimeout != null) {
+      clearTimeout(backedBeforeTimeout);
+    }
+
+    listeners.forEach((cb) => {
+      cb();
+    });
+    stateChanged.destroy();
+    destroyed.raiseEvent();
+    destroyed.destroy();
+  };
+
+  listeners.push(
+    app.flights.removed.addEventListener((flight) => {
+      if (flight === instance) {
+        destroy();
+      }
+    }),
+    app.flights.added.addEventListener((flight) => {
+      if (flight.name === instance.name) {
+        destroy();
+      }
+    }),
+  );
+
+  return {
+    clock,
+    get flightInstanceName(): string {
+      return instance.name;
+    },
+    get state(): FlightPlayerState {
+      return playerState;
+    },
+    get stateChanged(): VcsEvent<FlightPlayerState> {
+      return stateChanged;
+    },
+    get destroyed(): VcsEvent<void> {
+      return destroyed;
+    },
+    play,
+    stop,
+    pause(): void {
+      if (playerState === 'playing') {
+        setState('paused');
+      }
+    },
+    goToTime,
+    /**
+     * forwards the currentTime to the next anchor
+     */
+    forward(): void {
+      const seconds = clock.currentTime;
+      const newTime =
+        clock.times.find((t) => t > seconds) ||
+        clock.times[clock.times.length - 1];
+      goToTime(newTime);
+    },
+    /**
+     * resets the currentTime to the previous anchor
+     */
+    backward(): void {
+      const seconds = clock.currentTime;
+      let index = clock.times.findIndex((t) => t >= seconds) - 1;
+      if (backedBeforeTimeout != null) {
+        index -= 1;
+        clearTimeout(backedBeforeTimeout);
+      }
+      if (index < 0) {
+        index = 0;
+      }
+      const newTime = clock.times[index];
+      goToTime(newTime);
+      backedBeforeTimeout = window.setTimeout(() => {
+        backedBeforeTimeout = undefined;
+      }, 700);
+    },
+    destroy,
+  };
+}

package/src/util/flight/flightVisualizer.ts

@@ -0,0 +1,202 @@
+import {
+  PrimitiveCollection,
+  Camera,
+  Cartesian3,
+  HeadingPitchRoll,
+  Scene,
+} from '@vcmap-cesium/engine';
+import { createEmpty, isEmpty } from 'ol/extent.js';
+import Feature from 'ol/Feature.js';
+import { Point, LineString } from 'ol/geom.js';
+import { check } from '@vcsuite/check';
+
+import { mercatorToWgs84Transformer, wgs84Projection } from '../projection.js';
+import VectorLayer from '../../layer/vectorLayer.js';
+import Viewpoint from '../viewpoint.js';
+import CesiumMap from '../../map/cesiumMap.js';
+import VcsCameraPrimitive from '../../cesium/cesiumVcsCameraPrimitive.js';
+import FlightInstance from './flightInstance.js';
+import type VcsApp from '../../vcsApp.js';
+import { getFlightPathCoordinatesFromInstance } from './flightHelpers.js';
+import LayerState from '../../layer/layerState.js';
+import VcsEvent from '../../vcsEvent.js';
+import DeclarativeStyleItem from '../../style/declarativeStyleItem.js';
+import { markVolatile } from '../../vcsModule.js';
+
+export type FlightVisualization = {
+  readonly state: LayerState;
+  readonly stateChanged: VcsEvent<LayerState>;
+  readonly destroyed: VcsEvent<void>;
+  deactivate(): void;
+  activate(): Promise<void>;
+  destroy(): void;
+  zoomToExtent(): Promise<void>;
+};
+
+const flightVisualizationSymbol = Symbol('flightVisualization');
+export async function createFlightVisualization(
+  instance: FlightInstance & {
+    [flightVisualizationSymbol]?: FlightVisualization;
+  },
+  app: VcsApp,
+): Promise<FlightVisualization> {
+  check(instance, FlightInstance);
+  if (instance[flightVisualizationSymbol]) {
+    return instance[flightVisualizationSymbol];
+  }
+  await instance.initialize();
+  let extent = createEmpty();
+
+  const primitives = new PrimitiveCollection();
+  primitives.show = false;
+  const layer = new VectorLayer({
+    projection: wgs84Projection.toJSON(),
+    name: `flightLayer-${instance.name}`,
+    style: {
+      type: DeclarativeStyleItem.className,
+      declarativeStyle: {
+        // eslint-disable-next-line no-template-curly-in-string
+        labelText: '${title}',
+        image: 'false',
+        color: 'color("#333333")',
+        strokeWidth: '2',
+      },
+    },
+    vectorProperties: {
+      altitudeMode: 'absolute',
+    },
+  });
+  markVolatile(layer);
+
+  let scene: Scene | undefined;
+  const [cesiumMap] = app.maps.getByType(CesiumMap.className) as CesiumMap[];
+  if (cesiumMap) {
+    scene = cesiumMap.getScene();
+    if (scene && !scene.primitives.contains(primitives)) {
+      scene.primitives.add(primitives);
+    }
+  }
+
+  app.layers.add(layer);
+  const setFeatures = (): void => {
+    layer.removeAllFeatures();
+    primitives.removeAll();
+
+    const features: Feature<Point | LineString>[] = [];
+    for (const anchor of instance.anchors) {
+      if (scene) {
+        const camera = new Camera(scene);
+        camera.frustum.far = 200;
+        camera.frustum.near = 10;
+        camera.setView({
+          destination: Cartesian3.fromDegrees(
+            anchor.coordinate[0],
+            anchor.coordinate[1],
+            anchor.coordinate[2],
+          ),
+          orientation: HeadingPitchRoll.fromDegrees(
+            anchor.heading,
+            anchor.pitch,
+            anchor.roll,
+          ),
+        });
+        primitives.add(new VcsCameraPrimitive({ camera, allowPicking: false }));
+      }
+
+      features.push(
+        new Feature({
+          geometry: new Point(anchor.coordinate, 'XYZ'),
+          title: anchor.title ?? anchor.name,
+          duration: anchor.duration,
+        }),
+      );
+    }
+
+    if (instance.isValid()) {
+      const pathCoordinates = getFlightPathCoordinatesFromInstance(instance);
+
+      const flightPath = new Feature({
+        geometry: new LineString(pathCoordinates, 'XYZ'),
+      });
+      flightPath.setId('flightPathGeom');
+
+      features.push(flightPath);
+    }
+
+    layer.addFeatures(features);
+    const mercatorExtent = layer.getSource().getExtent();
+    extent = mercatorToWgs84Transformer(mercatorExtent, mercatorExtent, 2);
+  };
+  setFeatures();
+
+  const changeListeners = [
+    instance.anchorsChanged.addEventListener(setFeatures),
+    instance.propertyChanged.addEventListener((property) => {
+      if (property === 'loop' || property === 'interpolation') {
+        setFeatures();
+      }
+    }),
+  ];
+
+  const destroyed = new VcsEvent<void>();
+  const destroy = (): void => {
+    layer.deactivate();
+    app.layers.remove(layer);
+    layer.destroy();
+
+    if (scene && scene.primitives.contains(primitives)) {
+      scene.primitives.remove(primitives);
+    }
+    changeListeners.forEach((cb) => {
+      cb();
+    });
+    destroyed.raiseEvent();
+    destroyed.destroy();
+    delete instance[flightVisualizationSymbol];
+  };
+
+  changeListeners.push(
+    app.flights.removed.addEventListener((flight) => {
+      if (flight === instance) {
+        destroy();
+      }
+    }),
+    app.flights.added.addEventListener((flight) => {
+      if (flight.name === instance.name) {
+        destroy();
+      }
+    }),
+  );
+
+  const visualization: FlightVisualization = {
+    get state(): LayerState {
+      return layer.state;
+    },
+    get stateChanged(): VcsEvent<LayerState> {
+      return layer.stateChanged;
+    },
+    get destroyed(): VcsEvent<void> {
+      return destroyed;
+    },
+    async activate(): Promise<void> {
+      await layer.activate();
+      primitives.show = true;
+    },
+    deactivate(): void {
+      layer.deactivate();
+      primitives.show = false;
+    },
+    destroy,
+    async zoomToExtent(): Promise<void> {
+      if (!instance.isValid() || isEmpty(extent)) {
+        return;
+      }
+      const viewpoint = Viewpoint.createViewpointFromExtent(extent);
+      if (viewpoint) {
+        await app.maps.activeMap?.gotoViewpoint(viewpoint);
+      }
+    },
+  };
+  instance[flightVisualizationSymbol] = visualization;
+  return visualization;
+}

package/src/util/hiddenObjects.ts

@@ -0,0 +1,35 @@
+import type GlobalHider from '../layer/globalHider.js';
+import makeOverrideCollection, {
+  OverrideCollection,
+} from './overrideCollection.js';
+import Collection from './collection.js';
+import { moduleIdSymbol } from '../moduleIdSymbol.js';
+
+export type HiddenObject = {
+  id: string;
+  [moduleIdSymbol]?: string;
+};
+
+export function createHiddenObjectsCollection(
+  getDynamicModuleId: () => string,
+  globalHider: GlobalHider,
+): OverrideCollection<HiddenObject> {
+  const collection = makeOverrideCollection<
+    HiddenObject,
+    Collection<HiddenObject>
+  >(new Collection<HiddenObject>('id'), getDynamicModuleId);
+
+  collection.added.addEventListener(({ id }) => {
+    globalHider.hideObjects([id]);
+  });
+
+  collection.replaced.addEventListener(({ new: item }) => {
+    globalHider.showObjects([item.id]);
+  });
+
+  collection.removed.addEventListener(({ id }) => {
+    globalHider.showObjects([id]);
+  });
+
+  return collection;
+}

package/src/util/mapCollection.ts

@@ -1,4 +1,4 @@
-import { check, checkMaybe } from '@vcsuite/check';
+import { check, maybe, oneOf } from '@vcsuite/check';
 import { getLogger } from '@vcsuite/logger';
 import VcsEvent from '../vcsEvent.js';
 import Collection from './collection.js';
@@ -240,7 +240,7 @@ class MapCollection extends Collection<VcsMap> {
    * Set the target for these maps.
    */
   setTarget(target: string | HTMLElement): void {
-    checkMaybe(target, [String, HTMLElement]);
+    check(target, maybe(oneOf(String, HTMLElement)));
 
     this._target =
       typeof target === 'string' ? document.getElementById(target) : target;

package/src/util/overrideCollection.ts

@@ -27,14 +27,19 @@ export type OverrideCollectionItem = {
 /**
  * The override collection adds the ability to override a unique item and re-creating it, should the override
  * be removed. This does change some flow of called events. 1) if you override an item, removed is not called for the
- * removed current item. 2) added can be called more the once for the same unique id. 3) replaced is called for items
- * which where replaced. replaced is called after added has been called for the item.
+ * removed current item. 2) replaced is called for items which where replaced. 3) added can be called more the once for the same unique id.
+ * Replaced is called before added has been called for the item.
  */
 export type OverrideCollectionInterface<T> = {
   /**
-   * replaced is called after added
+   * replaced is called before added
    */
   replaced: VcsEvent<ReplacedEvent<T>>;
+  /**
+   * Replacement is only supported for items of the dynamic module. For other items you may use override instead.
+   * Returns the replaced item or null if the item could not be inserted
+   */
+  replace: (item: T) => T | null;
   shadowMap: Map<string, (object & { [moduleIdSymbol]?: string })[]>;
   /**
    * returns the overriden item or null if the item could not be inserted (this would be the result of a race condition)
@@ -104,6 +109,24 @@ function makeOverrideCollection<
 
   overrideCollection.shadowMap = new Map();
 
+  overrideCollection.replace = function replace(item: T): T | null {
+    const itemId = item[overrideCollection.uniqueKey] as string;
+    const old = overrideCollection.getByKey(itemId);
+    if (old?.[moduleIdSymbol] === getDynamicModuleId()) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      // eslint-disable-next-line no-underscore-dangle
+      const index = overrideCollection._remove(old);
+      overrideCollection.replaced.raiseEvent({ old, new: item });
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      if ((overrideCollection.add(item, index) as number) >= 0) {
+        return item;
+      }
+    }
+    return null;
+  };
+
   overrideCollection.override = function override(item: T): T | null {
     let shadow;
     let index;

package/src/util/projection.ts

@@ -7,7 +7,7 @@ import {
 import { register } from 'ol/proj/proj4.js';
 import type { Coordinate } from 'ol/coordinate.js';
 import proj4 from 'proj4';
-import { check } from '@vcsuite/check';
+import { check, maybe, oneOf } from '@vcsuite/check';
 
 export type ProjectionOptions = {
   type?: string;
@@ -102,7 +102,10 @@ function registerProjection(options: ProjectionOptions): ProjectionOptions {
  * projection created prior to this functions call.
  */
 export function setDefaultProjectionOptions(options: ProjectionOptions): void {
-  check(options, { epsg: [String, Number], proj4: [String, undefined, null] });
+  check(options, {
+    epsg: oneOf(String, Number),
+    proj4: maybe(String),
+  });
   if (!validateProjectionOptions(options)) {
     throw new Error('Cannot set invalid projection options as default options');
   }