@vcmap/core 5.0.3 → 5.1.0-rc.2

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');
   }

package/src/util/viewpoint.ts

@@ -1,4 +1,5 @@
 import type { Coordinate } from 'ol/coordinate.js';
+import { containsCoordinate } from 'ol/extent.js';
 import { EasingFunction } from '@vcmap-cesium/engine';
 import { parseBoolean, parseNumber } from '@vcsuite/parsers';
 import Projection, { wgs84Projection } from './projection.js';
@@ -159,12 +160,27 @@ class Viewpoint extends VcsObject {
    */
   easingFunctionName: string | undefined;
 
+  static getDefaultOptions(): ViewpointOptions {
+    return {
+      cameraPosition: undefined,
+      groundPosition: undefined,
+      distance: 1000,
+      heading: 0,
+      pitch: -90,
+      roll: 0,
+      animate: false,
+      duration: undefined,
+      easingFunctionName: undefined,
+    };
+  }
+
   /**
    * @param  options
    */
   constructor(options: ViewpointOptions) {
     super(options);
 
+    const defaultOptions = Viewpoint.getDefaultOptions();
     this.cameraPosition = null;
     if (
       Array.isArray(options.cameraPosition) &&
@@ -179,12 +195,12 @@ class Viewpoint extends VcsObject {
     }
     this.distance = parseNumber(
       options.distance,
-      this.cameraPosition ? this.cameraPosition[2] : 1000,
+      this.cameraPosition ? this.cameraPosition[2] : defaultOptions.distance,
     );
-    this.heading = parseNumber(options.heading, 0);
-    this.pitch = parseNumber(options.pitch, -90);
-    this.roll = parseNumber(options.roll, 0);
-    this.animate = parseBoolean(options.animate, false);
+    this.heading = parseNumber(options.heading, defaultOptions.heading);
+    this.pitch = parseNumber(options.pitch, defaultOptions.pitch);
+    this.roll = parseNumber(options.roll, defaultOptions.roll);
+    this.animate = parseBoolean(options.animate, defaultOptions.animate);
     this.duration = parseNumber(options.duration);
     this.easingFunctionName = options.easingFunctionName;
   }
@@ -341,13 +357,17 @@ class Viewpoint extends VcsObject {
       this.cameraPosition &&
       Array.isArray(this.cameraPosition) &&
       this.cameraPosition.length === 3 &&
-      this.cameraPosition.every((position) => Number.isFinite(position));
+      this.cameraPosition.every((position) => Number.isFinite(position)) &&
+      containsCoordinate(Extent.WGS_84_EXTENT, this.cameraPosition);
+
     const hasGround =
       this.groundPosition &&
       Array.isArray(this.groundPosition) &&
       this.groundPosition.length > 1 &&
       this.groundPosition.length < 4 &&
-      this.groundPosition.every((position) => Number.isFinite(position));
+      this.groundPosition.every((position) => Number.isFinite(position)) &&
+      containsCoordinate(Extent.WGS_84_EXTENT, this.groundPosition);
+
     if (!hasGround && !hasCamera) {
       return false;
     }

package/src/vcsApp.ts

@@ -42,6 +42,14 @@ import type LayerCollection from './util/layerCollection.js';
 import type Category from './category/category.js';
 import type TileProvider from './layer/tileProvider/tileProvider.js';
 import type AbstractFeatureProvider from './featureProvider/abstractFeatureProvider.js';
+import {
+  createHiddenObjectsCollection,
+  HiddenObject,
+} from './util/hiddenObjects.js';
+import FlightInstance, {
+  FlightInstanceOptions,
+} from './util/flight/flightInstance.js';
+import FlightCollection from './util/flight/flightCollection.js';
 
 function getLogger(): Logger {
   return getLoggerByName('init');
@@ -104,7 +112,11 @@ class VcsApp {
 
   private _modules: IndexedCollection<VcsModule>;
 
-  private _categoryClassRegisty: OverrideClassRegistry<typeof Category>;
+  private _hiddenObjects: OverrideCollection<HiddenObject>;
+
+  private _flights: OverrideCollection<FlightInstance, FlightCollection>;
+
+  private _categoryClassRegistry: OverrideClassRegistry<typeof Category>;
 
   private _categories: CategoryCollection;
 
@@ -114,11 +126,11 @@ class VcsApp {
 
   private _categoryItemClassRegistry: OverrideClassRegistry<Ctor<any>>;
 
-  private _tileProviderClassRegsitry: OverrideClassRegistry<
+  private _tileProviderClassRegistry: OverrideClassRegistry<
     typeof TileProvider
   >;
 
-  private _featureProviderClassRegsitry: OverrideClassRegistry<
+  private _featureProviderClassRegistry: OverrideClassRegistry<
     typeof AbstractFeatureProvider
   >;
 
@@ -186,7 +198,20 @@ class VcsApp {
     this._modules = new IndexedCollection('_id');
     this._modules.add(this._dynamicModule);
 
-    this._categoryClassRegisty = new OverrideClassRegistry(
+    this._hiddenObjects = createHiddenObjectsCollection(
+      getDynamicModuleId,
+      this._layers.globalHider,
+    );
+
+    this._flights = makeOverrideCollection(
+      new FlightCollection(this),
+      getDynamicModuleId,
+      undefined,
+      (flightOptions: FlightInstanceOptions) =>
+        new FlightInstance(flightOptions),
+    );
+
+    this._categoryClassRegistry = new OverrideClassRegistry(
       categoryClassRegistry,
     );
     this._categories = new CategoryCollection(this);
@@ -195,10 +220,10 @@ class VcsApp {
     this._categoryItemClassRegistry = new OverrideClassRegistry(
       new ClassRegistry(),
     );
-    this._tileProviderClassRegsitry = new OverrideClassRegistry(
+    this._tileProviderClassRegistry = new OverrideClassRegistry(
       tileProviderClassRegistry,
     );
-    this._featureProviderClassRegsitry = new OverrideClassRegistry(
+    this._featureProviderClassRegistry = new OverrideClassRegistry(
       featureProviderClassRegistry,
     );
 
@@ -262,6 +287,14 @@ class VcsApp {
     return this._categories;
   }
 
+  get hiddenObject(): OverrideCollection<HiddenObject> {
+    return this._hiddenObjects;
+  }
+
+  get flights(): OverrideCollection<FlightInstance, FlightCollection> {
+    return this._flights;
+  }
+
   get destroyed(): VcsEvent<void> {
     return this._destroyed;
   }
@@ -299,7 +332,7 @@ class VcsApp {
   }
 
   get categoryClassRegistry(): OverrideClassRegistry<typeof Category> {
-    return this._categoryClassRegisty;
+    return this._categoryClassRegistry;
   }
 
   get categoryItemClassRegistry(): OverrideClassRegistry<Ctor<any>> {
@@ -307,13 +340,13 @@ class VcsApp {
   }
 
   get tileProviderClassRegistry(): OverrideClassRegistry<typeof TileProvider> {
-    return this._tileProviderClassRegsitry;
+    return this._tileProviderClassRegistry;
   }
 
   get featureProviderClassRegistry(): OverrideClassRegistry<
     typeof AbstractFeatureProvider
   > {
-    return this._featureProviderClassRegsitry;
+    return this._featureProviderClassRegistry;
   }
 
   getModuleById(id: string): VcsModule | undefined {
@@ -329,7 +362,7 @@ class VcsApp {
 
     await this._styles.parseItems(config.styles, module._id);
     await this._layers.parseItems(config.layers, module._id);
-    // TODO add flights & ade here
+    // TODO add ade here
 
     await this._obliqueCollections.parseItems(
       config.obliqueCollections,
@@ -337,6 +370,8 @@ class VcsApp {
     );
     await this._viewpoints.parseItems(config.viewpoints, module._id);
     await this._maps.parseItems(config.maps, module._id);
+    await this._hiddenObjects.parseItems(config.hiddenObjects, module._id);
+    await this._flights.parseItems(config.flights, module._id);
 
     if (Array.isArray(config.categories)) {
       await Promise.all(
@@ -358,8 +393,6 @@ class VcsApp {
               `Failed to activate active on startup layer ${l.name}`,
             );
             getLogger().error(String(err));
-            this._layers.remove(l);
-            l.destroy();
           });
         }
       });
@@ -424,6 +457,10 @@ class VcsApp {
       this._obliqueCollections.serializeModule(moduleId);
     config.viewpoints = this._viewpoints.serializeModule(moduleId);
     config.styles = this._styles.serializeModule(moduleId);
+    config.hiddenObjects = this._hiddenObjects.serializeModule(
+      moduleId,
+    ) as HiddenObject[];
+    config.flights = this._flights.serializeModule(moduleId);
     config.categories = [...this._categories]
       .map((c) => c.serializeModule(moduleId))
       .filter((c) => !!c) as { name: string; items: object[] }[];
@@ -461,6 +498,8 @@ class VcsApp {
       this._viewpoints.removeModule(moduleId),
       this._styles.removeModule(moduleId),
       this._obliqueCollections.removeModule(moduleId),
+      this._hiddenObjects.removeModule(moduleId),
+      this._flights.removeModule(moduleId),
     ]);
   }
 
@@ -494,13 +533,15 @@ class VcsApp {
     destroyCollection(this._viewpoints);
     destroyCollection(this._styles);
     destroyCollection(this._categories);
+    this._modules.destroy();
+    this._hiddenObjects.destroy();
     this._mapClassRegistry.destroy();
     this._layerClassRegistry.destroy();
     this._styleClassRegistry.destroy();
-    this._categoryClassRegisty.destroy();
+    this._categoryClassRegistry.destroy();
     this._categoryItemClassRegistry.destroy();
-    this._tileProviderClassRegsitry.destroy();
-    this._featureProviderClassRegsitry.destroy();
+    this._tileProviderClassRegistry.destroy();
+    this._featureProviderClassRegistry.destroy();
     this.destroyed.raiseEvent();
     this.destroyed.destroy();
     this.localeChanged.destroy();

package/src/vcsModule.ts

@@ -7,6 +7,8 @@ import type { ViewpointOptions } from './util/viewpoint.js';
 import type { ObliqueCollectionOptions } from './oblique/obliqueCollection.js';
 import type VcsApp from './vcsApp.js';
 import { moduleIdSymbol } from './moduleIdSymbol.js';
+import { HiddenObject } from './util/hiddenObjects.js';
+import { FlightInstanceOptions } from './util/flight/flightInstance.js';
 
 export type VcsModuleConfig = {
   _id?: string | undefined;
@@ -23,6 +25,8 @@ export type VcsModuleConfig = {
   projection?: ProjectionOptions;
   obliqueCollections?: ObliqueCollectionOptions[];
   categories?: { name: string; items: object[] }[];
+  hiddenObjects?: HiddenObject[];
+  flights?: FlightInstanceOptions[];
 };
 
 /**