@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/util/featureconverter/circleToCesium.ts

@@ -0,0 +1,211 @@
+import { circular } from 'ol/geom/Polygon.js';
+import type { Style } from 'ol/style.js';
+import type { Circle } from 'ol/geom.js';
+import type { Coordinate } from 'ol/coordinate.js';
+import type { Feature } from 'ol/index.js';
+
+import {
+  Cartesian3,
+  CircleGeometry,
+  GroundPolylineGeometry,
+  CircleOutlineGeometry,
+  Math as CesiumMath,
+  Cartographic,
+  PolylineGeometry,
+  type Scene,
+} from '@vcmap-cesium/engine';
+import { parseNumber } from '@vcsuite/parsers';
+import { addPrimitivesToContext } from './featureconverterHelper.js';
+import Projection from '../projection.js';
+import type { VectorGeometryFactoryType } from '../../layer/vectorLayer.js';
+import type VectorProperties from '../../layer/vectorProperties.js';
+import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
+
+export function createSolidGeometries(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  height: number,
+  _perPositionHeight: boolean,
+  extrudedHeight?: number,
+): CircleGeometry[] {
+  return [
+    new CircleGeometry({
+      ...options,
+      height,
+      granularity: 0.02,
+      extrudedHeight,
+    }),
+  ];
+}
+
+export function createOutlineGeometries(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  height: number,
+  _perPositionHeight: boolean,
+  extrudedHeight?: number,
+): CircleOutlineGeometry[] {
+  return [
+    new CircleOutlineGeometry({
+      ...options,
+      height,
+      extrudedHeight,
+      granularity: 0.02,
+    }),
+  ];
+}
+
+export function createFillGeometries(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  height: number,
+  perPositionHeight: boolean,
+): CircleGeometry[] {
+  return createSolidGeometries(options, height, perPositionHeight, undefined);
+}
+
+export function getLineGeometryOptions(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  style: Style,
+): { width: number; positions: Cartesian3[] } {
+  const width = parseNumber(style.getStroke().getWidth(), 1.0);
+  const { center, radius } = options;
+  const cartographic = Cartographic.fromCartesian(center);
+  const wgs84Center = [
+    CesiumMath.toDegrees(cartographic.longitude),
+    CesiumMath.toDegrees(cartographic.latitude),
+  ];
+
+  // circular returns polygon with GeometryLayout.XY
+  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);
+  });
+  return {
+    positions,
+    width,
+  };
+}
+
+export function createGroundLineGeometries(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  style: Style,
+): GroundPolylineGeometry[] {
+  const lineOptions = getLineGeometryOptions(options, style);
+  return [new GroundPolylineGeometry(lineOptions)];
+}
+
+export function createLineGeometries(
+  options: ConstructorParameters<typeof CircleGeometry>[0],
+  style: Style,
+): PolylineGeometry[] {
+  const lineOptions = getLineGeometryOptions(options, style);
+  return [new PolylineGeometry(lineOptions)];
+}
+
+/**
+ * extracts the center and radius from the CircleGeometry and converts it to Cartesian3/radius in m
+ * @param  geometry
+ * @param  positionHeightAdjustment
+ * @returns }
+ * @private
+ */
+export function getGeometryOptions(
+  geometry: Circle,
+  positionHeightAdjustment: number,
+): ConstructorParameters<typeof CircleGeometry>[0] {
+  // olCoordinates of center and radius in WGS84
+  const olCenter = geometry.getCenter();
+  const olPoint = olCenter.slice();
+  olPoint[0] += geometry.getRadius();
+  const wgs84Center = Projection.mercatorToWgs84(olCenter, true);
+  if (wgs84Center[2] != null) {
+    wgs84Center[2] += 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],
+  );
+
+  // Computation of radius in Cesium 3D
+  const radius = Cartesian3.distance(center, point);
+  return {
+    radius,
+    center,
+  };
+}
+
+export function getCoordinates(geometries: Circle[]): Coordinate[] {
+  return geometries.map((circle) => {
+    return circle.getCenter();
+  });
+}
+
+let geometryFactory: VectorGeometryFactoryType | null = null;
+
+function getGeometryFactory(): VectorGeometryFactoryType {
+  if (!geometryFactory) {
+    geometryFactory = {
+      getCoordinates,
+      getGeometryOptions,
+      createSolidGeometries,
+      createOutlineGeometries,
+      createFillGeometries,
+      createGroundLineGeometries,
+      createLineGeometries,
+    };
+  }
+  return geometryFactory;
+}
+
+/**
+ * validates if a point is renderable
+ */
+export function validateCircle(circle: Circle): boolean {
+  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));
+  }
+  return false;
+}
+
+export default function circleToCesium(
+  feature: Feature,
+  style: Style,
+  geometries: Circle[],
+  vectorProperties: VectorProperties,
+  scene: Scene,
+  context: AsyncCesiumVectorContext,
+): void {
+  if (!style.getFill() && !style.getStroke()) {
+    return;
+  }
+  const circleGeometryFactory = getGeometryFactory();
+  const validGeometries = geometries.filter((circle) => validateCircle(circle));
+  addPrimitivesToContext(
+    feature,
+    style,
+    validGeometries,
+    vectorProperties,
+    scene,
+    circleGeometryFactory,
+    context,
+  );
+}

