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

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

@@ -30,6 +30,7 @@ import {
   Handlers,
   is1DAxis,
   is2DAxis,
+  is3DAxis,
   TransformationMode,
 } from './transformationTypes.js';
 import Projection from '../../projection.js';
@@ -206,7 +207,8 @@ function createAxisPrimitive(
   if (
     axis === AxisAndPlanes.X ||
     axis === AxisAndPlanes.XY ||
-    axis === AxisAndPlanes.XZ
+    axis === AxisAndPlanes.XZ ||
+    axis === AxisAndPlanes.XYZ
   ) {
     primitives.push(
       new Primitive({
@@ -229,7 +231,8 @@ function createAxisPrimitive(
   if (
     axis === AxisAndPlanes.Y ||
     axis === AxisAndPlanes.XY ||
-    axis === AxisAndPlanes.YZ
+    axis === AxisAndPlanes.YZ ||
+    axis === AxisAndPlanes.XYZ
   ) {
     primitives.push(
       new Primitive({
@@ -252,7 +255,8 @@ function createAxisPrimitive(
   if (
     axis === AxisAndPlanes.Z ||
     axis === AxisAndPlanes.XZ ||
-    axis === AxisAndPlanes.YZ
+    axis === AxisAndPlanes.YZ ||
+    axis === AxisAndPlanes.XYZ
   ) {
     primitives.push(
       new Primitive({
@@ -263,13 +267,13 @@ function createAxisPrimitive(
               positions: Cartesian3.fromDegreesArrayHeights([
                 centerWgs84[0],
                 centerWgs84[1],
-                center[2] - 500000,
+                (center[2] ?? 0) - 500000,
                 centerWgs84[0],
                 centerWgs84[1],
                 center[2],
                 centerWgs84[0],
                 centerWgs84[1],
-                center[2] + 500000,
+                (center[2] ?? 0) + 500000,
               ]),
               width: 1,
             }),
@@ -481,6 +485,28 @@ function createPlanePrimitive(
   return primitive;
 }
 
+function createBoxPrimitive(modelMatrix: Matrix4, greyOut = false): Primitive {
+  const color = greyOut ? greyedOutColor : Color.GAINSBORO;
+  const primitive = new Primitive({
+    allowPicking: !greyOut,
+    asynchronous: false,
+    geometryInstances: [
+      new GeometryInstance({
+        geometry: new BoxGeometry({
+          minimum: new Cartesian3(0.2, 0.2, 0.2),
+          maximum: new Cartesian3(0.4, 0.4, 0.4),
+        }),
+      }),
+    ],
+    ...getPolygonAppearance(color),
+    modelMatrix,
+  });
+  if (!greyOut) {
+    primitive[handlerSymbol] = AxisAndPlanes.XYZ;
+  }
+  return primitive;
+}
+
 function createShowShadowPrimitive(
   primitiveCollection: PrimitiveCollection,
 ): (
@@ -503,6 +529,8 @@ function createShowShadowPrimitive(
         });
       } else if (is2DAxis(axis)) {
         primitive.add(createPlanePrimitive(axis, modelMatrix, true));
+      } else if (is3DAxis(axis)) {
+        primitive.add(createBoxPrimitive(modelMatrix, true));
       }
       primitiveCollection.add(primitive);
     }
@@ -524,36 +552,47 @@ export default function create3DHandlers(
   const modelMatrix = Matrix4.fromTranslation(Cartesian3.fromDegrees(0, 0, 0));
   const zPrimitives: Primitive[] = [];
 
-  if (
-    mode === TransformationMode.TRANSLATE ||
-    mode === TransformationMode.SCALE
-  ) {
+  if (mode === TransformationMode.TRANSLATE) {
     const primitives = [
       ...createLineAxisPrimitives(AxisAndPlanes.X, modelMatrix, mode),
       ...createLineAxisPrimitives(AxisAndPlanes.Y, modelMatrix, mode),
       createPlanePrimitive(AxisAndPlanes.XY, modelMatrix),
     ];
 
-    if (mode === TransformationMode.TRANSLATE) {
-      zPrimitives.push(
-        ...createLineAxisPrimitives(AxisAndPlanes.Z, modelMatrix, mode),
-        createPlanePrimitive(AxisAndPlanes.XZ, modelMatrix),
-        createPlanePrimitive(AxisAndPlanes.YZ, modelMatrix),
-      );
-      primitives.push(...zPrimitives);
-    }
+    zPrimitives.push(
+      ...createLineAxisPrimitives(AxisAndPlanes.Z, modelMatrix, mode),
+      createPlanePrimitive(AxisAndPlanes.XZ, modelMatrix),
+      createPlanePrimitive(AxisAndPlanes.YZ, modelMatrix),
+    );
+    primitives.push(...zPrimitives);
     primitives.forEach((p) => {
       setFeatureOnPrimitive(p);
       primitiveCollection.add(p);
     });
   } else if (mode === TransformationMode.ROTATE) {
-    primitiveCollection.add(
-      createRingPrimitive(AxisAndPlanes.X, modelMatrix, true),
-    );
-    primitiveCollection.add(
-      createRingPrimitive(AxisAndPlanes.Y, modelMatrix, true),
+    zPrimitives.push(
+      createRingPrimitive(AxisAndPlanes.X, modelMatrix),
+      createRingPrimitive(AxisAndPlanes.Y, modelMatrix),
     );
+    zPrimitives.forEach((p) => {
+      primitiveCollection.add(p);
+    });
     primitiveCollection.add(createRingPrimitive(AxisAndPlanes.Z, modelMatrix));
+  } else if (mode === TransformationMode.SCALE) {
+    const primitives = [
+      ...createLineAxisPrimitives(AxisAndPlanes.X, modelMatrix, mode),
+      ...createLineAxisPrimitives(AxisAndPlanes.Y, modelMatrix, mode),
+    ];
+
+    zPrimitives.push(
+      ...createLineAxisPrimitives(AxisAndPlanes.Z, modelMatrix, mode),
+      createBoxPrimitive(modelMatrix),
+    );
+    primitives.push(...zPrimitives);
+    primitives.forEach((p) => {
+      setFeatureOnPrimitive(p);
+      primitiveCollection.add(p);
+    });
   } else if (mode === TransformationMode.EXTRUDE) {
     createLineAxisPrimitives(AxisAndPlanes.Z, modelMatrix, mode).forEach(
       (p) => {
@@ -629,6 +668,29 @@ export default function create3DHandlers(
             createPlanePrimitive(AxisAndPlanes.XZ, modelMatrix, greyOut),
             createPlanePrimitive(AxisAndPlanes.YZ, modelMatrix, greyOut),
           );
+        } else if (mode === TransformationMode.ROTATE) {
+          if (!greyOut) {
+            zPrimitives.push(
+              createRingPrimitive(AxisAndPlanes.X, modelMatrix, greyOut),
+              createRingPrimitive(AxisAndPlanes.Y, modelMatrix, greyOut),
+            );
+          }
+        } else if (mode === TransformationMode.SCALE) {
+          if (!greyOut) {
+            zPrimitives.push(
+              ...createLineAxisPrimitives(
+                AxisAndPlanes.Z,
+                modelMatrix,
+                mode,
+                greyOut,
+              ),
+              createBoxPrimitive(modelMatrix),
+            );
+          } else {
+            zPrimitives.push(
+              createPlanePrimitive(AxisAndPlanes.XY, modelMatrix),
+            );
+          }
         }
 
         zPrimitives.forEach((p) => {

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

@@ -12,6 +12,7 @@ import VcsEvent from '../../../vcsEvent.js';
 import Projection from '../../projection.js';
 import {
   cartesian2DDistance,
+  cartesian3DDistance,
   cartographicToWgs84,
   mercatorToCartesian,
 } from '../../math.js';
@@ -37,23 +38,30 @@ function createGetScaledEvent(
   const { center } = transformationHandler;
   let flippedX = false;
   let flippedY = false;
+  let flippedZ = false;
 
   const getDistance = (
     coordinate: Coordinate,
     windowPosition: Cartesian2,
-  ): { distance: number; dx: number; dy: number } => {
+  ): { distance: number; dx: number; dy: number; dz: number } => {
     const position = getPosition(coordinate, windowPosition);
     const dx = position[0] - center[0];
     const dy = position[1] - center[1];
+    let dz = position[2] - center[2];
+    dz = Number.isFinite(dz) ? dz : 0;
     let distance;
     if (axis === AxisAndPlanes.X) {
       distance = Math.abs(dx);
     } else if (axis === AxisAndPlanes.Y) {
       distance = Math.abs(dy);
+    } else if (axis === AxisAndPlanes.Z) {
+      distance = Math.abs(dz);
+    } else if (axis === AxisAndPlanes.XYZ) {
+      distance = cartesian3DDistance(center, position);
     } else {
       distance = cartesian2DDistance(center, position);
     }
-    return { distance, dx, dy };
+    return { distance, dx, dy, dz };
   };
 
   const { distance: initialDistance } = getDistance(
@@ -62,13 +70,16 @@ function createGetScaledEvent(
   );
   let currentDistance = initialDistance;
   return (coordinate, windowPosition) => {
-    const { distance, dx, dy } = getDistance(coordinate, windowPosition);
+    const { distance, dx, dy, dz } = getDistance(coordinate, windowPosition);
 
     const distanceDelta = distance / currentDistance;
     const currentFlippedX = dx < 0;
     const currentFlippedY = dy < 0;
+    const currentFlippedZ = dz < 0;
     let sx = distanceDelta;
     let sy = distanceDelta;
+    let sz = distanceDelta;
+
     if (currentFlippedX !== flippedX) {
       flippedX = currentFlippedX;
       sx *= -1;
@@ -79,14 +90,24 @@ function createGetScaledEvent(
       sy *= -1;
     }
 
+    if (currentFlippedZ !== flippedZ) {
+      flippedZ = currentFlippedZ;
+      sz *= -1;
+    }
+
     currentDistance = distance;
     if (axis === AxisAndPlanes.X) {
       return [sx, 1, 1];
     } else if (axis === AxisAndPlanes.Y) {
       return [1, sy, 1];
-    } else {
+    } else if (axis === AxisAndPlanes.XY) {
       return [sx, sy, 1];
+    } else if (axis === AxisAndPlanes.XYZ) {
+      return [sx, sy, sz];
+    } else if (axis === AxisAndPlanes.Z) {
+      return [1, 1, sz];
     }
+    return [1, 1, 1];
   };
 }
 
@@ -142,7 +163,9 @@ class ScaleInteraction extends AbstractInteraction {
   ): GetScaleCallback {
     const scene = (event.map as CesiumMap).getScene() as Scene;
     const center = mercatorToCartesian(this._transformationHandler!.center);
-    let plane = Plane.clone(Plane.ORIGIN_XY_PLANE);
+    let plane = Plane.clone(
+      axis === AxisAndPlanes.Z ? Plane.ORIGIN_ZX_PLANE : Plane.ORIGIN_XY_PLANE,
+    );
     plane = Plane.transform(
       plane,
       Transforms.eastNorthUpToFixedFrame(center),

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

@@ -1,12 +1,12 @@
 import type { Feature } from 'ol/index.js';
 import type { SimpleGeometry } from 'ol/geom.js';
 import type { Coordinate } from 'ol/coordinate.js';
-import { HeightReference } from '@vcmap-cesium/engine';
 import {
   createEmpty as createEmptyExtent,
   extend as extendExtent,
   getCenter as getExtentCenter,
 } from 'ol/extent.js';
+import { HeightReference } from '@vcmap-cesium/engine';
 import Extent3D from '../../featureconverter/extent3D.js';
 import CesiumMap from '../../../map/cesiumMap.js';
 import BaseOLMap from '../../../map/baseOLMap.js';
@@ -21,44 +21,69 @@ import {
   TransformationMode,
 } from './transformationTypes.js';
 import type VcsMap from '../../../map/vcsMap.js';
+import {
+  isAbsoluteHeightReference,
+  isClampedHeightReference,
+  isRelativeHeightReference,
+} from '../../featureconverter/vectorHeightInfo.js';
+import { mercatorToCartographic } from '../../math.js';
+import { is2DLayout } from '../../geometryHelpers.js';
 
 type FeatureCenterInfo = {
   center: import('ol/coordinate.js').Coordinate;
-  someClamped: boolean;
-  someNoTerrain: boolean;
+  greyOutZ: boolean;
+  calculateHeight: boolean;
+  offsetHeight: boolean;
 };
 
 function getCenterFromFeatures3D(
   layer: VectorLayer,
+  mode: TransformationMode,
   features: Feature[],
 ): FeatureCenterInfo {
   const extent3D = new Extent3D();
-  let someClamped = false;
-  let someNoTerrain = false;
-  const layerIsClamped =
-    layer.vectorProperties.altitudeMode === HeightReference.CLAMP_TO_GROUND;
+  let calculateHeight = false;
+  let greyOutZ = mode !== TransformationMode.TRANSLATE;
+  let offsetHeight: boolean | undefined;
 
   features.forEach((f) => {
     const geometry = f.getGeometry() as SimpleGeometry;
     extent3D.extendWithGeometry(geometry);
-    if (!someNoTerrain) {
-      const firstCoordinates = geometry.getFirstCoordinate();
-      if (!firstCoordinates[2]) {
-        someNoTerrain = true;
-      }
+    calculateHeight = calculateHeight || is2DLayout(geometry.getLayout());
+    const heightReference = layer.vectorProperties.getAltitudeMode(f);
+    if (offsetHeight !== false) {
+      const isRelative = isRelativeHeightReference(heightReference);
+      offsetHeight = isRelative;
+      calculateHeight = calculateHeight || isRelative;
     }
+    calculateHeight =
+      calculateHeight || isClampedHeightReference(heightReference);
 
-    if (!someClamped) {
-      const altitudeMode = f.get('olcs_altitudeMode') as string;
-      someClamped =
-        altitudeMode === 'clampToGround' || (!altitudeMode && layerIsClamped);
-    }
+    greyOutZ =
+      greyOutZ ||
+      is2DLayout(geometry.getLayout()) ||
+      isClampedHeightReference(heightReference) ||
+      (isRelativeHeightReference(heightReference) &&
+        layer.vectorProperties.getHeightAboveGround(f) != null) ||
+      (isAbsoluteHeightReference(heightReference) &&
+        layer.vectorProperties.getGroundLevel(f) != null);
   });
+
+  if (
+    features.length === 1 &&
+    (mode === TransformationMode.ROTATE || mode === TransformationMode.SCALE) &&
+    features[0].getGeometry()?.getType() === 'Point' &&
+    layer.vectorProperties.renderAs(features[0]) !== 'geometry'
+  ) {
+    greyOutZ = false;
+  }
   const center = extent3D.getCenter();
+
   return {
     center,
-    someClamped,
-    someNoTerrain,
+    calculateHeight,
+    greyOutZ,
+    offsetHeight: !!offsetHeight,
   };
 }
 
@@ -71,9 +96,10 @@ function getCenterFromFeatures2D(features: Feature[]): FeatureCenterInfo {
   });
 
   return {
-    center: [...getExtentCenter(extent), 0],
-    someClamped: false,
-    someNoTerrain: false,
+    center: [...getExtentCenter(extent)],
+    calculateHeight: false,
+    greyOutZ: false,
+    offsetHeight: false,
   };
 }
 
@@ -102,33 +128,40 @@ export default function createTransformationHandler(
   let getCenterFromFeatures: (features: Feature[]) => FeatureCenterInfo;
   let cesiumMap: CesiumMap | null = null;
 
-  let cancelAsyncSetting = (): void => {};
-  const setFeatures = async (features: Feature[]): Promise<void> => {
-    cancelAsyncSetting();
+  const setFeatures = (features: Feature[]): void => {
     const show = features.length > 0;
     if (show) {
       const {
         center: newCenter,
-        someClamped,
-        someNoTerrain,
+        calculateHeight,
+        greyOutZ,
+        offsetHeight,
       } = getCenterFromFeatures(features);
       center = newCenter;
-      if (!cesiumMap || !someNoTerrain) {
+      handlerFeatures.greyOutZ = greyOutZ;
+      if (!cesiumMap || !calculateHeight) {
         // only set center sync, if updating will not change it too drastically (to avoid jumps)
         handlerFeatures.show = true;
         handlerFeatures.setCenter(center);
       }
-      handlerFeatures.greyOutZ = someClamped;
-      if (cesiumMap && (someClamped || someNoTerrain)) {
-        let cancel = false;
-        cancelAsyncSetting = (): void => {
-          cancel = true;
-        };
-        await cesiumMap.getHeightFromTerrain([center]);
-        if (!cancel) {
-          handlerFeatures.show = true;
-          handlerFeatures.setCenter(center);
+      if (cesiumMap && calculateHeight) {
+        const height = cesiumMap
+          .getScene()!
+          .getHeight(
+            mercatorToCartographic(center),
+            HeightReference.CLAMP_TO_GROUND,
+          );
+
+        if (height) {
+          if (offsetHeight) {
+            center[2] += height;
+          } else {
+            center[2] = height;
+          }
         }
+
+        handlerFeatures.show = true;
+        handlerFeatures.setCenter(center);
       }
     } else {
       handlerFeatures.show = false;
@@ -137,7 +170,7 @@ export default function createTransformationHandler(
 
   if (map instanceof CesiumMap) {
     handlerFeatures = create3DHandlers(map, mode);
-    getCenterFromFeatures = getCenterFromFeatures3D.bind(null, layer);
+    getCenterFromFeatures = getCenterFromFeatures3D.bind(null, layer, mode);
     cesiumMap = map;
   } else if (map instanceof BaseOLMap) {
     handlerFeatures = create2DHandlers(map, scratchLayer, mode);
@@ -163,10 +196,8 @@ export default function createTransformationHandler(
       center[2] += dz;
       handlerFeatures.setCenter(center);
     },
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises
     setFeatures,
     destroy(): void {
-      cancelAsyncSetting();
       handlerFeatures.destroy();
       scratchLayer.removeAllFeatures();
     },

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

@@ -43,6 +43,7 @@ export enum AxisAndPlanes {
   XY = 'XY',
   XZ = 'XZ',
   YZ = 'YZ',
+  XYZ = 'XYZ',
   NONE = 'NONE',
 }
 export enum TransformationMode {
@@ -69,3 +70,7 @@ export function is2DAxis(axis: AxisAndPlanes): boolean {
     axis === AxisAndPlanes.YZ
   );
 }
+
+export function is3DAxis(axis: AxisAndPlanes): boolean {
+  return axis === AxisAndPlanes.XYZ;
+}

package/src/util/featureconverter/arcToCesium.ts

@@ -1,130 +1,60 @@
-import {
-  ArcType,
-  Cartesian3,
-  HeightReference,
-  Scene,
-} from '@vcmap-cesium/engine';
+import { ArcType, HeightReference } 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';
+import {
+  mercatorToCartesianTransformerForHeightInfo,
+  VectorHeightInfo,
+} from './vectorHeightInfo.js';
+import {
+  PolylineGeometryOptions,
+  VectorGeometryFactory,
+} from './vectorGeometryFactory.js';
 
 /**
  * Creates the positions & arcType option for the PolylineGeometry
  */
-export function getGeometryOptions(
+function getGeometryOptions(
   coords: Coordinate[],
   _geometry: LineString,
-  positionHeightAdjustment: number,
-  perPositionHeight: boolean,
-  groundLevelOrMinHeight: number,
-): { positions: Cartesian3[]; arcType: ArcType } {
-  const positions = coords.map((coord) => {
-    const wgs84Coords = Projection.mercatorToWgs84(coord);
-    if (!perPositionHeight && groundLevelOrMinHeight) {
-      wgs84Coords[2] = groundLevelOrMinHeight;
-    } else if (wgs84Coords[2] != null) {
-      wgs84Coords[2] += positionHeightAdjustment;
-    }
-    return Cartesian3.fromDegrees(
-      wgs84Coords[0],
-      wgs84Coords[1],
-      wgs84Coords[2],
-    );
-  });
+  heightInfo: VectorHeightInfo,
+): PolylineGeometryOptions {
+  const coordinateTransformer =
+    mercatorToCartesianTransformerForHeightInfo(heightInfo);
+  const positions = coords.map(coordinateTransformer);
   return { positions, arcType: ArcType.NONE };
 }
 
 /**
- * In this special case, the coordinates are not taken from the geometries array
+ * @param arcCoords - the coordinates of the arc to use instead of the geometries coordinates if height mode is absolute
+ * @param altitudeMode
  */
-// 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(
+// eslint-disable-next-line import/prefer-default-export
+export function getArcGeometryFactory(
   arcCoords: Coordinate[],
   altitudeMode: HeightReference,
-): VectorGeometryFactoryType {
+): VectorGeometryFactory<'arc'> {
   return {
-    getCoordinates:
-      altitudeMode === HeightReference.NONE
-        ? getCoordinates.bind(null, arcCoords)
-        : getLineStringCoordinates,
+    type: 'arc',
     getGeometryOptions:
       altitudeMode === HeightReference.NONE
         ? getGeometryOptions.bind(null, arcCoords)
         : getLineStringGeometryOptions,
     createSolidGeometries,
     createOutlineGeometries,
-    createFillGeometries,
+    createFillGeometries(): never[] {
+      return [];
+    },
     createGroundLineGeometries,
     createLineGeometries,
+    validateGeometry: validateLineString,
   };
 }
-
-/**
- * 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?
-}