@vcmap/core 5.0.0-rc.28 → 5.0.0-rc.29

package/src/util/featureconverter/lineStringToCesium.js

@@ -4,7 +4,8 @@ import {
   WallOutlineGeometry,
   GroundPolylineGeometry,
   PolylineGeometry,
-  Math as CesiumMath, HeightReference,
+  Math as CesiumMath,
+  HeightReference,
 } from '@vcmap-cesium/engine';
 import { Feature } from 'ol';
 import { Point } from 'ol/geom.js';
@@ -31,12 +32,15 @@ import { getPrimitiveOptions } from './pointHelpers.js';
  * @returns {ArrowOptions}
  */
 function getArrowOptions(from, to, heightReference) {
-  let pitch = heightReference === HeightReference.NONE ? getCartesianPitch(to, from) : 0;
+  let pitch =
+    heightReference === HeightReference.NONE ? getCartesianPitch(to, from) : 0;
   pitch += 90;
   return {
     location: to,
     pitch,
-    heading: CesiumMath.toDegrees(getCartesianBearing(from, to) + CesiumMath.PI_OVER_TWO),
+    heading: CesiumMath.toDegrees(
+      getCartesianBearing(from, to) + CesiumMath.PI_OVER_TWO,
+    ),
   };
 }
 
@@ -50,7 +54,13 @@ function getArrowOptions(from, to, heightReference) {
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
  */
 export function addArrowsToContext(
-  feature, style, validGeometries, vectorProperties, scene, lineGeometryFactory, context,
+  feature,
+  style,
+  validGeometries,
+  vectorProperties,
+  scene,
+  lineGeometryFactory,
+  context,
 ) {
   if (style.end === ArrowEnd.NONE || !style.primitiveOptions?.geometryOptions) {
     return;
@@ -60,11 +70,19 @@ export function addArrowsToContext(
   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));
+      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));
+      arrowOptions.push(
+        getArrowOptions(
+          coordinates.at(-2),
+          coordinates.at(-1),
+          heightReference,
+        ),
+      );
     }
   });
 
@@ -86,7 +104,11 @@ export function addArrowsToContext(
     });
 
     const wgs84Position = Projection.mercatorToWgs84(arrowOption.location);
-    const cartesianLocation = Cartesian3.fromDegrees(wgs84Position[0], wgs84Position[1], wgs84Position[2]);
+    const cartesianLocation = Cartesian3.fromDegrees(
+      wgs84Position[0],
+      wgs84Position[1],
+      wgs84Position[2],
+    );
     const primitiveOptions = getPrimitiveOptions(
       arrowFeature,
       usedStyle,
@@ -97,7 +119,11 @@ export function addArrowsToContext(
     );
 
     if (primitiveOptions.primitives) {
-      context.addScaledPrimitives(primitiveOptions.primitives, feature, allowPicking);
+      context.addScaledPrimitives(
+        primitiveOptions.primitives,
+        feature,
+        allowPicking,
+      );
     }
   });
 }
