@vcmap/core 6.0.0-rc.4 → 6.0.0-rc.6

package/src/util/editor/interactions/createLineStringInteraction.ts

@@ -3,7 +3,10 @@ import type { Coordinate } from 'ol/coordinate.js';
 import AbstractInteraction, {
   EventAfterEventHandler,
 } from '../../../interaction/abstractInteraction.js';
-import { EventType } from '../../../interaction/interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+} from '../../../interaction/interactionType.js';
 import VcsEvent from '../../../vcsEvent.js';
 import {
   alreadyTransformedToImage,
@@ -31,7 +34,10 @@ class CreateLineStringInteraction
   created = new VcsEvent<LineString>();
 
   constructor() {
-    super(EventType.CLICKMOVE | EventType.DBLCLICK);
+    super(
+      EventType.CLICKMOVE | EventType.DBLCLICK,
+      ModificationKeyType.NONE | ModificationKeyType.CTRL,
+    );
     this.setActive();
   }
 
@@ -57,7 +63,7 @@ class CreateLineStringInteraction
 
     if (event.type & EventType.CLICK) {
       if (!this._geometry) {
-        this._geometry = new LineString([event.positionOrPixel], 'XYZ');
+        this._geometry = new LineString([event.positionOrPixel]);
         if (event.map instanceof ObliqueMap) {
           this._geometry[alreadyTransformedToImage] = true;
         } else {

package/src/util/editor/interactions/createPointInteraction.ts

@@ -31,7 +31,7 @@ class CreatePointInteraction
   }
 
   pipe(event: EventAfterEventHandler): Promise<EventAfterEventHandler> {
-    this._geometry = new Point(event.positionOrPixel, 'XYZ');
+    this._geometry = new Point(event.positionOrPixel);
     if (event.map instanceof ObliqueMap) {
       this._geometry[alreadyTransformedToImage] = true;
     } else {

package/src/util/editor/interactions/createPolygonInteraction.ts

@@ -3,7 +3,10 @@ import type { Coordinate } from 'ol/coordinate.js';
 import AbstractInteraction, {
   EventAfterEventHandler,
 } from '../../../interaction/abstractInteraction.js';
-import { EventType } from '../../../interaction/interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+} from '../../../interaction/interactionType.js';
 import VcsEvent from '../../../vcsEvent.js';
 import {
   alreadyTransformedToImage,
@@ -12,6 +15,11 @@ import {
 import ObliqueMap from '../../../map/obliqueMap.js';
 import { CreateInteraction } from '../createFeatureSession.js';
 
+/**
+ * Set on polygon geometries which have a validity placeholder active
+ */
+export const validityPlaceholder = Symbol('validityPlaceholder');
+
 class CreatePolygonInteraction
   extends AbstractInteraction
   implements CreateInteraction<Polygon>
@@ -34,7 +42,10 @@ class CreatePolygonInteraction
   created = new VcsEvent<Polygon>();
 
   constructor() {
-    super(EventType.CLICKMOVE | EventType.DBLCLICK);
+    super(
+      EventType.CLICKMOVE | EventType.DBLCLICK,
+      ModificationKeyType.NONE | ModificationKeyType.CTRL,
+    );
     this.setActive();
   }
 
@@ -60,12 +71,13 @@ class CreatePolygonInteraction
 
     if (event.type & EventType.CLICK) {
       if (!this._geometry) {
-        this._geometry = new Polygon([[event.positionOrPixel.slice()]], 'XYZ');
+        this._geometry = new Polygon([[event.positionOrPixel.slice()]]);
         if (event.map instanceof ObliqueMap) {
           this._geometry[alreadyTransformedToImage] = true;
         } else {
           this._geometry[alreadyTransformedToMercator] = true;
         }
+        this._geometry[validityPlaceholder] = true;
         this.created.raiseEvent(this._geometry);
         this._coordinates = [event.positionOrPixel.slice()];
         this._lastCoordinate = [...event.positionOrPixel];
@@ -76,6 +88,7 @@ class CreatePolygonInteraction
         this._lastCoordinate = [...(this._lastCoordinate as Coordinate)];
         this._coordinates.splice(2, 1, this._lastCoordinate);
         this._validityPlaceHolder = null;
+        this._geometry[validityPlaceholder] = false;
       } else {
         this._lastCoordinate = [...(this._lastCoordinate as Coordinate)];
         this._coordinates.push(this._lastCoordinate);

package/src/util/editor/interactions/creationSnapping.ts

@@ -0,0 +1,226 @@
+import { LineString, Polygon } from 'ol/geom.js';
+import { Coordinate } from 'ol/coordinate.js';
+import { unByKey } from 'ol/Observable.js';
+import AbstractInteraction from '../../../interaction/abstractInteraction.js';
+import {
+  EventType,
+  ModificationKeyType,
+} from '../../../interaction/interactionType.js';
+import {
+  getSnappedCoordinateForResults,
+  getAngleSnapResult,
+  setSnappingFeatures,
+  SnapResult,
+  getGeometrySnapResult,
+  SnapType,
+  snapTypes,
+} from '../snappingHelpers.js';
+import { getCartesianBearing } from '../../math.js';
+import type VectorLayer from '../../../layer/vectorLayer.js';
+import { validityPlaceholder } from './createPolygonInteraction.js';
+import {
+  alreadySnapped,
+  SnappingInteractionEvent,
+} from '../editorSessionHelpers.js';
+
+function getBearings(coordinates: Coordinate[]): number[] {
+  // we dont want to take into account the last bearing, since that would be our own
+  const length = coordinates.length - 2;
+  if (length > 0) {
+    const bearings = new Array<number>(length);
+    for (let i = 0; i < length; i++) {
+      bearings[i] = getCartesianBearing(coordinates[i], coordinates[i + 1]);
+    }
+    return bearings;
+  }
+
+  return [];
+}
+
+export default class CreationSnapping extends AbstractInteraction {
+  private _coordinates: Coordinate[] = [];
+
+  private _bearings: number[] = [];
+
+  private _scratchLayer: VectorLayer;
+
+  private _isPolygon = false;
+
+  private _coordinatesDirty = false;
+
+  private _geometryLister: (() => void) | undefined;
+
+  private _removeFeatures: (() => void) | undefined;
+
+  private _snappingGeometry: LineString | undefined;
+
+  private _snapToVertex = true;
+
+  private _snapToEdge = true;
+
+  private _snapOrthogonal = true;
+
+  private _snapParallel = true;
+
+  constructor(scratchLayer: VectorLayer, snapTo: SnapType[] = [...snapTypes]) {
+    super(
+      EventType.CLICKMOVE | EventType.DBLCLICK,
+      ModificationKeyType.NONE | ModificationKeyType.CTRL,
+    );
+
+    this._scratchLayer = scratchLayer;
+    this.snapTo = snapTo;
+  }
+
+  get snapTo(): SnapType[] {
+    const snapTo: SnapType[] = [];
+    if (this._snapToVertex) {
+      snapTo.push('vertex');
+    }
+
+    if (this._snapToEdge) {
+      snapTo.push('edge');
+    }
+
+    if (this._snapOrthogonal) {
+      snapTo.push('orthogonal');
+    }
+
+    if (this._snapParallel) {
+      snapTo.push('parallel');
+    }
+
+    return snapTo;
+  }
+
+  set snapTo(snapTo: SnapType[]) {
+    this._snapToVertex = snapTo.includes('vertex');
+    this._snapToEdge = snapTo.includes('edge');
+    this._snapOrthogonal = snapTo.includes('orthogonal');
+    this._snapParallel = snapTo.includes('parallel');
+  }
+
+  private _setCoordinates(coordinates: Coordinate[]): void {
+    this._coordinates = coordinates;
+    this._bearings = getBearings(this._coordinates);
+    if (this._coordinates.length > 2) {
+      this._snappingGeometry = new LineString(
+        this._coordinates.slice(0, this._coordinates.length - 1),
+      );
+    }
+  }
+
+  setGeometry(geometry: LineString | Polygon): void {
+    this._geometryLister?.();
+    this._snappingGeometry = undefined;
+    let setCoordinates: () => void;
+    if (geometry instanceof Polygon) {
+      this._isPolygon = true;
+      setCoordinates = (): void => {
+        if (!geometry[validityPlaceholder]) {
+          this._setCoordinates(geometry.getCoordinates()[0]);
+        }
+      };
+    } else {
+      this._isPolygon = false;
+      setCoordinates = (): void => {
+        this._setCoordinates(geometry.getCoordinates());
+      };
+    }
+    setCoordinates();
+    const key = geometry.on('change', () => {
+      if (this._coordinatesDirty) {
+        setCoordinates();
+        this._coordinatesDirty = false;
+      }
+    });
+    this._geometryLister = (): void => {
+      unByKey(key);
+    };
+  }
+
+  pipe(event: SnappingInteractionEvent): Promise<SnappingInteractionEvent> {
+    this._removeFeatures?.();
+    if (event.type === EventType.CLICK) {
+      event.chainEnded?.addEventListener(() => {
+        this._coordinatesDirty = true;
+      });
+    }
+    if (
+      !event[alreadySnapped] &&
+      event.key !== ModificationKeyType.CTRL &&
+      this._coordinates.length >= 3
+    ) {
+      const results = new Array<SnapResult | undefined>(2);
+      const maxDistanceSquared =
+        (event.map.getCurrentResolution(event.positionOrPixel!) * 12) ** 2;
+
+      if (this._snappingGeometry) {
+        results[0] = getGeometrySnapResult(
+          [this._snappingGeometry],
+          event.positionOrPixel!,
+          maxDistanceSquared,
+          this._snapToVertex,
+          this._snapToEdge,
+        );
+      }
+
+      if (!results[0] && (this._snapOrthogonal || this._snapParallel)) {
+        results[0] = getAngleSnapResult(
+          event.positionOrPixel!,
+          this._coordinates.at(-2)!,
+          this._coordinates.at(-3)!,
+          this._bearings,
+          this._coordinates.length - 2,
+          maxDistanceSquared,
+          this._snapOrthogonal,
+          this._snapParallel,
+        );
+
+        if (this._isPolygon) {
+          const newCandidate = results[0]?.snapped ?? event.positionOrPixel!;
+          results[1] = getAngleSnapResult(
+            newCandidate,
+            this._coordinates.at(0)!,
+            this._coordinates.at(1)!,
+            this._bearings,
+            0,
+            maxDistanceSquared,
+            this._snapOrthogonal,
+            this._snapParallel,
+          );
+        }
+      }
+
+      const lastResult = getSnappedCoordinateForResults(
+        results,
+        this._coordinates,
+        maxDistanceSquared,
+      );
+
+      if (lastResult) {
+        if (event.positionOrPixel!.length > lastResult.length) {
+          lastResult[2] = event.positionOrPixel![2];
+        } else if (event.positionOrPixel!.length < lastResult.length) {
+          lastResult.pop();
+        }
+
+        event.positionOrPixel = lastResult;
+
+        this._removeFeatures = setSnappingFeatures(
+          results,
+          this._coordinates,
+          this._scratchLayer,
+        );
+      }
+    }
+
+    return Promise.resolve(event);
+  }
+
+  destroy(): void {
+    this._geometryLister?.();
+    this._removeFeatures?.();
+    super.destroy();
+  }
+}

package/src/util/editor/interactions/editGeometryMouseOverInteraction.ts

@@ -46,9 +46,10 @@ class EditGeometryMouseOverInteraction extends AbstractInteraction {
   constructor(denyRemoval?: boolean) {
     super(
       EventType.MOVE,
-      denyRemoval
+      (denyRemoval
         ? ModificationKeyType.NONE
-        : ModificationKeyType.NONE | ModificationKeyType.SHIFT,
+        : ModificationKeyType.NONE | ModificationKeyType.SHIFT) |
+        ModificationKeyType.CTRL,
     );
 
     this.setActive();

package/src/util/editor/interactions/insertVertexInteraction.ts

@@ -7,7 +7,7 @@ import {
   EventType,
   ModificationKeyType,
 } from '../../../interaction/interactionType.js';
-import { cartesian2DDistance } from '../../math.js';
+import { cartesian2DDistanceSquared } from '../../math.js';
 import {
   createVertex,
   getOlcsPropsFromFeature,
@@ -16,6 +16,9 @@ import {
   type Vertex,
 } from '../editorHelpers.js';
 import VcsEvent from '../../../vcsEvent.js';
+import { is2DLayout } from '../../geometryHelpers.js';
+import { isClampedHeightReference } from '../../featureconverter/vectorHeightInfo.js';
+import VectorProperties from '../../../layer/vectorProperties.js';
 
 export type VertexInsertedEvent = {
   vertex: Vertex;
@@ -31,6 +34,8 @@ class InsertVertexInteraction extends AbstractInteraction {
 
   private _isLinearRing: boolean;
 
+  private _vectorProperties: VectorProperties;
+
   /**
    * @param  feature
    * @param  geometry
@@ -38,11 +43,13 @@ class InsertVertexInteraction extends AbstractInteraction {
   constructor(
     feature: Feature<LineString | Polygon>,
     geometry: LineString | LinearRing,
+    vectorProperties: VectorProperties,
   ) {
     super(EventType.CLICK, ModificationKeyType.NONE);
 
     this._feature = feature;
     this._geometry = geometry;
+    this._vectorProperties = vectorProperties;
     this._isLinearRing = this._geometry instanceof LinearRing;
     this.setActive();
   }
@@ -56,15 +63,27 @@ class InsertVertexInteraction extends AbstractInteraction {
       if (this._isLinearRing) {
         lineCoords.push(lineCoords[0]);
       }
-      const distance = cartesian2DDistance(closestCoord, coordinate); // todo respect altitude mode here. e.g. distance3D
-      if (distance < event.map.getCurrentResolution(coordinate) * 5) {
+      const distanceSquared = cartesian2DDistanceSquared(
+        closestCoord,
+        coordinate,
+      ); // todo respect altitude mode here. e.g. distance3D
+      const is2DLine =
+        is2DLayout(this._geometry.getLayout()) ||
+        isClampedHeightReference(
+          this._vectorProperties.getAltitudeMode(this._feature),
+        );
+
+      // XXX how to handle relative to ground height references?
+      if (
+        distanceSquared <
+        (event.map.getCurrentResolution(coordinate) * 5) ** 2
+      ) {
         const length = lineCoords.length - 1;
         let i = 0;
         for (i; i < length; i++) {
-          const onLine =
-            this._feature.get('olcs_altitudeMode') === 'clampToGround' // todo altitude mode
-              ? pointOnLine2D(lineCoords[i], lineCoords[i + 1], closestCoord)
-              : pointOnLine3D(lineCoords[i], lineCoords[i + 1], closestCoord);
+          const onLine = is2DLine
+            ? pointOnLine2D(lineCoords[i], lineCoords[i + 1], closestCoord)
+            : pointOnLine3D(lineCoords[i], lineCoords[i + 1], closestCoord);
           if (onLine) {
             break;
           }
@@ -78,6 +97,7 @@ class InsertVertexInteraction extends AbstractInteraction {
           vertex: createVertex(
             closestCoord,
             getOlcsPropsFromFeature(this._feature),
+            -1,
           ),
           index,
         });

package/src/util/editor/interactions/layerSnapping.ts

@@ -0,0 +1,136 @@
+import { Feature } from 'ol';
+import VectorSource from 'ol/source/Vector.js';
+import AbstractInteraction from '../../../interaction/abstractInteraction.js';
+import {
+  EventType,
+  ModificationKeyType,
+} from '../../../interaction/interactionType.js';
+import VectorLayer from '../../../layer/vectorLayer.js';
+import { originalFeatureSymbol } from '../../../layer/vectorSymbols.js';
+import ObliqueMap from '../../../map/obliqueMap.js';
+import type VectorObliqueImpl from '../../../layer/oblique/vectorObliqueImpl.js';
+import {
+  alreadySnapped,
+  SnappingInteractionEvent,
+} from '../editorSessionHelpers.js';
+import {
+  setSnappingFeatures,
+  getGeometrySnapResult,
+  SnapType,
+} from '../snappingHelpers.js';
+
+export default class LayerSnapping extends AbstractInteraction {
+  layers: VectorLayer[];
+
+  private _scratchLayer: VectorLayer;
+
+  private _removeFeatures: (() => void) | undefined;
+
+  private _filter: (f: Feature) => boolean;
+
+  private _snapToVertex = true;
+
+  private _snapToEdge = true;
+
+  constructor(
+    layers: VectorLayer[],
+    scratchLayer: VectorLayer,
+    filter: (f: Feature) => boolean,
+    snapTo: SnapType[] = ['vertex', 'edge'],
+    type: EventType = EventType.CLICKMOVE | EventType.DBLCLICK,
+  ) {
+    super(type, ModificationKeyType.NONE | ModificationKeyType.CTRL);
+
+    this.layers = layers;
+    this._scratchLayer = scratchLayer;
+    this._filter = filter;
+    this.snapTo = snapTo;
+  }
+
+  get snapTo(): SnapType[] {
+    const snapTo: SnapType[] = [];
+    if (this._snapToVertex) {
+      snapTo.push('vertex');
+    }
+
+    if (this._snapToEdge) {
+      snapTo.push('edge');
+    }
+
+    return snapTo;
+  }
+
+  set snapTo(snapTo: SnapType[]) {
+    this._snapToVertex = snapTo.includes('vertex');
+    this._snapToEdge = snapTo.includes('edge');
+  }
+
+  pipe(event: SnappingInteractionEvent): Promise<SnappingInteractionEvent> {
+    this._removeFeatures?.();
+    if (event.key !== ModificationKeyType.CTRL) {
+      const coordinate = event.positionOrPixel!;
+      const bufferDistance = event.map.getCurrentResolution(coordinate) * 12;
+      const maxDistanceSquared = bufferDistance ** 2;
+
+      const isOblique = event.map instanceof ObliqueMap;
+
+      const geometries = this.layers
+        .flatMap((layer) => {
+          let source: VectorSource;
+
+          if (isOblique) {
+            source = (
+              layer.getImplementationsForMap(event.map)[0] as VectorObliqueImpl
+            )
+              .getOLLayer()
+              .getSource() as VectorSource;
+          } else {
+            source = layer.getSource();
+          }
+
+          return source.getFeaturesInExtent([
+            coordinate[0] - bufferDistance,
+            coordinate[1] - bufferDistance,
+            coordinate[0] + bufferDistance,
+            coordinate[1] + bufferDistance,
+          ]);
+        })
+        .filter((feature) => {
+          const originalFeature = feature[originalFeatureSymbol] ?? feature;
+          return this._filter(originalFeature);
+        })
+        .map((f) => f.getGeometry()!);
+
+      const result = getGeometrySnapResult(
+        geometries,
+        coordinate,
+        maxDistanceSquared,
+        this._snapToVertex,
+        this._snapToEdge,
+      );
+
+      if (result) {
+        const closest = result.snapped;
+        if (coordinate.length > closest.length) {
+          closest[2] = coordinate[2];
+        } else if (coordinate.length < closest.length) {
+          closest.pop();
+        }
+        event.positionOrPixel = closest;
+        event[alreadySnapped] = true;
+        this._removeFeatures = setSnappingFeatures(
+          [result],
+          [result.snapped],
+          this._scratchLayer,
+        );
+      }
+    }
+    return Promise.resolve(event);
+  }
+
+  destroy(): void {
+    this._removeFeatures?.();
+    this.layers = [];
+    super.destroy();
+  }
+}

package/src/util/editor/interactions/translateVertexInteraction.ts

@@ -2,7 +2,10 @@ import Feature from 'ol/Feature.js';
 import AbstractInteraction, {
   EventAfterEventHandler,
 } from '../../../interaction/abstractInteraction.js';
-import { EventType } from '../../../interaction/interactionType.js';
+import {
+  EventType,
+  ModificationKeyType,
+} from '../../../interaction/interactionType.js';
 import { vertexSymbol } from '../editorSymbols.js';
 import VcsEvent from '../../../vcsEvent.js';
 import { Vertex } from '../editorHelpers.js';
@@ -20,7 +23,10 @@ class TranslateVertexInteraction extends AbstractInteraction {
   private _feature: Feature;
 
   constructor(feature: Feature) {
-    super(EventType.DRAGEVENTS);
+    super(
+      EventType.DRAGEVENTS,
+      ModificationKeyType.NONE | ModificationKeyType.CTRL,
+    );
     this._feature = feature;
     this.setActive();
   }