@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/util/editor/transformation/translateInteraction.ts

@@ -0,0 +1,248 @@
+import { Cartesian2, Plane, Scene, Transforms } from '@vcmap-cesium/engine';
+import type { Coordinate } from 'ol/coordinate.js';
+import type { Feature } from 'ol/index.js';
+
+import AbstractInteraction, {
+  EventAfterEventHandler,
+} from '../../../interaction/abstractInteraction.js';
+import { EventType } from '../../../interaction/interactionType.js';
+import { handlerSymbol } from '../editorSymbols.js';
+import {
+  createCameraVerticalPlane,
+  getCartographicFromPlane,
+  getClosestPointOn2DLine,
+} from '../editorHelpers.js';
+import VcsEvent from '../../../vcsEvent.js';
+import Projection, { mercatorProjection } from '../../projection.js';
+import { cartographicToWgs84, mercatorToCartesian } from '../../math.js';
+import {
+  AxisAndPlanes,
+  is1DAxis,
+  is2DAxis,
+  TransformationHandler,
+} from './transformationTypes.js';
+import CesiumMap from '../../../map/cesiumMap.js';
+
+/**
+ * Of type [dx, dy, dz];
+ */
+export type TranslateEvent = [number, number, number];
+
+type GetTranslateEvent = (
+  coord: Coordinate,
+  windowPosition: Cartesian2,
+) => TranslateEvent;
+
+/**
+ * A class to handle events on a {@link TransformationHandler}. Should be used with {@link TransformationHandler} created for mode TransformationMode.TRANSLATE.
+ * If the rings are dragged, the translated event will be raised.
+ * @extends {AbstractInteraction}
+ */
+class TranslateInteraction extends AbstractInteraction {
+  private _transformationHandler: TransformationHandler | null;
+
+  /**
+   * Event raised if the handlers are dragged. The resulting array is of type [dx, dy, dz] where all numbers
+   * are considered to be deltas to the previous event (where 0 means no translating).
+   */
+  readonly translated = new VcsEvent<TranslateEvent>();
+
+  private _getTranslateEvent: null | GetTranslateEvent = null;
+
+  constructor(transformationHandler: TransformationHandler) {
+    super(EventType.DRAGEVENTS);
+    this._transformationHandler = transformationHandler;
+  }
+
+  pipe(event: EventAfterEventHandler): Promise<EventAfterEventHandler> {
+    if (this._getTranslateEvent) {
+      this.translated.raiseEvent(
+        this._getTranslateEvent(event.positionOrPixel, event.windowPosition),
+      );
+      if (event.type === EventType.DRAGEND) {
+        this._getTranslateEvent = null;
+        this._transformationHandler!.showAxis = AxisAndPlanes.NONE;
+      }
+    } else if (
+      event.type === EventType.DRAGSTART &&
+      (event?.feature as Feature)?.[handlerSymbol]
+    ) {
+      const axis = (event.feature as Feature)[handlerSymbol] as AxisAndPlanes;
+      if (axis !== AxisAndPlanes.NONE) {
+        this._transformationHandler!.showAxis = axis;
+        if (event.map instanceof CesiumMap) {
+          if (is1DAxis(axis)) {
+            this._getTranslateEvent = this._dragAlongAxis3D(axis, event);
+          } else if (is2DAxis(axis)) {
+            this._getTranslateEvent = this._dragAlongPlane3D(axis, event);
+          }
+        } else if (is1DAxis(axis)) {
+          this._getTranslateEvent = this._dragAlongAxis2D(axis, event);
+        } else if (is2DAxis(axis)) {
+          this._getTranslateEvent = this._dragAlongPlane2D(axis, event);
+        }
+      }
+    }
+    return Promise.resolve(event);
+  }
+
+  private _dragAlongAxis3D(
+    axis: AxisAndPlanes,
+    event: EventAfterEventHandler,
+  ): GetTranslateEvent {
+    const scene = (event.map as CesiumMap).getScene() as Scene;
+    if (axis !== AxisAndPlanes.Z) {
+      const center = mercatorToCartesian(this._transformationHandler!.center);
+      let plane = Plane.clone(Plane.ORIGIN_XY_PLANE);
+      plane = Plane.transform(
+        plane,
+        Transforms.eastNorthUpToFixedFrame(center),
+        plane,
+      );
+      let cartographic = getCartographicFromPlane(
+        plane,
+        scene.camera,
+        event.windowPosition,
+      );
+      let currentPosition = Projection.wgs84ToMercator(
+        cartographicToWgs84(cartographic),
+      );
+      return (_c, windowPosition): TranslateEvent => {
+        cartographic = getCartographicFromPlane(
+          plane,
+          scene.camera,
+          windowPosition,
+        );
+        const newPosition = Projection.wgs84ToMercator(
+          cartographicToWgs84(cartographic),
+        );
+        const translate: TranslateEvent =
+          axis === AxisAndPlanes.X
+            ? [newPosition[0] - currentPosition[0], 0, 0]
+            : [0, newPosition[1] - currentPosition[1], 0];
+
+        currentPosition = newPosition;
+        return translate;
+      };
+    } else {
+      const plane = createCameraVerticalPlane(
+        this._transformationHandler!.center.slice(),
+        scene,
+      );
+      let currentHeight = getCartographicFromPlane(
+        plane,
+        scene.camera,
+        event.windowPosition,
+      ).height;
+      return (_c, windowPosition): TranslateEvent => {
+        const newHeight = getCartographicFromPlane(
+          plane,
+          scene.camera,
+          windowPosition,
+        ).height;
+        const translate: TranslateEvent = [0, 0, newHeight - currentHeight];
+        currentHeight = newHeight;
+        return translate;
+      };
+    }
+  }
+
+  private _dragAlongPlane3D(
+    axis: AxisAndPlanes,
+    event: EventAfterEventHandler,
+  ): GetTranslateEvent {
+    const scene = (event.map as CesiumMap).getScene() as Scene;
+    const center = mercatorToCartesian(this._transformationHandler!.center);
+    let plane: Plane;
+    if (axis === AxisAndPlanes.YZ) {
+      plane = Plane.clone(Plane.ORIGIN_YZ_PLANE);
+    } else if (axis === AxisAndPlanes.XZ) {
+      plane = Plane.clone(Plane.ORIGIN_ZX_PLANE);
+    } else {
+      plane = Plane.clone(Plane.ORIGIN_XY_PLANE);
+    }
+    plane = Plane.transform(
+      plane,
+      Transforms.eastNorthUpToFixedFrame(center),
+      plane,
+    );
+    let cartographic = getCartographicFromPlane(
+      plane,
+      scene.camera,
+      event.windowPosition,
+    );
+    let currentPosition = Projection.wgs84ToMercator(
+      cartographicToWgs84(cartographic),
+    );
+    return (_c, windowPosition): TranslateEvent => {
+      cartographic = getCartographicFromPlane(
+        plane,
+        scene.camera,
+        windowPosition,
+      );
+      const newPosition = Projection.wgs84ToMercator(
+        cartographicToWgs84(cartographic),
+      );
+
+      const translate: TranslateEvent = [
+        newPosition[0] - currentPosition[0],
+        newPosition[1] - currentPosition[1],
+        newPosition[2] - currentPosition[2],
+      ];
+      currentPosition = newPosition;
+      return translate;
+    };
+  }
+
+  private _dragAlongAxis2D(
+    axis: AxisAndPlanes,
+    event: EventAfterEventHandler,
+  ): GetTranslateEvent {
+    const center = this._transformationHandler!.center.slice();
+    const mercatorExtent = mercatorProjection.proj.getExtent();
+    const end =
+      axis === AxisAndPlanes.X
+        ? [mercatorExtent[0], center[1], center[2]]
+        : [center[0], mercatorExtent[1], center[2]];
+
+    let lastPointOnAxis = getClosestPointOn2DLine(
+      center,
+      end,
+      event.positionOrPixel,
+    );
+    return (coords): TranslateEvent => {
+      const newPointOnAxis = getClosestPointOn2DLine(center, end, coords);
+      const translate: TranslateEvent =
+        axis === AxisAndPlanes.X
+          ? [newPointOnAxis[0] - lastPointOnAxis[0], 0, 0]
+          : [0, newPointOnAxis[1] - lastPointOnAxis[1], 0];
+
+      lastPointOnAxis = newPointOnAxis;
+      return translate;
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  private _dragAlongPlane2D(
+    _axis: AxisAndPlanes,
+    event: EventAfterEventHandler,
+  ): GetTranslateEvent {
+    let current = event.positionOrPixel.slice();
+    return (coords): TranslateEvent => {
+      const translate: TranslateEvent = [
+        coords[0] - current[0],
+        coords[1] - current[1],
+        0,
+      ];
+      current = coords.slice();
+      return translate;
+    };
+  }
+
+  destroy(): void {
+    this._transformationHandler = null;
+    this.translated.destroy();
+  }
+}
+
+export default TranslateInteraction;

package/src/util/editor/validateGeoemetry.ts

@@ -0,0 +1,22 @@
+import type { Geometry, LineString, Polygon, Point, Circle } from 'ol/geom.js';
+import { validateLineString } from '../featureconverter/lineStringToCesium.js';
+import { validatePolygon } from '../featureconverter/polygonToCesium.js';
+import { validatePoint } from '../featureconverter/pointToCesium.js';
+import { validateCircle } from '../featureconverter/circleToCesium.js';
+
+export default function geometryIsValid(geometry?: Geometry): boolean {
+  if (!geometry) {
+    return false;
+  }
+  const type = geometry.getType();
+  if (type === 'LineString') {
+    return validateLineString(geometry as LineString);
+  } else if (type === 'Polygon') {
+    return validatePolygon(geometry as Polygon);
+  } else if (type === 'Point') {
+    return validatePoint(geometry as Point);
+  } else if (type === 'Circle') {
+    return validateCircle(geometry as Circle);
+  }
+  return false;
+}

package/src/util/{exclusiveManager.js → exclusiveManager.ts}

@@ -1,32 +1,25 @@
+// eslint-disable-next-line import/no-named-default
+import type { default as Layer, SplitLayer } from '../layer/layer.js';
+
 /**
  * Tracks layer exclusivity, added to every {@link LayerCollection}.
- * @class
- * @api
  */
 class ExclusiveManager {
-  constructor() {
-    /**
-     * The layers managed by this manager. The key is the group.
-     * @type {Map<(string|symbol), Set<import("@vcmap/core").Layer>>}
-     * @api
-     */
-    this.layers = new Map();
-  }
+  layers: Map<string | symbol, Set<Layer>> = new Map();
 
   /**
    * registers a Layer as Exclusive, the activation of a layer triggers the deactivation of all other exclusive Layers.
    * The layer collection adds exclusive layers to the manager on adding the layer to the collection.
-   * @param {import("@vcmap/core").Layer} layer - layer to register
-   * @api
+   * @param  layer - layer to register
    */
-  registerLayer(layer) {
+  registerLayer(layer: Layer): void {
     const { exclusiveGroups } = layer;
     if (exclusiveGroups.length > 0) {
       exclusiveGroups.forEach((group) => {
         if (!this.layers.has(group)) {
           this.layers.set(group, new Set());
         }
-        const groupSet = this.layers.get(group);
+        const groupSet = this.layers.get(group)!;
         groupSet.add(layer);
       });
 
@@ -38,22 +31,18 @@ class ExclusiveManager {
 
   /**
    * Removes a layer from tracking. Layer collections remove the layer once they are removed from them.
-   * @param {import("@vcmap/core").Layer} layer - layer to unregister
-   * @api
+   * @param  layer - layer to unregister
    */
-  unregisterLayer(layer) {
+  unregisterLayer(layer: Layer): void {
     const { exclusiveGroups } = layer;
     if (exclusiveGroups.length > 0) {
       exclusiveGroups.forEach((group) => {
-        this.layers.get(group).delete(layer);
+        this.layers.get(group)!.delete(layer);
       });
     }
   }
 
-  /**
-   * @param {import("@vcmap/core").Layer} layer
-   */
-  handleSplitDirectionChanged(layer) {
+  handleSplitDirectionChanged(layer: Layer): void {
     if (layer.active) {
       this.handleLayerActivated(layer);
     }
@@ -61,20 +50,22 @@ class ExclusiveManager {
 
   /**
    * handles the changing of a layer
-   * @param {import("@vcmap/core").Layer} layer
+   * @param  layer
    */
-  handleLayerActivated(layer) {
+  handleLayerActivated(layer: Layer): void {
     const { exclusiveGroups } = layer;
     if (exclusiveGroups.length > 0) {
-      const splitDirection = /** @type {SplitLayer} */ (layer).splitDirection || 0;
+      const splitDirection = (layer as Layer & SplitLayer).splitDirection || 0;
       exclusiveGroups.forEach((group) => {
         if (this.layers.has(group)) {
-          this.layers.get(group).forEach((groupLayer) => {
+          this.layers.get(group)!.forEach((groupLayer) => {
             if (
-              groupLayer !== layer && !(
+              groupLayer !== layer &&
+              !(
                 splitDirection &&
-                /** @type {SplitLayer} */ (groupLayer).splitDirection &&
-                /** @type {SplitLayer} */ (groupLayer).splitDirection !== splitDirection
+                (groupLayer as Layer & SplitLayer).splitDirection &&
+                (groupLayer as Layer & SplitLayer).splitDirection !==
+                  splitDirection
               )
             ) {
               groupLayer.deactivate();
@@ -85,10 +76,7 @@ class ExclusiveManager {
     }
   }
 
-  /**
-   * @param {import("@vcmap/core").Layer} layer
-   */
-  handleExclusiveGroupsChanged(layer) {
+  handleExclusiveGroupsChanged(layer: Layer): void {
     [...this.layers.values()].forEach((set) => {
       set.delete(layer);
     });
@@ -97,14 +85,12 @@ class ExclusiveManager {
 
   /**
    * Gets all layers in the given group
-   * @param {string} group
-   * @returns {Array<import("@vcmap/core").Layer>}
-   * @api
+   * @param  group
    */
-  getActiveLayersForGroup(group) {
+  getActiveLayersForGroup(group: string): Layer[] {
     const layerGroup = this.layers.get(group);
     if (layerGroup) {
-      const activeLayers = [];
+      const activeLayers: Layer[] = [];
       layerGroup.forEach((groupLayer) => {
         if (groupLayer.active) {
           activeLayers.push(groupLayer);
@@ -117,17 +103,15 @@ class ExclusiveManager {
 
   /**
    * Clears all layer groups
-   * @api
    */
-  clear() {
+  clear(): void {
     this.layers.clear();
   }
 
   /**
    * Destroys the ExclusiveManager
-   * @api
    */
-  destroy() {
+  destroy(): void {
     this.clear();
   }
 }

package/src/util/extent.ts

@@ -0,0 +1,114 @@
+import type { Extent as OLExtent } from 'ol/extent.js';
+import Projection, { type ProjectionOptions } from './projection.js';
+
+export type ExtentOptions = {
+  type?: string;
+  coordinates?: OLExtent;
+  projection?: ProjectionOptions;
+};
+
+/**
+ * checks extent validity, point extent is also valid
+ * @param  extent
+ */
+function checkExtentValidity(extent?: OLExtent): boolean {
+  if (!extent || !Array.isArray(extent) || extent.length !== 4) {
+    return false;
+  }
+
+  if (
+    !Number.isFinite(extent[0]) ||
+    !Number.isFinite(extent[1]) ||
+    !Number.isFinite(extent[2]) ||
+    !Number.isFinite(extent[3])
+  ) {
+    return false;
+  }
+  return extent[0] <= extent[2] && extent[1] <= extent[3];
+}
+
+/**
+ * Extent Class
+ */
+class Extent {
+  static get className(): string {
+    return 'Extent';
+  }
+
+  static get WGS_84_EXTENT(): OLExtent {
+    return [-180, -90, 180, 90];
+  }
+
+  /**
+   * validates extent options, checks for valid projection and the geometry of the given coordinates.
+   * The Coordinate extent is also valid if its a point extent
+   * @param  options
+   */
+  static validateOptions(options: ExtentOptions): boolean {
+    return (
+      Projection.validateOptions(options.projection || {}) &&
+      checkExtentValidity(options.coordinates)
+    );
+  }
+
+  projection: Projection;
+
+  extent: OLExtent;
+
+  constructor(options: ExtentOptions = {}) {
+    this.projection = new Projection(options.projection);
+    this.extent = options.coordinates || this.projection.proj.getExtent();
+  }
+
+  getCoordinatesInProjection(
+    destination: Projection,
+    result?: OLExtent,
+  ): OLExtent {
+    if (destination.epsg === this.projection.epsg) {
+      // TODO aliases?!
+      const extent = result
+        ? result.splice(0, 4, ...this.extent)
+        : this.extent.slice();
+      return extent;
+    }
+    const transformer = Projection.getTransformer(destination, this.projection);
+    const target = result || [];
+    transformer(this.extent, target, 2);
+    return target;
+  }
+
+  /**
+   * only checks for null/nan numbers, does not check for spatial validity of the extent
+   * @returns  true if extent is valid
+   */
+  isValid(): boolean {
+    return checkExtentValidity(this.extent);
+  }
+
+  toJSON(): ExtentOptions {
+    return {
+      coordinates: this.extent.slice(),
+      projection: this.projection.toJSON(),
+      type: Extent.className,
+    };
+  }
+
+  clone(): Extent {
+    return new Extent(this.toJSON());
+  }
+
+  equals(extent: Extent): boolean {
+    if (this === extent) {
+      return true;
+    }
+
+    return (
+      this.isValid() &&
+      extent.isValid() &&
+      this.extent.every((c, i) => c === extent.extent[i]) &&
+      this.projection.equals(extent.projection)
+    );
+  }
+}
+
+export default Extent;

package/src/util/featureconverter/arcToCesium.ts

@@ -0,0 +1,126 @@
+import {
+  ArcType,
+  Cartesian3,
+  HeightReference,
+  Scene,
+} from '@vcmap-cesium/engine';
+import type { Coordinate } from 'ol/coordinate.js';
+import type { LineString } from 'ol/geom.js';
+import type { Feature } from 'ol/index.js';
+
+import Projection from '../projection.js';
+import { addPrimitivesToContext } from './featureconverterHelper.js';
+import {
+  createFillGeometries,
+  createGroundLineGeometries,
+  createLineGeometries,
+  createOutlineGeometries,
+  createSolidGeometries,
+  validateLineString,
+  getCoordinates as getLineStringCoordinates,
+  getGeometryOptions as getLineStringGeometryOptions,
+  addArrowsToContext,
+} from './lineStringToCesium.js';
+import ArcStyle, { featureArcStruct } from '../../style/arcStyle.js';
+import { VectorGeometryFactoryType } from '../../layer/vectorLayer.js';
+import VectorProperties from '../../layer/vectorProperties.js';
+import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
+
+/**
+ * Creates the positions & arcType option for the PolylineGeometry
+ */
+export function getGeometryOptions(
+  coords: Coordinate[],
+  _geometry: LineString,
+  positionHeightAdjustment: number,
+): { positions: Cartesian3[]; arcType: ArcType } {
+  const positions = coords.map((coord) => {
+    const wgs84Coords = Projection.mercatorToWgs84(coord);
+    if (wgs84Coords[2] != null) {
+      wgs84Coords[2] += positionHeightAdjustment;
+    }
+    return Cartesian3.fromDegrees(
+      wgs84Coords[0],
+      wgs84Coords[1],
+      wgs84Coords[2],
+    );
+  });
+  return { positions, arcType: ArcType.NONE };
+}
+
+/**
+ * In this special case, the coordinates are not taken from the geometries array
+ */
+// eslint-disable-next-line no-unused-vars
+export function getCoordinates(
+  coords: Coordinate[],
+  _geometries: LineString[],
+): Coordinate[] {
+  return coords;
+}
+
+/**
+ * @param  arcCoords - the coordinates of the arc to use instead of the geometries coordinates if height mode is absolute
+ */
+function getGeometryFactory(
+  arcCoords: Coordinate[],
+  altitudeMode: HeightReference,
+): VectorGeometryFactoryType {
+  return {
+    getCoordinates:
+      altitudeMode === HeightReference.NONE
+        ? getCoordinates.bind(null, arcCoords)
+        : getLineStringCoordinates,
+    getGeometryOptions:
+      altitudeMode === HeightReference.NONE
+        ? getGeometryOptions.bind(null, arcCoords)
+        : getLineStringGeometryOptions,
+    createSolidGeometries,
+    createOutlineGeometries,
+    createFillGeometries,
+    createGroundLineGeometries,
+    createLineGeometries,
+  };
+}
+
+/**
+ * converts a linestring with an ArcStyle to a a cesium primitive
+ */
+export default async function arcToCesium(
+  feature: Feature,
+  style: ArcStyle,
+  geometries: LineString[],
+  vectorProperties: VectorProperties,
+  scene: Scene,
+  context: AsyncCesiumVectorContext,
+): Promise<void> {
+  if (!style.getFill() && !style.getStroke()) {
+    return;
+  }
+  const altitudeMode = vectorProperties.getAltitudeMode(feature);
+  const arcGeometryFactory = getGeometryFactory(
+    feature[featureArcStruct]!.coordinates!,
+    altitudeMode,
+  );
+  const validGeometries = geometries.filter((lineString) =>
+    validateLineString(lineString),
+  );
+  addPrimitivesToContext(
+    feature,
+    style,
+    validGeometries,
+    vectorProperties,
+    scene,
+    arcGeometryFactory,
+    context,
+  );
+  await addArrowsToContext(
+    feature,
+    style,
+    validGeometries,
+    vectorProperties,
+    scene,
+    arcGeometryFactory,
+    context,
+  ); // IDEA what about labels?
+}