@@ -110,12 +136,19 @@ export function addArrowsToContext(
  * @returns {Array<import("@vcmap-cesium/engine").WallGeometry>}
  * @private
  */
-export function createSolidGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [WallGeometry.fromConstantHeights({
-    ...options,
-    maximumHeight: !perPositionHeight ? height : undefined,
-    minimumHeight: extrudedHeight,
-  })];
+export function createSolidGeometries(
+  options,
+  height,
+  perPositionHeight,
+  extrudedHeight,
+) {
+  return [
+    WallGeometry.fromConstantHeights({
+      ...options,
+      maximumHeight: !perPositionHeight ? height : undefined,
+      minimumHeight: extrudedHeight,
+    }),
+  ];
 }
 
 /**
@@ -126,14 +159,21 @@ export function createSolidGeometries(options, height, perPositionHeight, extrud
  * @returns {Array<import("@vcmap-cesium/engine").WallOutlineGeometry>}
  * @private
  */
-export function createOutlineGeometries(options, height, perPositionHeight, extrudedHeight) {
+export function createOutlineGeometries(
+  options,
+  height,
+  perPositionHeight,
+  extrudedHeight,
+) {
   // 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,
-  })];
+  return [
+    WallOutlineGeometry.fromConstantHeights({
+      ...options,
+      maximumHeight: !perPositionHeight ? height : undefined,
+      minimumHeight: extrudedHeight,
+    }),
+  ];
 }
 
 /**
@@ -148,7 +188,6 @@ export function createFillGeometries(options, height, perPositionHeight) {
   return [];
 }
 
-
 /**
  * @param {Object} options
  * @param {import("ol/style/Style").default} style
@@ -157,10 +196,12 @@ export function createFillGeometries(options, height, perPositionHeight) {
  */
 export function createGroundLineGeometries(options, style) {
   const width = parseNumber(style.getStroke().getWidth(), 1.0);
-  return [new GroundPolylineGeometry({
-    ...options,
-    width,
-  })];
+  return [
+    new GroundPolylineGeometry({
+      ...options,
+      width,
+    }),
+  ];
 }
 
 /**
@@ -171,10 +212,12 @@ export function createGroundLineGeometries(options, style) {
  */
 export function createLineGeometries(options, style) {
   const width = parseNumber(style.getStroke().getWidth(), 1.0);
-  return [new PolylineGeometry({
-    ...options,
-    width,
-  })];
+  return [
+    new PolylineGeometry({
+      ...options,
+      width,
+    }),
+  ];
 }
 
 /**
@@ -191,7 +234,11 @@ export function getGeometryOptions(geometry, positionHeightAdjustment) {
     if (wgs84Coords[2] != null) {
       wgs84Coords[2] += positionHeightAdjustment;
     }
-    return Cartesian3.fromDegrees(wgs84Coords[0], wgs84Coords[1], wgs84Coords[2]);
+    return Cartesian3.fromDegrees(
+      wgs84Coords[0],
+      wgs84Coords[1],
+      wgs84Coords[2],
+    );
   });
   return { positions };
 }
@@ -244,7 +291,7 @@ export function validateLineString(lineString) {
   const flatCoordinates = lineString.getFlatCoordinates();
   const minimumValues = lineString.getStride() * 2;
   if (flatCoordinates && flatCoordinates.length >= minimumValues) {
-    return flatCoordinates.every(value => Number.isFinite(value));
+    return flatCoordinates.every((value) => Number.isFinite(value));
   }
   return false;
 }
@@ -258,14 +305,39 @@ export function validateLineString(lineString) {
  * @param {import("@vcmap-cesium/engine").Scene} scene
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
  */
