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

package/src/util/featureconverter/lineStringToCesium.ts

@@ -1,5 +1,4 @@
 import {
-  Cartesian3,
   WallGeometry,
   WallOutlineGeometry,
   GroundPolylineGeometry,
@@ -7,7 +6,7 @@ import {
   Math as CesiumMath,
   HeightReference,
   type Scene,
-  PolygonGeometry,
+  Cartesian3,
 } from '@vcmap-cesium/engine';
 import { Feature } from 'ol';
 import { type LineString, Point } from 'ol/geom.js';
@@ -15,15 +14,23 @@ import type { Coordinate } from 'ol/coordinate.js';
 import type { Style } from 'ol/style.js';
 
 import { parseNumber } from '@vcsuite/parsers';
-import Projection from '../projection.js';
-import { addPrimitivesToContext } from './featureconverterHelper.js';
-import { getFlatCoordinatesFromSimpleGeometry } from '../geometryHelpers.js';
 import ArrowStyle, { ArrowEnd } from '../../style/arrowStyle.js';
 import { getCartesianBearing, getCartesianPitch } from '../math.js';
 import { getPrimitiveOptions } from './pointHelpers.js';
 import type VectorProperties from '../../layer/vectorProperties.js';
-import type { VectorGeometryFactoryType } from '../../layer/vectorLayer.js';
-import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
+import { getWgs84CoordinatesForPoint } from './pointToCesium.js';
+import { ConvertedItem } from './convert.js';
+import {
+  getHeightInfo,
+  VectorHeightInfo,
+  mercatorToCartesianTransformerForHeightInfo,
+  isAbsoluteHeightReference,
+} from './vectorHeightInfo.js';
+import {
+  CesiumGeometryOption,
+  PolylineGeometryOptions,
+  VectorGeometryFactory,
+} from './vectorGeometryFactory.js';
 
 type ArrowOptions = {
   location: Coordinate;
@@ -36,8 +43,9 @@ function getArrowOptions(
   to: Coordinate,
   heightReference: HeightReference,
 ): ArrowOptions {
-  let pitch =
-    heightReference === HeightReference.NONE ? getCartesianPitch(to, from) : 0;
+  let pitch = isAbsoluteHeightReference(heightReference)
+    ? getCartesianPitch(to, from)
+    : 0;
   pitch += 90;
   return {
     location: to,
@@ -48,208 +56,179 @@ function getArrowOptions(
   };
 }
 
-export async function addArrowsToContext(
+export function getArrowHeadPrimitives(
   feature: Feature,
   style: ArrowStyle,
-  validGeometries: LineString[],
+  geometry: LineString,
   vectorProperties: VectorProperties,
   scene: Scene,
-  lineGeometryFactory: VectorGeometryFactoryType,
-  context: AsyncCesiumVectorContext,
-): Promise<void> {
+  inputCoordinates?: Coordinate[],
+): ConvertedItem<'primitive'>[] {
   if (style.end === ArrowEnd.NONE || !style.primitiveOptions?.geometryOptions) {
-    return;
+    return [];
   }
   const arrowOptions: ArrowOptions[] = [];
   const heightReference = vectorProperties.getAltitudeMode(feature);
-  validGeometries.forEach((geom) => {
-    const coordinates = lineGeometryFactory.getCoordinates([geom]);
-    if (style.end === ArrowEnd.START || style.end === ArrowEnd.BOTH) {
-      arrowOptions.push(
-        getArrowOptions(coordinates[1], coordinates[0], heightReference),
-      );
-    }
+  const coordinates = inputCoordinates ?? geometry.getCoordinates();
+  if (style.end === ArrowEnd.START || style.end === ArrowEnd.BOTH) {
+    arrowOptions.push(
+      getArrowOptions(coordinates[1], coordinates[0], heightReference),
+    );
+  }
 
-    if (style.end === ArrowEnd.END || style.end === ArrowEnd.BOTH) {
-      arrowOptions.push(
-        getArrowOptions(
-          coordinates.at(-2)!,
-          coordinates.at(-1)!,
-          heightReference,
-        ),
-      );
-    }
-  });
+  if (style.end === ArrowEnd.END || style.end === ArrowEnd.BOTH) {
+    arrowOptions.push(
+      getArrowOptions(
+        coordinates.at(-2)!,
+        coordinates.at(-1)!,
+        heightReference,
+      ),
+    );
+  }
 
   if (arrowOptions.length === 0) {
-    return;
+    return [];
   }
 
   const usedStyle = style.getOlcsStyle();
-  const allowPicking = vectorProperties.getAllowPicking(feature);
 
-  await Promise.all(
-    arrowOptions.map(async (arrowOption) => {
+  return arrowOptions
+    .map((arrowOption): ConvertedItem<'primitive'>[] => {
+      const arrowHeadGeometry = new Point(arrowOption.location);
       const arrowFeature = new Feature({
         ...feature.getProperties(),
         olcs_primitiveOptions: style.primitiveOptions,
         olcs_modelHeading: arrowOption.heading,
         olcs_modelPitch: arrowOption.pitch,
-        geometry: new Point(arrowOption.location),
+        geometry: arrowHeadGeometry,
         olcs_modelAutoScale: true,
       });
 
-      const wgs84Position = Projection.mercatorToWgs84(arrowOption.location);
-      const cartesianLocation = Cartesian3.fromDegrees(
-        wgs84Position[0],
-        wgs84Position[1],
-        wgs84Position[2],
+      const heightInfo = getHeightInfo(
+        arrowFeature,
+        arrowHeadGeometry,
+        vectorProperties,
+      );
+
+      const wgs84Coords = getWgs84CoordinatesForPoint(
+        arrowHeadGeometry,
+        heightInfo,
+      );
+      const position = Cartesian3.fromDegrees(
+        wgs84Coords[0],
+        wgs84Coords[1],
+        wgs84Coords[2],
       );
-      const primitiveOptions = await getPrimitiveOptions(
+
+      return getPrimitiveOptions(
         arrowFeature,
         usedStyle,
-        [wgs84Position],
-        [cartesianLocation],
+        position,
+        wgs84Coords,
         vectorProperties,
         scene,
+        heightInfo,
       );
-
-      if (primitiveOptions?.primitives) {
-        context.addScaledPrimitives(
-          primitiveOptions.primitives,
-          feature,
-          allowPicking,
-        );
-      }
-    }),
-  );
+    })
+    .flat();
 }
 
-export type LineGeometryOptions = { positions: Cartesian3[] };
-
 export function createSolidGeometries(
-  options: LineGeometryOptions,
+  options: PolylineGeometryOptions,
+  heightInfo: VectorHeightInfo,
   height: number,
   perPositionHeight: boolean,
   extrudedHeight?: number,
-): WallGeometry[] {
+): CesiumGeometryOption<'solid'>[] {
   return [
-    WallGeometry.fromConstantHeights({
-      ...options,
-      maximumHeight: !perPositionHeight ? height : undefined,
-      minimumHeight: extrudedHeight,
-    }),
+    {
+      type: 'solid',
+      geometry: WallGeometry.fromConstantHeights({
+        ...options,
+        maximumHeight: !perPositionHeight ? height : undefined,
+        minimumHeight: extrudedHeight,
+      }),
+      heightInfo,
+    },
   ];
 }
 
 export function createOutlineGeometries(
-  options: LineGeometryOptions,
+  options: PolylineGeometryOptions,
+  heightInfo: VectorHeightInfo,
   height: number,
   perPositionHeight: boolean,
   extrudedHeight?: number,
-): WallOutlineGeometry[] {
+): CesiumGeometryOption<'outline'>[] {
   // maxium and minimum are flipped, to create the same perPositionHeight behaviour as in polygons
   // WallGeometries extrudes down instead of up, so we switch the behaviour and extrude in the other direction
   return [
-    WallOutlineGeometry.fromConstantHeights({
-      ...options,
-      maximumHeight: !perPositionHeight ? height : undefined,
-      minimumHeight: extrudedHeight,
-    }),
+    {
+      type: 'outline',
+      geometry: WallOutlineGeometry.fromConstantHeights({
+        ...options,
+        maximumHeight: !perPositionHeight ? height : undefined,
+        minimumHeight: extrudedHeight,
+      }),
+      heightInfo,
+    },
   ];
 }
 
-export function createFillGeometries(
-  _options: LineGeometryOptions,
-  _height: number,
-  _perPositionHeight: boolean,
-): PolygonGeometry[] {
-  return [];
-}
-
 export function createGroundLineGeometries(
-  options: LineGeometryOptions,
+  options: PolylineGeometryOptions,
+  heightInfo: VectorHeightInfo,
   style: Style,
-): GroundPolylineGeometry[] {
+): CesiumGeometryOption<'groundLine'>[] {
   const width = parseNumber(style.getStroke()!.getWidth(), 1.0);
   return [
-    new GroundPolylineGeometry({
-      ...options,
-      width,
-    }),
+    {
+      type: 'groundLine',
+      geometry: new GroundPolylineGeometry({
+        ...options,
+        width,
+      }),
+      heightInfo,
+    },
   ];
 }
 
 export function createLineGeometries(
-  options: LineGeometryOptions,
+  options: PolylineGeometryOptions,
+  heightInfo: VectorHeightInfo,
   style: Style,
-): PolylineGeometry[] {
+): CesiumGeometryOption<'line'>[] {
   const width = parseNumber(style.getStroke()!.getWidth(), 1.0);
 
   return [
-    new PolylineGeometry({
-      ...options,
-      width,
-    }),
+    {
+      type: 'line',
+      geometry: new PolylineGeometry({
+        ...options,
+        width,
+      }),
+      heightInfo,
+    },
   ];
 }
 
 /**
  * Creates the positions array for PolylineGeometry
  * @param  geometry
- * @param  positionHeightAdjustment
- * @param  perPositionHeight
- * @param  groundLevelOrMinHeight
+ * @param heightInfo
  * @private
  */
 export function getGeometryOptions(
   geometry: LineString,
-  positionHeightAdjustment: number,
-  perPositionHeight: boolean,
-  groundLevelOrMinHeight: number,
-): LineGeometryOptions {
+  heightInfo: VectorHeightInfo,
+): PolylineGeometryOptions {
   const coords = geometry.getCoordinates();
-  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],
-    );
-  });
+  const coordinateTransformer =
+    mercatorToCartesianTransformerForHeightInfo(heightInfo);
+  const positions = coords.map(coordinateTransformer);
   return { positions };
 }
 
-export function getCoordinates(geometries: LineString[]): Coordinate[] {
-  const coordinates: Coordinate[] = [];
-  geometries.forEach((lineString) => {
-    coordinates.push(...getFlatCoordinatesFromSimpleGeometry(lineString));
-  });
-  return coordinates;
-}
-
-let geometryFactory: VectorGeometryFactoryType | null = null;
-
-function getGeometryFactory(): VectorGeometryFactoryType {
-  if (!geometryFactory) {
-    geometryFactory = {
-      getCoordinates,
-      getGeometryOptions,
-      createSolidGeometries,
-      createOutlineGeometries,
-      createFillGeometries,
-      createGroundLineGeometries,
-      createLineGeometries,
-    };
-  }
-  return geometryFactory;
-}
-
 /**
  * validates if a lineString is renderable
  * @param  lineString
@@ -266,48 +245,22 @@ export function validateLineString(lineString: LineString): boolean {
   return false;
 }
 
-/**
- * converts a linestring to a a cesium primitive, with optional labels
- * @param  feature
- * @param  style
- * @param  geometries
- * @param  vectorProperties
- * @param  scene
- * @param  context
- */
-export default async function lineStringToCesium(
-  feature: Feature,
-  style: Style,
-  geometries: LineString[],
-  vectorProperties: VectorProperties,
-  scene: Scene,
-  context: AsyncCesiumVectorContext,
-): Promise<void> {
-  if (!style.getFill() && !style.getStroke()) {
-    return;
-  }
-  const lineGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter((lineString) =>
-    validateLineString(lineString),
-  );
-  addPrimitivesToContext(
-    feature,
-    style,
-    validGeometries,
-    vectorProperties,
-    scene,
-    lineGeometryFactory,
-    context,
-  );
-  if (style instanceof ArrowStyle) {
-    await addArrowsToContext(
-      feature,
-      style,
-      validGeometries,
-      vectorProperties,
-      scene,
-      lineGeometryFactory,
-      context,
-    );
+let geometryFactory: VectorGeometryFactory<'lineString'> | undefined;
+
+export function getLineStringGeometryFactory(): VectorGeometryFactory<'lineString'> {
+  if (!geometryFactory) {
+    geometryFactory = {
+      type: 'lineString',
+      getGeometryOptions,
+      createSolidGeometries,
+      createOutlineGeometries,
+      createFillGeometries(): never[] {
+        return [];
+      },
+      createGroundLineGeometries,
+      createLineGeometries,
+      validateGeometry: validateLineString,
+    };
   }
+  return geometryFactory;
 }