package/src/util/featureconverter/convert.ts

@@ -0,0 +1,178 @@
+import {
+  type Geometry,
+  Polygon,
+  LineString,
+  Circle,
+  Point,
+  MultiPoint,
+  MultiLineString,
+  MultiPolygon,
+} from 'ol/geom.js';
+import type { Scene } from '@vcmap-cesium/engine';
+import Style, { type StyleLike } from 'ol/style/Style.js';
+import type { Feature } from 'ol/index.js';
+import GeometryCollection from 'ol/geom/GeometryCollection.js';
+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';
+import type VectorProperties from '../../layer/vectorProperties.js';
+import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
+
+async function convertGeometry(
+  feature: Feature,
+  geometry: Geometry,
+  style: Style,
+  vectorProperties: VectorProperties,
+  scene: Scene,
+  context: AsyncCesiumVectorContext,
+): Promise<void> {
+  if (geometry instanceof Point) {
+    await pointToCesium(
+      feature,
+      style,
+      [geometry],
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof Polygon) {
+    polygonToCesium(
+      feature,
+      style,
+      [geometry],
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof LineString) {
+    if (style instanceof ArcStyle && feature[featureArcStruct]?.coordinates) {
+      await arcToCesium(
+        feature,
+        style,
+        [geometry],
+        vectorProperties,
+        scene,
+        context,
+      );
+    } else {
+      await lineStringToCesium(
+        feature,
+        style,
+        [geometry],
+        vectorProperties,
+        scene,
+        context,
+      );
+    }
+  } else if (geometry instanceof Circle) {
+    circleToCesium(
+      feature,
+      style,
+      [geometry],
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof MultiPoint) {
+    await pointToCesium(
+      feature,
+      style,
+      geometry.getPoints(),
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof MultiPolygon) {
+    polygonToCesium(
+      feature,
+      style,
+      geometry.getPolygons(),
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof MultiLineString) {
+    await lineStringToCesium(
+      feature,
+      style,
+      geometry.getLineStrings(),
+      vectorProperties,
+      scene,
+      context,
+    );
+  } else if (geometry instanceof GeometryCollection) {
+    await Promise.all(
+      geometry.getGeometries().map(async (currentGeometry) => {
+        await convertGeometry(
+          feature,
+          currentGeometry,
+          style,
+          vectorProperties,
+          scene,
+          context,
+        );
+      }),
+    );
+  }
+}
+
+export function getStylesArray(
+  style: StyleLike,
+  feature: Feature,
+  resolution = 1,
+): Style[] {
+  const styles = [];
+  if (typeof style === 'function') {
+    styles.push(
+      ...getStylesArray(
+        style(feature, resolution) as StyleLike,
+        feature,
+        resolution,
+      ),
+    );
+  } else if (Array.isArray(style)) {
+    style.forEach((currentStyle) => {
+      styles.push(...getStylesArray(currentStyle, feature, resolution));
+    });
+  } else if (style instanceof Style) {
+    styles.push(style);
+  }
+  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
+ * @param  feature
+ * @param  style
+ * @param  vectorProperties
+ * @param  context
+ * @param  scene
+ */
+export default async function convert(
+  feature: Feature,
+  style: StyleLike,
+  vectorProperties: VectorProperties,
+  context: AsyncCesiumVectorContext,
+  scene: Scene,
+): Promise<void> {
+  const styles = getStylesArray(feature.getStyle() || style, feature, 0);
+  await Promise.all(
+    styles.map(async (currentStyle) => {
+      const geometry = currentStyle.getGeometryFunction()(feature) as Geometry;
+      if (geometry) {
+        await convertGeometry(
+          feature,
+          geometry,
+          currentStyle,
+          vectorProperties,
+          scene,
+          context,
+        );
+      }
+    }),
+  );
+}

package/src/util/featureconverter/extent3D.ts

@@ -0,0 +1,217 @@
+import { check } from '@vcsuite/check';
+import type {
+  Geometry,
+  GeometryCollection,
+  Circle,
+  SimpleGeometry,
+} from 'ol/geom.js';
+import type { Extent } from 'ol/extent.js';
+import type { Coordinate } from 'ol/coordinate.js';
+import { VectorHeightInfo } from '../../layer/vectorLayer.js';
+
+class Extent3D {
+  static fromArray(
+    array: [number, number, number, number, number, number],
+  ): Extent3D {
+    check(array, [Number]);
+    check(array.length, 6);
+    return new Extent3D(
+      array[0],
+      array[1],
+      array[2],
+      array[3],
+      array[4],
+      array[5],
+    );
+  }
+
+  static fromGeometry(geometry?: Geometry): Extent3D {
+    const extent = new Extent3D();
+    extent.extendWithGeometry(geometry);
+    return extent;
+  }
+
+  /**
+   * @param  heightInfo
+   */
+  static fromHeightInfo(heightInfo: VectorHeightInfo): Extent3D {
+    const extent = new Extent3D();
+    extent.extendWithHeightInfo(heightInfo);
+    return extent;
+  }
+
+  static fromCoordinates(coordinates: Coordinate[]): Extent3D {
+    check(coordinates, [[Number]]);
+
+    const extent = new Extent3D();
+    coordinates.forEach((c) => {
+      extent.extendXYZ(c[0], c[1], c[2] ?? 0);
+    });
+    return extent;
+  }
+
+  minX: number;
+
+  minY: number;
+
+  minZ: number;
+
+  maxX: number;
+
+  maxY: number;
+
+  maxZ: number;
+
+  constructor(
+    minX = Infinity,
+    minY = Infinity,
+    minZ = Infinity,
+    maxX = -Infinity,
+    maxY = -Infinity,
+    maxZ = -Infinity,
+  ) {
+    this.minX = minX;
+    this.minY = minY;
+    this.minZ = minZ;
+    this.maxX = maxX;
+    this.maxY = maxY;
+    this.maxZ = maxZ;
+  }
+
+  extendWithGeometry(geometry?: Geometry): void {
+    if (!geometry) {
+      return;
+    }
+    if (geometry.getType() === 'GeometryCollection') {
+      (geometry as GeometryCollection).getGeometriesArray().forEach((geom) => {
+        this.extendWithGeometry(geom);
+      });
+    } else if (geometry.getType() === 'Circle') {
+      const flatCoordinates = geometry.getFlatCoordinates();
+      const stride = (geometry as Circle).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 = geometry.getFlatCoordinates();
+      const stride = (geometry as SimpleGeometry).getStride();
+      this.extendFlatCoordinates(flatCoordinates, stride);
+    }
+  }
+
+  extendWithHeightInfo(heightInfo: VectorHeightInfo): void {
+    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);
+    }
+  }
+
+  extendXYZ(x: number, y: number, z: number): void {
+    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);
+  }
+
+  extendXY(x: number, y: number): void {
+    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);
+  }
+
+  extendZ(z: number): void {
+    this.minZ = Math.min(this.minZ, z);
+    this.maxZ = Math.max(this.maxZ, z);
+  }
+
+  extendFlatCoordinates(flatCoordinates: number[], stride: number): void {
+    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]);
+      }
+    }
+  }
+
+  to2D(): Extent {
+    return [this.minX, this.minY, this.maxX, this.maxY];
+  }
+
+  toArray(): [number, number, number, number, number, number] {
+    return [this.minX, this.minY, this.minZ, this.maxX, this.maxY, this.maxZ];
+  }
+
+  isEmpty(): boolean {
+    return (
+      this.minX === Infinity &&
+      this.minY === Infinity &&
+      this.minZ === Infinity &&
+      this.maxX === -Infinity &&
+      this.maxY === -Infinity &&
+      this.maxZ === -Infinity
+    );
+  }
+
+  getCenter(): Coordinate {
+    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,
+    ];
+  }
+
+  getSize(): [number, number, number] {
+    if (this.isEmpty()) {
+      return [0, 0, 0];
+    }
+    return [
+      this.maxX - this.minX,
+      this.maxY - this.minY,
+      this.maxZ - this.minZ,
+    ];
+  }
+
+  clone(): Extent3D {
+    return new Extent3D(
+      this.minX,
+      this.minY,
+      this.minZ,
+      this.maxX,
+      this.maxY,
+      this.maxZ,
+    );
+  }
+}
+
+export default Extent3D;