-export default function lineStringToCesium(feature, style, geometries, vectorProperties, scene, context) {
+export default function lineStringToCesium(
+  feature,
+  style,
+  geometries,
+  vectorProperties,
+  scene,
+  context,
+) {
   if (!style.getFill() && !style.getStroke()) {
     return;
   }
   const lineGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter(lineString => validateLineString(lineString));
-  addPrimitivesToContext(feature, style, validGeometries, vectorProperties, scene, lineGeometryFactory, context);
+  const validGeometries = geometries.filter((lineString) =>
+    validateLineString(lineString),
+  );
+  addPrimitivesToContext(
+    feature,
+    style,
+    validGeometries,
+    vectorProperties,
+    scene,
+    lineGeometryFactory,
+    context,
+  );
   if (style instanceof ArrowStyle) {
-    addArrowsToContext(feature, style, validGeometries, vectorProperties, scene, lineGeometryFactory, context);
+    addArrowsToContext(
+      feature,
+      style,
+      validGeometries,
+      vectorProperties,
+      scene,
+      lineGeometryFactory,
+      context,
+    );
   }
 }

package/src/util/featureconverter/pointHelpers.js

@@ -2,15 +2,22 @@ import {
   BoxGeometry,
   BoxOutlineGeometry,
   Cartesian3,
-  Cartographic, Color, ColorGeometryInstanceAttribute,
+  Cartographic,
+  Color,
+  ColorGeometryInstanceAttribute,
   CylinderGeometry,
   CylinderOutlineGeometry,
   EllipsoidGeometry,
-  EllipsoidOutlineGeometry, GeometryInstance,
-  HeadingPitchRoll, Material, MaterialAppearance,
+  EllipsoidOutlineGeometry,
+  GeometryInstance,
+  HeadingPitchRoll,
+  Material,
+  MaterialAppearance,
   Matrix4,
   Model,
-  ModelAnimationLoop, PerInstanceColorAppearance, Primitive,
+  ModelAnimationLoop,
+  PerInstanceColorAppearance,
+  Primitive,
   sampleTerrainMostDetailed,
   SphereGeometry,
   SphereOutlineGeometry,
@@ -33,7 +40,9 @@ function makeOffsetAutoScalePrimitive(primitive, transform, scale, offset) {
   const currentOffset = offset.clone();
 
   Object.defineProperty(primitive, 'modelMatrix', {
-    get() { return modelMatrix; },
+    get() {
+      return modelMatrix;
+    },
     set(newModelMatrix) {
       const newScale = Matrix4.getScale(newModelMatrix, new Cartesian3());
       if (!newScale.equals(currentScale)) {
@@ -57,7 +66,9 @@ function makeScaledAutoScalePrimitive(primitive, scale) {
   let currentScale = scale.clone();
 
   Object.defineProperty(primitive, 'modelMatrix', {
-    get() { return modelMatrix; },
+    get() {
+      return modelMatrix;
+    },
     set(newModelMatrix) {
       const newScale = Matrix4.getScale(newModelMatrix, new Cartesian3());
       if (!newScale.equals(currentScale)) {
@@ -78,18 +89,27 @@ function makeScaledAutoScalePrimitive(primitive, scale) {
  */
 async function placePrimitiveOnTerrain(primitive, position, scene, offset) {
   await sampleTerrainMostDetailed(
-    /** @type {import("@vcmap-cesium/engine").CesiumTerrainProvider} */ (scene.globe.terrainProvider),
+    /** @type {import("@vcmap-cesium/engine").CesiumTerrainProvider} */ (
+      scene.globe.terrainProvider
+    ),
     [Cartographic.fromCartesian(position)],
   )
     .then(([cartoWithNewHeight]) => {
       if (!primitive.isDestroyed()) {
         const { modelMatrix } = primitive;
-        const newPosition = Cartographic.toCartesian(cartoWithNewHeight, undefined, position);
+        const newPosition = Cartographic.toCartesian(
+          cartoWithNewHeight,
+          undefined,
+          position,
+        );
         if (offset) {
           Cartesian3.add(newPosition, offset, newPosition);
         }
-        primitive.modelMatrix = Matrix4
-          .setTranslation(modelMatrix, newPosition, modelMatrix);
+        primitive.modelMatrix = Matrix4.setTranslation(
+          modelMatrix,
+          newPosition,
+          modelMatrix,
+        );
       }
     })
     .catch(() => {});
@@ -103,13 +123,23 @@ async function placePrimitiveOnTerrain(primitive, position, scene, offset) {
  * @param {import("@vcmap-cesium/engine").Scene} scene
  * @returns {null|{ primitives: Array<import("@vcmap-cesium/engine").Model>, options: VectorPropertiesModelOptions }}
  */
-export function getModelOptions(feature, wgs84Positions, positions, vectorProperties, scene) {
+export function getModelOptions(
+  feature,
+  wgs84Positions,
+  positions,
+  vectorProperties,
+  scene,
+) {
   const options = vectorProperties.getModel(feature);
   if (!options) {
     return null;
   }
   const scale = Cartesian3.fromArray(options.scale);
-  const headingPitchRoll = HeadingPitchRoll.fromDegrees(options.heading, options.pitch, options.roll);
+  const headingPitchRoll = HeadingPitchRoll.fromDegrees(
+    options.heading,
+    options.pitch,
+    options.roll,
+  );
   const allowPicking = vectorProperties.getAllowPicking(feature);
   const primitives = positions.map((position, index) => {
     const modelMatrix = Matrix4.multiply(
@@ -159,35 +189,43 @@ function getGeometryInstanceFromOptions(options, color, outline) {
   const { type } = options;
   let geometry;
   if (type === PrimitiveOptionsType.CYLINDER) {
-    geometry = outline ?
-      new CylinderOutlineGeometry(options.geometryOptions) :
-      new CylinderGeometry(options.geometryOptions);
+    geometry = outline
+      ? new CylinderOutlineGeometry(options.geometryOptions)
+      : new CylinderGeometry(options.geometryOptions);
   } else if (type === PrimitiveOptionsType.ELLIPSOID) {
     if (Array.isArray(options.geometryOptions.radii)) {
-      options.geometryOptions.radii = Cartesian3.fromArray(options.geometryOptions.radii);
+      options.geometryOptions.radii = Cartesian3.fromArray(
+        options.geometryOptions.radii,
+      );
     }
     if (Array.isArray(options.geometryOptions.innerRadii)) {
-      options.geometryOptions.innerRadii = Cartesian3.fromArray(options.geometryOptions.innerRadii);
+      options.geometryOptions.innerRadii = Cartesian3.fromArray(
+        options.geometryOptions.innerRadii,
+      );
     }
-    geometry = outline ?
-      new EllipsoidOutlineGeometry(options.geometryOptions) :
-      new EllipsoidGeometry(options.geometryOptions);
+    geometry = outline
+      ? new EllipsoidOutlineGeometry(options.geometryOptions)
+      : new EllipsoidGeometry(options.geometryOptions);
   }
   if (type === PrimitiveOptionsType.SPHERE) {
-    geometry = outline ?
-      new SphereOutlineGeometry(options.geometryOptions) :
-      new SphereGeometry(options.geometryOptions);
+    geometry = outline
+      ? new SphereOutlineGeometry(options.geometryOptions)
+      : new SphereGeometry(options.geometryOptions);
   }
   if (type === PrimitiveOptionsType.BOX) {
     if (Array.isArray(options.geometryOptions.minimum)) {
-      options.geometryOptions.minimum = Cartesian3.fromArray(options.geometryOptions.minimum);
+      options.geometryOptions.minimum = Cartesian3.fromArray(
+        options.geometryOptions.minimum,
+      );
     }
     if (Array.isArray(options.geometryOptions.maximum)) {
-      options.geometryOptions.maximum = Cartesian3.fromArray(options.geometryOptions.maximum);
+      options.geometryOptions.maximum = Cartesian3.fromArray(
+        options.geometryOptions.maximum,
+      );
     }
-    geometry = outline ?
-      new BoxOutlineGeometry(options.geometryOptions) :
-      new BoxGeometry(options.geometryOptions);
+    geometry = outline
+      ? new BoxOutlineGeometry(options.geometryOptions)
+      : new BoxGeometry(options.geometryOptions);
   }
 
   if (geometry) {
@@ -210,7 +248,14 @@ function getGeometryInstanceFromOptions(options, color, outline) {
  * @param {import("@vcmap-cesium/engine").Scene} scene
  * @returns {null|{ primitives: Array<import("@vcmap-cesium/engine").Primitive>, options: VectorPropertiesPrimitive}}
  */
-export function getPrimitiveOptions(feature, style, wgs84Positions, positions, vectorProperties, scene) {
+export function getPrimitiveOptions(
+  feature,
+  style,
+  wgs84Positions,
+  positions,
+  vectorProperties,
+  scene,
+) {
   const options = vectorProperties.getPrimitive(feature);
   if (!options) {
     return null;
@@ -222,7 +267,8 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
   if (imageStyle instanceof RegularShape) {
     fill = imageStyle.getFill();
     stroke = imageStyle.getStroke();
-  } else if (imageStyle) { // XXX or should we only allow primitives with regular shapes defined as image?
+  } else if (imageStyle) {
+    // XXX or should we only allow primitives with regular shapes defined as image?
     fill = style.getFill();
     stroke = style.getStroke(); // XXX this makes it impossible to create an extruded un-stroked primitive with an icon in 2D or we add a new primitive option
   }
@@ -240,8 +286,11 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
   }
 
   const scale = Cartesian3.fromArray(options.scale);
-  const headingPitchRoll = HeadingPitchRoll
-    .fromDegrees(options.heading, options.pitch, options.roll);
+  const headingPitchRoll = HeadingPitchRoll.fromDegrees(
+    options.heading,
+    options.pitch,
+    options.roll,
+  );
   const allowPicking = vectorProperties.getAllowPicking(feature);
 
   const primitives = positions.flatMap((position, index) => {
@@ -255,7 +304,10 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
         geometryModelMatrix,
       );
     }
-    const transform = Transforms.headingPitchRollToFixedFrame(position, headingPitchRoll);
+    const transform = Transforms.headingPitchRollToFixedFrame(
+      position,
+      headingPitchRoll,
+    );
     const modelMatrix = Matrix4.multiply(
       transform,
       geometryModelMatrix,
@@ -264,7 +316,10 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
 
     let deptFail;
     if (options.primitiveOptions.depthFailColor) {
-      const depthFailColor = getCesiumColor(options.primitiveOptions.depthFailColor, [255, 255, 255, 0.4]);
+      const depthFailColor = getCesiumColor(
+        options.primitiveOptions.depthFailColor,
+        [255, 255, 255, 0.4],
+      );
       deptFail = new MaterialAppearance({
         translucent: depthFailColor.alpha < 1,
         material: Material.fromType('Color', {
@@ -273,7 +328,11 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
       });
     }
 
-    const createPrimitive = (translucent, geometryInstances, depthFailAppearance) => {
+    const createPrimitive = (
+      translucent,
+      geometryInstances,
+      depthFailAppearance,
+    ) => {
       const primitive = new Primitive({
         asynchronous: !feature[createSync],
         geometryInstances,
@@ -288,10 +347,15 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
       });
 
       if (!wgs84Positions[index][2]) {
-        placePrimitiveOnTerrain(primitive, position, scene, offset)
-          .then(() => {
-            Transforms.headingPitchRollToFixedFrame(position, headingPitchRoll, undefined, undefined, transform); // update transform for usage in offset auto scale
-          });
+        placePrimitiveOnTerrain(primitive, position, scene, offset).then(() => {
+          Transforms.headingPitchRollToFixedFrame(
+            position,
+            headingPitchRoll,
+            undefined,
+            undefined,
+            transform,
+          ); // update transform for usage in offset auto scale
+        });
       }
 
       if (options.autoScale) {
@@ -308,7 +372,7 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
     if (fillColor) {
       fillAndOutline.push(
         createPrimitive(
-          (fillColor.alpha < 1) || !!deptFail,
+          fillColor.alpha < 1 || !!deptFail,
           [getGeometryInstanceFromOptions(options.primitiveOptions, fillColor)],
           deptFail,
         ),
@@ -318,17 +382,25 @@ export function getPrimitiveOptions(feature, style, wgs84Positions, positions, v
       fillAndOutline.push(
         createPrimitive(
           true,
-          [getGeometryInstanceFromOptions(options.primitiveOptions, transparent)],
+          [
+            getGeometryInstanceFromOptions(
+              options.primitiveOptions,
+              transparent,
+            ),
+          ],
           deptFail,
         ),
       );
     }
     if (strokeColor) {
       fillAndOutline.push(
-        createPrimitive(
-          (strokeColor.alpha < 1) || !!deptFail,
-          [getGeometryInstanceFromOptions(options.primitiveOptions, strokeColor, true)],
-        ),
+        createPrimitive(strokeColor.alpha < 1 || !!deptFail, [
+          getGeometryInstanceFromOptions(
+            options.primitiveOptions,
+            strokeColor,
+            true,
+          ),
+        ]),
       );
     }
     return fillAndOutline;