@vcmap/core 5.0.3 → 5.1.0-rc.2

package/src/util/featureconverter/circleToCesium.ts

@@ -105,19 +105,25 @@ export function createLineGeometries(
  * extracts the center and radius from the CircleGeometry and converts it to Cartesian3/radius in m
  * @param  geometry
  * @param  positionHeightAdjustment
- * @returns }
+ * @param  perPositionHeight
+ * @param  groundLevelOrMinHeight
+ * @returns
  * @private
  */
 export function getGeometryOptions(
   geometry: Circle,
   positionHeightAdjustment: number,
+  perPositionHeight: boolean,
+  groundLevelOrMinHeight: number,
 ): ConstructorParameters<typeof CircleGeometry>[0] {
   // olCoordinates of center and radius in WGS84
   const olCenter = geometry.getCenter();
   const olPoint = olCenter.slice();
   olPoint[0] += geometry.getRadius();
   const wgs84Center = Projection.mercatorToWgs84(olCenter, true);
-  if (wgs84Center[2] != null) {
+  if (!perPositionHeight && groundLevelOrMinHeight) {
+    wgs84Center[2] = groundLevelOrMinHeight;
+  } else if (wgs84Center[2] != null) {
     wgs84Center[2] += positionHeightAdjustment;
   }
 

package/src/util/featureconverter/extent3D.ts

@@ -13,7 +13,7 @@ class Extent3D {
   static fromArray(
     array: [number, number, number, number, number, number],
   ): Extent3D {
-    check(array, [Number]);
+    check(array as [number, number, number, number, number, number], [Number]);
     check(array.length, 6);
     return new Extent3D(
       array[0],

package/src/util/featureconverter/featureconverterHelper.ts

@@ -520,6 +520,8 @@ export function addPrimitivesToContext(
     const geometryOptions = geometryFactory.getGeometryOptions(
       geometry,
       heightInfo.heightAboveGroundAdjustment,
+      heightInfo.perPositionHeight,
+      heightInfo.groundLevel,
     );
     const storeyOptions = getStoreyOptions(
       heightInfo.storeyHeightsAboveGround,
@@ -609,11 +611,7 @@ export function addPrimitivesToContext(
           );
         } else {
           lineGeometries.push(
-            ...geometryFactory.createLineGeometries(
-              geometryOptions,
-              style,
-              heightInfo.groundLevel,
-            ),
+            ...geometryFactory.createLineGeometries(geometryOptions, style),
           );
         }
       }

package/src/util/featureconverter/lineStringToCesium.ts

@@ -185,6 +185,7 @@ export function createLineGeometries(
   style: Style,
 ): PolylineGeometry[] {
   const width = parseNumber(style.getStroke().getWidth(), 1.0);
+
   return [
     new PolylineGeometry({
       ...options,
@@ -197,16 +198,22 @@ export function createLineGeometries(
  * Creates the positions array for PolylineGeometry
  * @param  geometry
  * @param  positionHeightAdjustment
+ * @param  perPositionHeight
+ * @param  groundLevelOrMinHeight
  * @private
  */
 export function getGeometryOptions(
   geometry: LineString,
   positionHeightAdjustment: number,
+  perPositionHeight: boolean,
+  groundLevelOrMinHeight: number,
 ): LineGeometryOptions {
   const coords = geometry.getCoordinates();
   const positions = coords.map((coord) => {
     const wgs84Coords = Projection.mercatorToWgs84(coord);
-    if (wgs84Coords[2] != null) {
+    if (!perPositionHeight && groundLevelOrMinHeight) {
+      wgs84Coords[2] = groundLevelOrMinHeight;
+    } else if (wgs84Coords[2] != null) {
       wgs84Coords[2] += positionHeightAdjustment;
     }
     return Cartesian3.fromDegrees(

package/src/util/featureconverter/pointToCesium.ts

@@ -228,7 +228,7 @@ export function getCartesian3AndWGS84FromCoordinates(
     wgs84Positions[index] = Projection.mercatorToWgs84(coord, true);
     let height = null;
     if (heightInfo.heightReference === HeightReference.RELATIVE_TO_GROUND) {
-      height = heightInfo.heightAboveGroundAdjustment;
+      height = heightValue + heightInfo.heightAboveGroundAdjustment;
     } else {
       height = heightValue;
     }

package/src/util/featureconverter/polygonToCesium.ts

@@ -7,7 +7,6 @@ import {
   PolygonHierarchy,
   PolylineGeometry,
   type Scene,
-  Cartographic,
 } from '@vcmap-cesium/engine';
 import type { Style } from 'ol/style.js';
 import type { Polygon } from 'ol/geom.js';
@@ -74,7 +73,6 @@ export function createFillGeometries(
 export function getLineGeometryOptions(
   options: PolygonGeometryOptions,
   style: Style,
-  groundLevel?: number,
 ): PolylineGeometryOptions[] {
   const width = parseNumber(style.getStroke().getWidth(), 1.0);
   const geometryOptions: PolylineGeometryOptions[] = [];
@@ -90,16 +88,6 @@ export function getLineGeometryOptions(
       width,
     });
   });
-
-  if (groundLevel) {
-    geometryOptions.forEach((polylineOptions) => {
-      polylineOptions.positions = polylineOptions.positions.map((c) => {
-        const geographic = Cartographic.fromCartesian(c);
-        geographic.height = groundLevel;
-        return Cartographic.toCartesian(geographic);
-      });
-    });
-  }
   return geometryOptions;
 }
 
@@ -114,9 +102,8 @@ export function createGroundLineGeometries(
 export function createLineGeometries(
   options: PolygonGeometryOptions,
   style: Style,
-  groundLevel?: number,
 ): PolylineGeometry[] {
-  return getLineGeometryOptions(options, style, groundLevel).map((option) => {
+  return getLineGeometryOptions(options, style).map((option) => {
     return new PolylineGeometry(option);
   });
 }
@@ -124,6 +111,8 @@ export function createLineGeometries(
 export function getGeometryOptions(
   geometry: Polygon,
   positionHeightAdjustment: number,
+  perPositionHeight: boolean,
+  groundLevelOrMinHeight: number,
 ): PolygonGeometryOptions {
   let hieraryPositions;
   const holes = [];
@@ -132,7 +121,9 @@ export function getGeometryOptions(
     const coords = rings[i].getCoordinates();
     const positions = coords.map((coord) => {
       const wgs84Coords = Projection.mercatorToWgs84(coord);
-      if (wgs84Coords[2] != null) {
+      if (!perPositionHeight && groundLevelOrMinHeight) {
+        wgs84Coords[2] = groundLevelOrMinHeight;
+      } else if (wgs84Coords[2] != null) {
         wgs84Coords[2] += positionHeightAdjustment;
       }
       return Cartesian3.fromDegrees(

package/src/util/fetch.ts

@@ -1,3 +1,5 @@
+import { TrustedServers } from '@vcmap-cesium/engine';
+
 export async function requestUrl(
   url: string,
   init?: RequestInit,
@@ -26,3 +28,26 @@ export async function requestArrayBuffer(
   const response = await requestUrl(url, init);
   return response.arrayBuffer();
 }
+
+export async function requestObjectUrl(
+  url: string,
+  init?: RequestInit,
+): Promise<string> {
+  const response = await requestUrl(url, init);
+  const blob = await response.blob();
+  return URL.createObjectURL(blob);
+}
+
+export function getInitForUrl(
+  url: string,
+  headers?: Record<string, string>,
+): RequestInit {
+  const init: RequestInit = {};
+  if (headers) {
+    init.headers = headers;
+  }
+  if (TrustedServers.contains(url)) {
+    init.credentials = 'include';
+  }
+  return init;
+}

package/src/util/flight/flightAnchor.ts

@@ -0,0 +1,195 @@
+import { check, is, maybe, PatternFor } from '@vcsuite/check';
+import { v4 as uuidv4 } from 'uuid';
+import type { Feature as GeojsonFeature, Point as GeojsonPoint } from 'geojson';
+import { type Coordinate, equals as coordinateEquals } from 'ol/coordinate.js';
+import VcsEvent from '../../vcsEvent.js';
+import Viewpoint from '../viewpoint.js';
+
+type FlightAnchorFeatureProperties = {
+  heading: number;
+  pitch: number;
+  roll: number;
+  duration: number;
+  title?: string;
+};
+
+export type FlightAnchorGeojsonFeature = GeojsonFeature<
+  GeojsonPoint,
+  FlightAnchorFeatureProperties
+>;
+
+export type FlightAnchor = FlightAnchorFeatureProperties & {
+  readonly changed: VcsEvent<void>;
+  readonly name: string;
+  coordinate: Coordinate;
+  destroy(): void;
+};
+
+type FlightAnchorOptions = Omit<FlightAnchor, 'changed' | 'destroy'>;
+
+const flightAnchorOptionsPattern: PatternFor<FlightAnchorOptions> = {
+  name: String,
+  coordinate: [Number],
+  heading: Number,
+  pitch: Number,
+  roll: Number,
+  duration: Number,
+  title: maybe(String),
+};
+
+function isOptions(options: unknown): options is FlightAnchorOptions {
+  return (
+    is(options, flightAnchorOptionsPattern) && options.coordinate.length === 3
+  );
+}
+
+function fromOptions(options: FlightAnchorOptions): FlightAnchor {
+  check(options, flightAnchorOptionsPattern);
+
+  const changed = new VcsEvent<void>();
+  const { name } = options;
+  let { title, heading, pitch, roll, coordinate, duration } = options;
+  coordinate = coordinate.slice();
+
+  return {
+    get changed(): VcsEvent<void> {
+      return changed;
+    },
+    get name(): string {
+      return name;
+    },
+    get coordinate(): Coordinate {
+      return coordinate;
+    },
+    set coordinate(value: Coordinate) {
+      check(value, [Number]);
+      check(value.length, 3);
+
+      if (!coordinateEquals(coordinate, value)) {
+        coordinate = value.slice();
+        changed.raiseEvent();
+      }
+    },
+    get heading(): number {
+      return heading;
+    },
+    set heading(value: number) {
+      check(value, Number);
+      if (heading !== value) {
+        heading = value;
+        changed.raiseEvent();
+      }
+    },
+    get pitch(): number {
+      return pitch;
+    },
+    set pitch(value: number) {
+      check(value, Number);
+      if (pitch !== value) {
+        pitch = value;
+        changed.raiseEvent();
+      }
+    },
+    get roll(): number {
+      return roll;
+    },
+    set roll(value: number) {
+      check(value, Number);
+      if (roll !== value) {
+        roll = value;
+        changed.raiseEvent();
+      }
+    },
+    get duration(): number {
+      return duration;
+    },
+    set duration(value: number) {
+      check(value, Number);
+      if (duration !== value) {
+        duration = value;
+        changed.raiseEvent();
+      }
+    },
+    get title(): string | undefined {
+      return title;
+    },
+    set title(value: string | undefined) {
+      check(value, maybe(String));
+
+      if (title !== value) {
+        title = value;
+        changed.raiseEvent();
+      }
+    },
+    destroy(): void {
+      changed.destroy();
+    },
+  };
+}
+
+export function anchorFromViewpoint(
+  viewpoint: Viewpoint,
+): FlightAnchor | undefined {
+  if (!viewpoint.cameraPosition) {
+    return undefined;
+  }
+
+  return fromOptions({
+    ...viewpoint,
+    coordinate: viewpoint.cameraPosition,
+    duration: viewpoint.duration ?? 1,
+    title: viewpoint.properties.title as string | undefined,
+  });
+}
+
+export function anchorFromGeojsonFeature(
+  feature: FlightAnchorGeojsonFeature,
+): FlightAnchor | undefined {
+  const options = {
+    ...feature.properties,
+    name: String(feature.id) || uuidv4(),
+    coordinate: feature.geometry.coordinates,
+  };
+  if (isOptions(options)) {
+    return fromOptions(options);
+  }
+  return undefined;
+}
+
+export function anchorToViewpoint(anchor: FlightAnchor): Viewpoint {
+  return new Viewpoint({
+    name: anchor.name,
+    cameraPosition: anchor.coordinate.slice(),
+    heading: anchor.heading,
+    pitch: anchor.pitch,
+    roll: anchor.roll,
+    duration: anchor.duration,
+    properties: {
+      title: anchor.title,
+    },
+  });
+}
+
+export function anchorToGeojsonFeature(
+  anchor: FlightAnchor,
+): FlightAnchorGeojsonFeature {
+  const properties: FlightAnchorFeatureProperties = {
+    heading: anchor.heading,
+    pitch: anchor.pitch,
+    roll: anchor.roll,
+    duration: anchor.duration,
+  };
+  if (anchor.title) {
+    properties.title = anchor.title;
+  }
+
+  return {
+    type: 'Feature',
+    id: anchor.name,
+    geometry: {
+      type: 'Point',
+      coordinates: anchor.coordinate.slice(),
+    },
+    properties,
+  };
+}

package/src/util/flight/flightCollection.ts

@@ -0,0 +1,78 @@
+import Collection from '../collection.js';
+import { createFlightPlayer, FlightPlayer } from './flightPlayer.js';
+import VcsEvent from '../../vcsEvent.js';
+import FlightInstance from './flightInstance.js';
+import type VcsApp from '../../vcsApp.js';
+
+/**
+ * A collection of flights. Provides playFlight API, which returns a FlightPlayer.
+ * Emits playerChanged event, whenever another flight is played.
+ */
+class FlightCollection extends Collection<FlightInstance> {
+  private readonly _app: VcsApp;
+
+  private _player: FlightPlayer | undefined;
+
+  playerChanged: VcsEvent<FlightPlayer | undefined>;
+
+  private _playerDestroyedListener: () => void;
+
+  constructor(app: VcsApp) {
+    super();
+
+    this._app = app;
+    this._player = undefined;
+    this.playerChanged = new VcsEvent<FlightPlayer | undefined>();
+    this._playerDestroyedListener = (): void => {};
+  }
+
+  get player(): FlightPlayer | undefined {
+    return this._player;
+  }
+
+  remove(item: FlightInstance): void {
+    if (this._player?.flightInstanceName === item.name) {
+      this._player.stop();
+      this._player.destroy();
+    }
+    super.remove(item);
+  }
+
+  /**
+   * Creates a FlightPlayer for a flight instance, if not already existing for provided instance
+   * @param flight
+   */
+  async setPlayerForFlight(
+    flight: FlightInstance,
+  ): Promise<FlightPlayer | undefined> {
+    if (this._player?.flightInstanceName === flight.name) {
+      return this._player;
+    } else if (this._player) {
+      this._playerDestroyedListener();
+      this._player.stop();
+      this._player.destroy();
+    }
+    this._player = await createFlightPlayer(flight, this._app);
+    this.playerChanged.raiseEvent(this._player);
+    this._playerDestroyedListener = this._player.destroyed.addEventListener(
+      () => {
+        this._player = undefined;
+        this.playerChanged.raiseEvent(undefined);
+      },
+    );
+    return this._player;
+  }
+
+  destroy(): void {
+    if (this._player) {
+      this._player.stop();
+      this._player.destroy();
+      this._player = undefined;
+    }
+    this.playerChanged.destroy();
+    this._playerDestroyedListener();
+    super.destroy();
+  }
+}
+
+export default FlightCollection;

package/src/util/flight/flightHelpers.ts

@@ -0,0 +1,208 @@
+import {
+  HeadingPitchRoll,
+  Cartesian3,
+  Quaternion,
+  CatmullRomSpline,
+  LinearSpline,
+  QuaternionSpline,
+  Cartographic,
+  Math as CesiumMath,
+} from '@vcmap-cesium/engine';
+import type {
+  FeatureCollection,
+  Point as GeojsonPoint,
+  LineString as GeojsonLineString,
+} from 'geojson';
+import type { Coordinate } from 'ol/coordinate.js';
+import type {
+  // eslint-disable-next-line import/no-named-default
+  default as FlightInstance,
+  FlightInstanceMeta,
+  FlightInstanceOptions,
+} from './flightInstance.js';
+import { vcsMetaVersion } from '../../layer/vectorProperties.js';
+import { FlightAnchorGeojsonFeature } from './flightAnchor.js';
+
+/**
+ * exports a flight as GeoJson FeatureCollection
+ * {Object} vcsMeta.flightOptions: flight settings
+ * {Array} feature: viewpoints
+ *
+ * @param flightInstance
+ */
+export function exportFlightAsGeoJson(
+  flightInstance: FlightInstance,
+): FeatureCollection<GeojsonPoint> {
+  const options = flightInstance.toJSON();
+  const flightOptions: FlightInstanceMeta = {};
+  if (options.loop != null) {
+    flightOptions.loop = options.loop;
+  }
+  if (options.interpolation != null) {
+    flightOptions.interpolation = options.interpolation;
+  }
+  if (options.multiplier != null) {
+    flightOptions.multiplier = options.multiplier;
+  }
+
+  return {
+    type: 'FeatureCollection',
+    features: options.anchors ?? [],
+    vcsMeta: {
+      version: vcsMetaVersion,
+      flightOptions: options,
+    },
+  };
+}
+
+export function getSplineAndTimesForInstance(flightInstance: FlightInstance): {
+  destinationSpline: CatmullRomSpline | LinearSpline;
+  quaternionSpline: QuaternionSpline;
+  times: number[];
+} {
+  const { loop, anchors } = flightInstance;
+  const anchorsArray = [...anchors];
+  const length = loop ? anchors.size + 1 : anchors.size;
+  const points = new Array(length) as Cartesian3[];
+  const quaternions = new Array(length) as Quaternion[];
+  const times = new Array(length) as number[];
+
+  anchorsArray.forEach((anchor, index) => {
+    points[index] = Cartesian3.fromDegrees(
+      anchor.coordinate[0],
+      anchor.coordinate[1],
+      anchor.coordinate[2],
+    );
+    quaternions[index] = Quaternion.fromHeadingPitchRoll(
+      HeadingPitchRoll.fromDegrees(anchor.heading, anchor.pitch, anchor.roll),
+    );
+
+    if (index > 0) {
+      let previousDuration = anchorsArray[index - 1].duration;
+      if (!previousDuration) {
+        previousDuration =
+          Cartesian3.distance(points[index - 1], points[index]) / 300 || 1;
+      }
+      times[index] = times[index - 1] + previousDuration;
+    } else {
+      times[index] = 0;
+    }
+  });
+
+  if (loop) {
+    points[length - 1] = Cartesian3.fromDegrees(
+      anchorsArray[0].coordinate[0],
+      anchorsArray[0].coordinate[1],
+      anchorsArray[0].coordinate[2],
+    );
+    quaternions[length - 1] = Quaternion.fromHeadingPitchRoll(
+      HeadingPitchRoll.fromDegrees(
+        anchorsArray[0].heading,
+        anchorsArray[0].pitch,
+        anchorsArray[0].roll,
+      ),
+    );
+
+    let loopDuration = anchorsArray[length - 2].duration;
+    if (!loopDuration) {
+      loopDuration =
+        Cartesian3.distance(points[length - 2], points[length - 1]) / 300 || 1;
+    }
+    times[length - 1] = times[length - 2] + loopDuration;
+  }
+
+  const destinationSpline =
+    flightInstance.interpolation === 'spline'
+      ? new CatmullRomSpline({ times, points })
+      : new LinearSpline({ times, points });
+  const quaternionSpline = new QuaternionSpline({ times, points: quaternions });
+
+  return {
+    destinationSpline,
+    quaternionSpline,
+    times,
+  };
+}
+
+export function getFlightPathCoordinatesFromInstance(
+  flightInstance: FlightInstance,
+): Coordinate[] {
+  const pathCoordinates: Coordinate[] = [];
+
+  if (flightInstance.interpolation === 'spline') {
+    const { destinationSpline, times } =
+      getSplineAndTimesForInstance(flightInstance);
+    const scratchCartographic = new Cartographic();
+    const addCoordinateFromTime = (time: number): void => {
+      Cartographic.fromCartesian(
+        destinationSpline.evaluate(time) as Cartesian3,
+        undefined,
+        scratchCartographic,
+      );
+      pathCoordinates.push([
+        CesiumMath.toDegrees(scratchCartographic.longitude),
+        CesiumMath.toDegrees(scratchCartographic.latitude),
+        scratchCartographic.height,
+      ]);
+    };
+    const endTime = times[times.length - 1];
+    const step = endTime / 0.2 > 500 ? endTime / 500 : 0.2;
+    for (let i = 0; i < endTime; i += step) {
+      addCoordinateFromTime(i);
+    }
+    addCoordinateFromTime(endTime);
+  } else {
+    for (const anchor of flightInstance.anchors) {
+      pathCoordinates.push(anchor.coordinate);
+    }
+
+    if (flightInstance.loop) {
+      pathCoordinates.push(pathCoordinates[0]);
+    }
+  }
+
+  return pathCoordinates;
+}
+
+export function exportFlightPathAsGeoJson(
+  flightInstance: FlightInstance,
+): FeatureCollection<GeojsonLineString> {
+  const coordinates = getFlightPathCoordinatesFromInstance(flightInstance);
+
+  return {
+    type: 'FeatureCollection',
+    features: [
+      {
+        type: 'Feature',
+        geometry: {
+          type: 'LineString',
+          coordinates,
+        },
+        properties: {},
+      },
+    ],
+  };
+}
+
+/**
+ * parses source and creates a flight Object
+ * @param {Object} collection GeoJSON
+ * containing:
+ * {Object} vcsMeta containing flightOptions
+ * {Array} features anchors of flightInstance
+ * @returns
+ */
+export function parseFlightOptionsFromGeoJson(
+  collection: FeatureCollection<
+    GeojsonPoint,
+    FlightAnchorGeojsonFeature['properties']
+  >,
+): FlightInstanceOptions {
+  const flightOptions: Partial<FlightInstanceOptions> =
+    collection.vcsMeta && collection.vcsMeta.flightOptions
+      ? collection.vcsMeta.flightOptions
+      : {};
+
+  flightOptions.anchors = collection.features;
+  return flightOptions;
+}