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

package/src/util/featureconverter/circleToCesium.js

@@ -20,13 +20,20 @@ import Projection from '../projection.js';
  * @returns {Array<import("@vcmap-cesium/engine").CircleGeometry>}
  * @private
  */
-export function createSolidGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [new CircleGeometry({
-    ...options,
-    height,
-    granularity: 0.02,
-    extrudedHeight,
-  })];
+export function createSolidGeometries(
+  options,
+  height,
+  perPositionHeight,
+  extrudedHeight,
+) {
+  return [
+    new CircleGeometry({
+      ...options,
+      height,
+      granularity: 0.02,
+      extrudedHeight,
+    }),
+  ];
 }
 
 /**
@@ -37,13 +44,20 @@ export function createSolidGeometries(options, height, perPositionHeight, extrud
  * @returns {Array<import("@vcmap-cesium/engine").CircleOutlineGeometry>}
  * @private
  */
-export function createOutlineGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [new CircleOutlineGeometry({
-    ...options,
-    height,
-    extrudedHeight,
-    granularity: 0.02,
-  })];
+export function createOutlineGeometries(
+  options,
+  height,
+  perPositionHeight,
+  extrudedHeight,
+) {
+  return [
+    new CircleOutlineGeometry({
+      ...options,
+      height,
+      extrudedHeight,
+      granularity: 0.02,
+    }),
+  ];
 }
 
 /**
@@ -73,11 +87,7 @@ export function getLineGeometryOptions(options, style) {
   ];
 
   // circular returns polygon with GeometryLayout.XY
-  const circlePolygon = circular(
-    wgs84Center,
-    radius,
-    40,
-  );
+  const circlePolygon = circular(wgs84Center, radius, 40);
   const pos = circlePolygon.getLinearRing(0).getCoordinates();
   const positions = pos.map((coord) => {
     return Cartesian3.fromDegrees(coord[0], coord[1], cartographic.height);
@@ -130,8 +140,16 @@ export function getGeometryOptions(geometry, positionHeightAdjustment) {
   const wgs84Point = Projection.mercatorToWgs84(olPoint, true);
 
   // Cesium coordinates of center and radius
-  const center = Cartesian3.fromDegrees(wgs84Center[0], wgs84Center[1], wgs84Center[2]);
-  const point = Cartesian3.fromDegrees(wgs84Point[0], wgs84Point[1], wgs84Center[2]);
+  const center = Cartesian3.fromDegrees(
+    wgs84Center[0],
+    wgs84Center[1],
+    wgs84Center[2],
+  );
+  const point = Cartesian3.fromDegrees(
+    wgs84Point[0],
+    wgs84Point[1],
+    wgs84Center[2],
+  );
 
   // Computation of radius in Cesium 3D
   const radius = Cartesian3.distance(center, point);
@@ -187,13 +205,16 @@ export function validateCircle(circle) {
   const flatCoordinates = circle.getFlatCoordinates();
   const stride = circle.getStride();
   // needs at least one full coordinate + a radius value and a non 0 radius
-  if (flatCoordinates && flatCoordinates.length >= stride + 1 && flatCoordinates[stride] !== flatCoordinates[0]) {
-    return flatCoordinates.every(value => Number.isFinite(value));
+  if (
+    flatCoordinates &&
+    flatCoordinates.length >= stride + 1 &&
+    flatCoordinates[stride] !== flatCoordinates[0]
+  ) {
+    return flatCoordinates.every((value) => Number.isFinite(value));
   }
   return false;
 }
 
-
 /**
  * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
  * @param {import("ol/style/Style").default} style
@@ -202,13 +223,26 @@ export function validateCircle(circle) {
  * @param {import("@vcmap-cesium/engine").Scene} scene
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
  */
