@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.30

package/src/{vcs/vcm/util → util}/featureconverter/circleToCesium.js

@@ -1,5 +1,4 @@
 import { circular } from 'ol/geom/Polygon.js';
-import GeometryType from 'ol/geom/GeometryType.js';
 import {
   Cartesian3,
   CircleGeometry,
@@ -8,7 +7,7 @@ import {
   Math as CesiumMath,
   Cartographic,
   PolylineGeometry,
-} from '@vcmap/cesium';
+} from '@vcmap-cesium/engine';
 import { parseNumber } from '@vcsuite/parsers';
 import { addPrimitivesToContext } from './featureconverterHelper.js';
 import Projection from '../projection.js';
@@ -18,16 +17,23 @@ import Projection from '../projection.js';
  * @param {number} height
  * @param {boolean} perPositionHeight
  * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").CircleGeometry>}
+ * @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,
+    }),
+  ];
 }
 
 /**
@@ -35,23 +41,30 @@ export function createSolidGeometries(options, height, perPositionHeight, extrud
  * @param {number} height
  * @param {boolean} perPositionHeight
  * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").CircleOutlineGeometry>}
+ * @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,
+    }),
+  ];
 }
 
 /**
  * @param {Object} options
  * @param {number} height
  * @param {boolean} perPositionHeight
- * @returns {Array<import("@vcmap/cesium").CircleGeometry>}
+ * @returns {Array<import("@vcmap-cesium/engine").CircleGeometry>}
  * @private
  */
 export function createFillGeometries(options, height, perPositionHeight) {
@@ -74,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);
@@ -92,7 +101,7 @@ export function getLineGeometryOptions(options, style) {
 /**
  * @param {Object} options
  * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").GroundPolylineGeometry>}
+ * @returns {Array<import("@vcmap-cesium/engine").GroundPolylineGeometry>}
  * @private
  */
 export function createGroundLineGeometries(options, style) {
@@ -103,7 +112,7 @@ export function createGroundLineGeometries(options, style) {
 /**
  * @param {Object} options
  * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").PolylineGeometry>}
+ * @returns {Array<import("@vcmap-cesium/engine").PolylineGeometry>}
  * @private
  */
 export function createLineGeometries(options, style) {
@@ -115,7 +124,7 @@ export function createLineGeometries(options, style) {
  * extracts the center and radius from the CircleGeometry and converts it to Cartesian3/radius in m
  * @param {import("ol/geom/Circle").default} geometry
  * @param {number} positionHeightAdjustment
- * @returns {{center: import("@vcmap/cesium").Cartesian3, radius: Number}}
+ * @returns {{center: import("@vcmap-cesium/engine").Cartesian3, radius: Number}}
  * @private
  */
 export function getGeometryOptions(geometry, positionHeightAdjustment) {
@@ -131,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);
@@ -182,34 +199,50 @@ function getGeometryFactory() {
  * @returns {boolean}
  */
 export function validateCircle(circle) {
-  if (circle.getType() !== GeometryType.CIRCLE) {
+  if (circle.getType() !== 'Circle') {
     return false;
   }
   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
  * @param {Array<import("ol/geom/Circle").default>} geometries
  * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {import("@vcmap/cesium").Scene} scene
+ * @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/{vcs/vcm/util → util}/featureconverter/convert.js

@@ -11,33 +11,95 @@ import polygonToCesium from './polygonToCesium.js';
 import circleToCesium from './circleToCesium.js';
 import lineStringToCesium from './lineStringToCesium.js';
 import pointToCesium from './pointToCesium.js';
+import arcToCesium from './arcToCesium.js';
+import ArcStyle, { featureArcStruct } from '../../style/arcStyle.js';
 
 /**
  * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
  * @param {import("ol/geom/Geometry").default} geometry
  * @param {import("ol/style/Style").default} style
  * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {import("@vcmap/cesium").Scene} scene
+ * @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) {
-    lineStringToCesium(feature, style, [geometry], vectorProperties, scene, context);
+    if (style instanceof ArcStyle && feature[featureArcStruct].coordinates) {
+      arcToCesium(feature, style, [geometry], vectorProperties, scene, context);
+    } else {
+      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,
+      );
     });
   }
 }
@@ -51,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));
@@ -62,22 +126,36 @@ 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 contexts collections here
+ * must be added to the modules collections here
  * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
  * @param {import("ol/style/Style").StyleLike} style
  * @param {import("@vcmap/core").VectorProperties} vectorProperties
  * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
- * @param {import("@vcmap/cesium").Scene} scene
+ * @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

@@ -0,0 +1,284 @@
+import { check } from '@vcsuite/check';
+
+/**
+ * @class
+ */
+class Extent3D {
+  /**
+   * @param {Array<number>} array
+   * @returns {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],
+    );
+  }
+
+  /**
+   * @param {import("ol/geom").Geometry} geometry
+   * @returns {Extent3D}
+   */
+  static fromGeometry(geometry) {
+    const extent = new Extent3D();
+    extent.extendWithGeometry(geometry);
+    return extent;
+  }
+
+  /**
+   * @param {VectorHeightInfo} heightInfo
+   * @returns {Extent3D}
+   */
+  static fromHeightInfo(heightInfo) {
+    const extent = new Extent3D();
+    extent.extendWithHeightInfo(heightInfo);
+    return extent;
+  }
+
+  /**
+   * @param {Array<import("ol/coordinate").Coordinate>} coordinates
+   * @returns {Extent3D}
+   */
+  static fromCoordinates(coordinates) {
+    check(coordinates, [[Number]]);
+
+    const extent = new Extent3D();
+    coordinates.forEach((c) => {
+      extent.extendXYZ(c[0], c[1], c[2] ?? 0);
+    });
+    return extent;
+  }
+
+  /**
+   * @param {number} minX
+   * @param {number} minY
+   * @param {number} minZ
+   * @param {number} maxX
+   * @param {number} maxY
+   * @param {number} maxZ
+   */
+  constructor(
+    minX = Infinity,
+    minY = Infinity,
+    minZ = Infinity,
+    maxX = -Infinity,
+    maxY = -Infinity,
+    maxZ = -Infinity,
+  ) {
+    /**
+     * @type {number}
+     */
+    this.minX = minX;
+    /**
+     * @type {number}
+     */
+    this.minY = minY;
+    /**
+     * @type {number}
+     */
+    this.minZ = minZ;
+    /**
+     * @type {number}
+     */
+    this.maxX = maxX;
+    /**
+     * @type {number}
+     */
+    this.maxY = maxY;
+    /**
+     * @type {number}
+     */
+    this.maxZ = maxZ;
+  }
+
+  /**
+   * @param {import("ol/geom").Geometry} geometry
+   */
+  extendWithGeometry(geometry) {
+    if (geometry.getType() === 'GeometryCollection') {
+      /** @type {import("ol/geom/GeometryCollection").default} */ (geometry)
+        .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 radius = flatCoordinates[stride] - flatCoordinates[0];
+      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();
+      this.extendFlatCoordinates(flatCoordinates, stride);
+    }
+  }
+
+  /**
+   * @param {VectorHeightInfo} heightInfo
+   */
+  extendWithHeightInfo(heightInfo) {
+    if (heightInfo.extruded) {
+      const calculatedFeatureMaxHeight =
+        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,
+        );
+      this.extendZ(calculatedFeatureMinHeight);
+    }
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   */
+  extendXYZ(x, y, z) {
+    this.minX = Math.min(this.minX, x);
+    this.minY = Math.min(this.minY, y);
+    this.minZ = Math.min(this.minZ, z);
+    this.maxX = Math.max(this.maxX, x);
+    this.maxY = Math.max(this.maxY, y);
+    this.maxZ = Math.max(this.maxZ, z);
+  }
+
+  /**
+   * @param {number} x
+   * @param {number} y
+   */
+  extendXY(x, y) {
+    this.minX = Math.min(this.minX, x);
+    this.minY = Math.min(this.minY, y);
+    this.maxX = Math.max(this.maxX, x);
+    this.maxY = Math.max(this.maxY, y);
+  }
+
+  /**
+   * @param {number} z
+   */
+  extendZ(z) {
+    this.minZ = Math.min(this.minZ, z);
+    this.maxZ = Math.max(this.maxZ, z);
+  }
+
+  /**
+   * @param {Array<number>} flatCoordinates
+   * @param {number} stride
+   */
+  extendFlatCoordinates(flatCoordinates, stride) {
+    const { length } = flatCoordinates;
+    for (let offset = 0; offset < length; offset += stride) {
+      if (stride > 2) {
+        this.extendXYZ(
+          flatCoordinates[offset],
+          flatCoordinates[offset + 1],
+          flatCoordinates[offset + 2],
+        );
+      } else {
+        this.extendXY(flatCoordinates[offset], flatCoordinates[offset + 1]);
+      }
+    }
+  }
+
+  /**
+   * @returns {import("ol/extent").Extent}
+   */
+  to2D() {
+    return [this.minX, this.minY, this.maxX, this.maxY];
+  }
+
+  /**
+   * @returns {Array<number>}
+   */
+  toArray() {
+    return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return (
+      this.minX === Infinity &&
+      this.minY === Infinity &&
+      this.minZ === Infinity &&
+      this.maxX === -Infinity &&
+      this.maxY === -Infinity &&
+      this.maxZ === -Infinity
+    );
+  }
+
+  /**
+   * @returns {import("ol/coordinate").Coordinate}
+   */
+  getCenter() {
+    if (this.isEmpty()) {
+      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,
+    ];
+  }
+
+  /**
+   * @returns {Array<number>}
+   */
+  getSize() {
+    if (this.isEmpty()) {
+      return [0, 0, 0];
+    }
+    return [
+      this.maxX - this.minX,
+      this.maxY - this.minY,
+      this.maxZ - this.minZ,
+    ];
+  }
+
+  /**
+   * @returns {Extent3D}
+   */
+  clone() {
+    return new Extent3D(
+      this.minX,
+      this.minY,
+      this.minZ,
+      this.maxX,
+      this.maxY,
+      this.maxZ,
+    );
+  }
+}
+
+export default Extent3D;