-export default function circleToCesium(feature, style, geometries, vectorProperties, scene, context) {
+export default function circleToCesium(
+  feature,
+  style,
+  geometries,
+  vectorProperties,
+  scene,
+  context,
+) {
   if (!style.getFill() && !style.getStroke()) {
     return;
   }
   const circleGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter(circle => validateCircle(circle));
+  const validGeometries = geometries.filter((circle) => validateCircle(circle));
   addPrimitivesToContext(
-    feature, style, validGeometries, vectorProperties, scene, circleGeometryFactory, context,
+    feature,
+    style,
+    validGeometries,
+    vectorProperties,
+    scene,
+    circleGeometryFactory,
+    context,
   );
 }

package/src/util/featureconverter/convert.js

@@ -22,28 +22,84 @@ import ArcStyle, { featureArcStruct } from '../../style/arcStyle.js';
  * @param {import("@vcmap-cesium/engine").Scene} scene
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
  */
-function convertGeometry(feature, geometry, style, vectorProperties, scene, context) {
+function convertGeometry(
+  feature,
+  geometry,
+  style,
+  vectorProperties,
+  scene,
+  context,
+) {
   if (geometry instanceof Point) {
     pointToCesium(feature, style, [geometry], vectorProperties, scene, context);
   } else if (geometry instanceof Polygon) {
-    polygonToCesium(feature, style, [geometry], vectorProperties, scene, context);
+    polygonToCesium(
+      feature,
+      style,
+      [geometry],
+      vectorProperties,
+      scene,
+      context,
+    );
   } else if (geometry instanceof LineString) {
     if (style instanceof ArcStyle && feature[featureArcStruct].coordinates) {
       arcToCesium(feature, style, [geometry], vectorProperties, scene, context);
     } else {
-      lineStringToCesium(feature, style, [geometry], vectorProperties, scene, context);
+      lineStringToCesium(
+        feature,
+        style,
+        [geometry],
+        vectorProperties,
+        scene,
+        context,
+      );
     }
   } else if (geometry instanceof Circle) {
-    circleToCesium(feature, style, [geometry], vectorProperties, scene, context);
+    circleToCesium(
+      feature,
+      style,
+      [geometry],
+      vectorProperties,
+      scene,
+      context,
+    );
   } else if (geometry instanceof MultiPoint) {
-    pointToCesium(feature, style, geometry.getPoints(), vectorProperties, scene, context);
+    pointToCesium(
+      feature,
+      style,
+      geometry.getPoints(),
+      vectorProperties,
+      scene,
+      context,
+    );
   } else if (geometry instanceof MultiPolygon) {
-    polygonToCesium(feature, style, geometry.getPolygons(), vectorProperties, scene, context);
+    polygonToCesium(
+      feature,
+      style,
+      geometry.getPolygons(),
+      vectorProperties,
+      scene,
+      context,
+    );
   } else if (geometry instanceof MultiLineString) {
-    lineStringToCesium(feature, style, geometry.getLineStrings(), vectorProperties, scene, context);
+    lineStringToCesium(
+      feature,
+      style,
+      geometry.getLineStrings(),
+      vectorProperties,
+      scene,
+      context,
+    );
   } else if (geometry instanceof GeometryCollection) {
     geometry.getGeometries().forEach((currentGeometry) => {
-      convertGeometry(feature, currentGeometry, style, vectorProperties, scene, context);
+      convertGeometry(
+        feature,
+        currentGeometry,
+        style,
+        vectorProperties,
+        scene,
+        context,
+      );
     });
   }
 }
@@ -57,7 +113,9 @@ function convertGeometry(feature, geometry, style, vectorProperties, scene, cont
 export function getStylesArray(style, feature, resolution = 1) {
   const styles = [];
   if (typeof style === 'function') {
-    styles.push(...getStylesArray(style(feature, resolution), feature, resolution));
+    styles.push(
+      ...getStylesArray(style(feature, resolution), feature, resolution),
+    );
   } else if (Array.isArray(style)) {
     style.forEach((currentStyle) => {
       styles.push(...getStylesArray(currentStyle, feature, resolution));
@@ -68,7 +126,6 @@ export function getStylesArray(style, feature, resolution = 1) {
   return styles;
 }
 
-
 /**
  * function to convert a feature to an array of Cesium.Primitives given a style and default properties. the resulting primitives
  * must be added to the modules collections here
@@ -78,12 +135,27 @@ export function getStylesArray(style, feature, resolution = 1) {
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
  * @param {import("@vcmap-cesium/engine").Scene} scene
  */
-export default function convert(feature, style, vectorProperties, context, scene) {
+export default function convert(
+  feature,
+  style,
+  vectorProperties,
+  context,
+  scene,
+) {
   const styles = getStylesArray(feature.getStyle() || style, feature, 0);
   styles.forEach((currentStyle) => {
-    const geometry = /** @type {import("ol/geom/Geometry").default} */(currentStyle.getGeometryFunction()(feature));
+    const geometry = /** @type {import("ol/geom/Geometry").default} */ (
+      currentStyle.getGeometryFunction()(feature)
+    );
     if (geometry) {
-      convertGeometry(feature, geometry, currentStyle, vectorProperties, scene, context);
+      convertGeometry(
+        feature,
+        geometry,
+        currentStyle,
+        vectorProperties,
+        scene,
+        context,
+      );
     }
   });
 }

package/src/util/featureconverter/extent3D.js

@@ -11,7 +11,14 @@ class Extent3D {
   static fromArray(array) {
     check(array, [Number]);
     check(array.length, 6);
-    return new Extent3D(array[0], array[1], array[2], array[3], array[4], array[5]);
+    return new Extent3D(
+      array[0],
+      array[1],
+      array[2],
+      array[3],
+      array[4],
+      array[5],
+    );
   }
 
   /**
@@ -56,7 +63,14 @@ class Extent3D {
    * @param {number} maxY
    * @param {number} maxZ
    */
-  constructor(minX = Infinity, minY = Infinity, minZ = Infinity, maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity) {
+  constructor(
+    minX = Infinity,
+    minY = Infinity,
+    minZ = Infinity,
+    maxX = -Infinity,
+    maxY = -Infinity,
+    maxZ = -Infinity,
+  ) {
     /**
      * @type {number}
      */
@@ -89,25 +103,31 @@ class Extent3D {
   extendWithGeometry(geometry) {
     if (geometry.getType() === 'GeometryCollection') {
       /** @type {import("ol/geom/GeometryCollection").default} */ (geometry)
-        .getGeometriesArray().forEach((geom) => { this.extendWithGeometry(geom); });
+        .getGeometriesArray()
+        .forEach((geom) => {
+          this.extendWithGeometry(geom);
+        });
     } else if (geometry.getType() === 'Circle') {
-      const flatCoordinates = /** @type {import("ol/geom/Circle").default} */ (geometry).getFlatCoordinates();
-      const stride = /** @type {import("ol/geom/Circle").default} */ (geometry).getStride();
+      const flatCoordinates = /** @type {import("ol/geom/Circle").default} */ (
+        geometry
+      ).getFlatCoordinates();
+      const stride = /** @type {import("ol/geom/Circle").default} */ (
+        geometry
+      ).getStride();
       const radius = flatCoordinates[stride] - flatCoordinates[0];
-      this.extendXY(
-        flatCoordinates[0] - radius,
-        flatCoordinates[1] - radius,
-      );
-      this.extendXY(
-        flatCoordinates[0] + radius,
-        flatCoordinates[1] + radius,
-      );
+      this.extendXY(flatCoordinates[0] - radius, flatCoordinates[1] - radius);
+      this.extendXY(flatCoordinates[0] + radius, flatCoordinates[1] + radius);
       if (stride > 2) {
         this.extendZ(flatCoordinates[2]);
       }
     } else {
-      const flatCoordinates = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getFlatCoordinates();
-      const stride = /** @type {import("ol/geom/SimpleGeometry").default} */ (geometry).getStride();
+      const flatCoordinates =
+        /** @type {import("ol/geom/SimpleGeometry").default} */ (
+          geometry
+        ).getFlatCoordinates();
+      const stride = /** @type {import("ol/geom/SimpleGeometry").default} */ (
+        geometry
+      ).getStride();
       this.extendFlatCoordinates(flatCoordinates, stride);
     }
   }
@@ -118,14 +138,22 @@ class Extent3D {
   extendWithHeightInfo(heightInfo) {
     if (heightInfo.extruded) {
       const calculatedFeatureMaxHeight =
-        heightInfo.groundLevel + heightInfo.storeyHeightsAboveGround.reduce((accumulator, currentValue) => {
-          return accumulator + currentValue;
-        }, 0);
+        heightInfo.groundLevel +
+        heightInfo.storeyHeightsAboveGround.reduce(
+          (accumulator, currentValue) => {
+            return accumulator + currentValue;
+          },
+          0,
+        );
       this.extendZ(calculatedFeatureMaxHeight);
       const calculatedFeatureMinHeight =
-        heightInfo.groundLevel - heightInfo.storeyHeightsBelowGround.reduce((accumulator, currentValue) => {
-          return accumulator + currentValue;
-        }, 0);
+        heightInfo.groundLevel -
+        heightInfo.storeyHeightsBelowGround.reduce(
+          (accumulator, currentValue) => {
+            return accumulator + currentValue;
+          },
+          0,
+        );
       this.extendZ(calculatedFeatureMinHeight);
     }
   }
@@ -171,7 +199,11 @@ class Extent3D {
     const { length } = flatCoordinates;
     for (let offset = 0; offset < length; offset += stride) {
       if (stride > 2) {
-        this.extendXYZ(flatCoordinates[offset], flatCoordinates[offset + 1], flatCoordinates[offset + 2]);
+        this.extendXYZ(
+          flatCoordinates[offset],
+          flatCoordinates[offset + 1],
+          flatCoordinates[offset + 2],
+        );
       } else {
         this.extendXY(flatCoordinates[offset], flatCoordinates[offset + 1]);
       }
@@ -196,12 +228,14 @@ class Extent3D {
    * @returns {boolean}
    */
   isEmpty() {
-    return this.minX === Infinity &&
+    return (
+      this.minX === Infinity &&
       this.minY === Infinity &&
       this.minZ === Infinity &&
       this.maxX === -Infinity &&
       this.maxY === -Infinity &&
-      this.maxZ === -Infinity;
+      this.maxZ === -Infinity
+    );
   }
 
   /**
@@ -212,9 +246,9 @@ class Extent3D {
       return [0, 0, 0];
     }
     return [
-      this.minX + ((this.maxX - this.minX) / 2),
-      this.minY + ((this.maxY - this.minY) / 2),
-      this.minZ + ((this.maxZ - this.minZ) / 2),
+      this.minX + (this.maxX - this.minX) / 2,
+      this.minY + (this.maxY - this.minY) / 2,
+      this.minZ + (this.maxZ - this.minZ) / 2,
     ];
   }
 
@@ -236,7 +270,14 @@ class Extent3D {
    * @returns {Extent3D}
    */
   clone() {
-    return new Extent3D(this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ);
+    return new Extent3D(
+      this.minX,
+      this.minY,
+      this.minZ,
+      this.maxX,
+      this.maxY,
+      this.maxZ,
+    );
   }
 }