@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/util/featureconverter/polygonToCesium.js

@@ -1,229 +0,0 @@
-import {
-  Cartesian3,
-  PolygonGeometry,
-  PerInstanceColorAppearance,
-  PolygonOutlineGeometry,
-  GroundPolylineGeometry,
-  PolygonHierarchy,
-  PolylineGeometry,
-} from '@vcmap/cesium';
-import GeometryType from 'ol/geom/GeometryType.js';
-import { parseNumber } from '@vcsuite/parsers';
-import { addPrimitivesToContext } from './featureconverterHelper.js';
-import Projection from '../projection.js';
-import { getFlatCoordinatesFromSimpleGeometry } from '../geometryHelpers.js';
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").PolygonGeometry>}
- * @private
- */
-export function createSolidGeometries(options, height, perPositionHeight, extrudedHeight) {
-  const polygonOptions = {
-    ...options,
-    perPositionHeight,
-    extrudedHeight,
-  };
-  if (!perPositionHeight) {
-    polygonOptions.height = height;
-  }
-  return [new PolygonGeometry(polygonOptions)];
-}
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").PolygonOutlineGeometry>}
- * @private
- */
-export function createOutlineGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [new PolygonOutlineGeometry({
-    ...options,
-    height: perPositionHeight ? undefined : height,
-    extrudedHeight,
-    perPositionHeight,
-    vertexFormat: PerInstanceColorAppearance.FLAT_VERTEX_FORMAT,
-  })];
-}
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @returns {Array<import("@vcmap/cesium").PolygonGeometry>}
- * @private
- */
-export function createFillGeometries(options, height, perPositionHeight) {
-  return createSolidGeometries(options, height, perPositionHeight, undefined);
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<Object>}
- * @private
- */
-export function getLineGeometryOptions(options, style) {
-  const width = parseNumber(style.getStroke().getWidth(), 1.0);
-  const geometryOptions = [];
-  geometryOptions.push({
-    positions: options.polygonHierarchy.positions,
-    width,
-  });
-  options.polygonHierarchy.holes.forEach((polygonHierarchy) => {
-    geometryOptions.push({
-      positions: polygonHierarchy.positions,
-      width,
-    });
-  });
-  return geometryOptions;
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<GroundPolylineGeometry>}
- * @private
- */
-export function createGroundLineGeometries(options, style) {
-  return getLineGeometryOptions(options, style).map((option) => {
-    return new GroundPolylineGeometry(option);
-  });
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<PolylineGeometry>}
- * @private
- */
-export function createLineGeometries(options, style) {
-  return getLineGeometryOptions(options, style).map((option) => {
-    return new PolylineGeometry(option);
-  });
-}
-
-
-/**
- * @param {import("ol/geom/Polygon").default} geometry
- * @param {number} positionHeightAdjustment
- * @returns {Object}
- * @private
- */
-export function getGeometryOptions(geometry, positionHeightAdjustment) {
-  let hieraryPositions;
-  const holes = [];
-  const rings = geometry.getLinearRings();
-  for (let i = 0; i < rings.length; i++) {
-    const coords = rings[i].getCoordinates();
-    const positions = coords.map((coord) => {
-      const wgs84Coords = Projection.mercatorToWgs84(coord);
-      if (wgs84Coords[2] != null) {
-        wgs84Coords[2] += positionHeightAdjustment;
-      }
-      return Cartesian3.fromDegrees(wgs84Coords[0], wgs84Coords[1], wgs84Coords[2]);
-    });
-    // make sure the last and first vertex is identical.
-    if (!Cartesian3.equals(positions[0], positions[positions.length - 1])) {
-      positions.push(positions[0]);
-    }
-    if (i === 0) {
-      hieraryPositions = positions;
-    } else {
-      holes.push(new PolygonHierarchy(positions));
-    }
-  }
-  return {
-    polygonHierarchy: new PolygonHierarchy(hieraryPositions, holes),
-  };
-}
-
-/**
- * @param {Array<import("ol/geom/Polygon").default>} geometries
- * @returns {Array<import("ol/coordinate").Coordinate>}
- * @private
- */
-export function getCoordinates(geometries) {
-  const coordinates = [];
-  geometries.forEach((polygon) => {
-    coordinates.push(...getFlatCoordinatesFromSimpleGeometry(polygon));
-  });
-  return coordinates;
-}
-
-/**
- * @type {VectorGeometryFactoryType|null}
- */
-let geometryFactory = null;
-
-/**
- * @returns {VectorGeometryFactoryType}
- */
-function getGeometryFactory() {
-  if (!geometryFactory) {
-    geometryFactory = {
-      getCoordinates,
-      getGeometryOptions,
-      createSolidGeometries,
-      createOutlineGeometries,
-      createFillGeometries,
-      createGroundLineGeometries,
-      createLineGeometries,
-    };
-  }
-  return geometryFactory;
-}
-
-/**
- * TODO maybe add validation Functions to OpenlayersMap
- * validates if a polygon is renderable
- * @param {import("ol/geom/Polygon").default} polygon
- * @returns {boolean}
- */
-export function validatePolygon(polygon) {
-  if (polygon.getType() !== GeometryType.POLYGON) {
-    return false;
-  }
-  const flatCoordinates = polygon.getFlatCoordinates();
-  const ends = polygon.getEnds();
-  const stride = polygon.getStride();
-  const valid = ends.every((end, index) => {
-    const previous = index ? ends[index - 1] : 0;
-    const currentRingSize = end - previous;
-    return currentRingSize >= stride * 3;
-  });
-  if (!valid) {
-    return false;
-  }
-  // should have at least three coordinates for each linearRing and every value should be a number
-  const minimumValues = stride * 3 * polygon.getLinearRingCount();
-  if (flatCoordinates && flatCoordinates.length >= minimumValues && polygon.getLinearRingCount()) {
-    return flatCoordinates.every(value => Number.isFinite(value));
-  }
-  return false;
-}
-
-/**
- * converts a polygon to a a cesium primitive, with optional labels
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {import("ol/style/Style").default} style
- * @param {Array<import("ol/geom/Polygon").default>} geometries
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
- */
-export default function polygonToCesium(feature, style, geometries, vectorProperties, scene, context) {
-  if (!style.getFill() && !style.getStroke()) {
-    return;
-  }
-  const polygonGeometryFactory = getGeometryFactory();
-  const validGeometries = geometries.filter(polygon => validatePolygon(polygon));
-  addPrimitivesToContext(
-    feature, style, validGeometries, vectorProperties, scene, polygonGeometryFactory, context,
-  );
-}

package/src/util/fetch.js

@@ -1,32 +0,0 @@
-/**
- * @param {string} url
- * @param {RequestInit=} init
- * @returns {Promise<Response>}
- */
-export async function requestUrl(url, init) {
-  const response = await fetch(url, init);
-  if (!response.ok) {
-    throw new Error(`Failed fetching url ${url} with status: ${response.status}`);
-  }
-  return response;
-}
-
-/**
- * @param {string} url
- * @param {RequestInit=} init
- * @returns {Promise<any>}
- */
-export async function requestJson(url, init) {
-  const response = await requestUrl(url, init);
-  return response.json();
-}
-
-/**
- * @param {string} url
- * @param {RequestInit=} init
- * @returns {Promise<ArrayBuffer>}
- */
-export async function requestArrayBuffer(url, init) {
-  const response = await requestUrl(url, init);
-  return response.arrayBuffer();
-}

package/src/util/geometryHelpers.js

@@ -1,172 +0,0 @@
-import { offset } from 'ol/sphere.js';
-import Circle from 'ol/geom/Circle.js';
-import Point from 'ol/geom/Point.js';
-import LineString from 'ol/geom/LineString.js';
-import Polygon, { fromCircle } from 'ol/geom/Polygon.js';
-import MultiPoint from 'ol/geom/MultiPoint.js';
-import MultiLineString from 'ol/geom/MultiLineString.js';
-import MultiPolygon from 'ol/geom/MultiPolygon.js';
-import GeometryCollection from 'ol/geom/GeometryCollection.js';
-import Projection from './projection.js';
-
-/**
- * @param {import("ol/geom/SimpleGeometry").default} geometry
- * @returns {Array<import("ol/coordinate").Coordinate>}
- */
-export function getFlatCoordinatesFromSimpleGeometry(geometry) {
-  const stride = geometry.getStride();
-  const flatCoordinates = geometry.getFlatCoordinates();
-  if (flatCoordinates.length) {
-    const numberOfCoordinates = Math.floor(flatCoordinates.length / stride);
-    const coordinates = new Array(numberOfCoordinates);
-    for (let i = 0; i < numberOfCoordinates; i++) {
-      const flatIndex = i * stride;
-      const coord = new Array(stride);
-      for (let j = 0; j < stride; j++) {
-        coord[j] = flatCoordinates[flatIndex + j];
-      }
-      coordinates[i] = coord;
-    }
-    return coordinates;
-  }
-  return [];
-}
-
-/**
- * @param {import("ol/geom/Geometry").default} geometry
- * @param {Array=} inputCoordinates
- * @returns {Array.<import("ol/coordinate").Coordinate>}
- */
-export function getFlatCoordinatesFromGeometry(geometry, inputCoordinates) {
-  const coordinates = inputCoordinates || geometry.getCoordinates();
-  let flattenCoordinates = null;
-  if (geometry instanceof Point) {
-    flattenCoordinates = [coordinates];
-  } else if (geometry instanceof LineString) {
-    flattenCoordinates = coordinates;
-  } else if (geometry instanceof Polygon) {
-    flattenCoordinates = coordinates.reduce((current, next) => current.concat(next));
-  } else if (geometry instanceof MultiPoint) {
-    flattenCoordinates = coordinates;
-  } else if (geometry instanceof MultiLineString) {
-    flattenCoordinates = coordinates.reduce((current, next) => current.concat(next));
-  } else if (geometry instanceof MultiPolygon) {
-    flattenCoordinates = coordinates
-      .reduce((current, next) => current.concat(next))
-      .reduce((current, next) => current.concat(next));
-  } else if (geometry instanceof Circle) {
-    flattenCoordinates = coordinates;
-  } else if (geometry instanceof GeometryCollection) {
-    flattenCoordinates = geometry.getGeometries()
-      .map((g, i) => getFlatCoordinatesFromGeometry(g, coordinates[i]))
-      .reduce((current, next) => current.concat(next));
-  }
-  return flattenCoordinates;
-}
-
-/**
- * @param {import("ol/coordinate").Coordinate} center
- * @param {number} radius
- * @returns {import("ol/geom/Circle").default}
- */
-export function circleFromCenterRadius(center, radius) {
-  const offsetWGS84 = offset(Projection.mercatorToWgs84(center), radius, Math.PI / 2);
-  const of = Projection.wgs84ToMercator(offsetWGS84);
-  const dx = center[0] - of[0];
-  const dy = center[1] - of[1];
-  const dx2 = dx * dx;
-  const dy2 = dy * dy;
-  const radiusProjected = Math.sqrt(dx2 + dy2);
-  return new Circle(
-    center,
-    radiusProjected,
-    'XYZ',
-  );
-}
-
-/**
- * @param {import("ol/geom/Geometry").default} geometry
- * @returns {import("ol/geom/Geometry").default}
- */
-export function convertGeometryToPolygon(geometry) {
-  if (geometry instanceof Circle) {
-    return fromCircle(geometry);
-  } else if (geometry instanceof Polygon) {
-    geometry.unset('_vcsGeomType');
-  }
-  return geometry;
-}
-
-/**
- * @param {Array<import("ol/coordinate").Coordinate>} linearRing
- */
-export function enforceEndingVertex(linearRing) {
-  const [lastX, lastY] = linearRing[linearRing.length - 1];
-  if (!(linearRing[0][0] === lastX && linearRing[0][1] === lastY)) {
-    linearRing.push(linearRing[0].slice());
-  }
-}
-
-/**
- * @param {Array<import("ol/coordinate").Coordinate>} linearRing
- */
-export function removeEndingVertex(linearRing) {
-  const [lastX, lastY] = linearRing[linearRing.length - 1];
-  if (linearRing[0][0] === lastX && linearRing[0][1] === lastY) {
-    linearRing.pop();
-  }
-}
-
-/**
- * @param {import("ol/geom/Geometry").default} geometry
- */
-export function removeEndingVertexFromGeometry(geometry) {
-  if (geometry instanceof Polygon) {
-    const coordinates = geometry.getCoordinates();
-    coordinates.forEach((ring) => {
-      removeEndingVertex(ring);
-    });
-    geometry.setCoordinates(coordinates);
-  } else if (geometry instanceof MultiPolygon) {
-    const coordinates = geometry.getCoordinates();
-    coordinates.forEach((poly) => {
-      poly.forEach((ring) => {
-        removeEndingVertex(ring);
-      });
-    });
-    geometry.setCoordinates(coordinates);
-  }
-}
-
-/**
- * from @mapbox/geojson-area
- * @param {Array<Array<number>>}ring
- * @returns {number}
- */
-function ringArea(ring) {
-  let area = 0;
-  const positions = ring.length;
-
-  for (let i = 0; i <= positions - 2; i++) {
-    const p1 = ring[i];
-    const p2 = ring[i + 1];
-    area += ((p1[0] * p2[1]) - (p1[1] * p2[0]));
-  }
-
-  area /= 2;
-  return area;
-}
-
-/**
- * enforce a ring to be counter-clockwise
- * @param {Array<import("ol/coordinate").Coordinate>} ring
- * @returns {Array<import("ol/coordinate").Coordinate>}
- */
-export function enforceRightHand(ring) {
-  const area = ringArea(ring);
-  if (area < 0) {
-    ring.reverse();
-  }
-
-  return ring;
-}

package/src/util/indexedCollection.js

@@ -1,181 +0,0 @@
-import VcsEvent from '../vcsEvent.js';
-import Collection from './collection.js';
-
-/**
- * A generic array based collection. Implements the Symbol.iterator (e.g. [...collection])
- * @class
- * @export
- * @template {*} T
- * @extends {Collection<T>}
- * @api
- */
-class IndexedCollection extends Collection {
-  /**
-   * Creates a Collection from an iterable, such as an Array.
-   * @template {*} T
-   * @param {Iterable<T>} iterable
-   * @param {(string|symbol|boolean)=} [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
-   * @returns {IndexedCollection<T>}
-   * @override
-   * @api
-   */
-  static from(iterable, uniqueKey) {
-    const collection = /** @type {IndexedCollection<T>} */ (new IndexedCollection(uniqueKey));
-    if (iterable) {
-      // eslint-disable-next-line no-restricted-syntax
-      for (const i of iterable) {
-        collection.add(i);
-      }
-    }
-    return collection;
-  }
-
-  /**
-   * @param {(string|symbol|boolean)=} [uniqueKey='name'] - a key to maintain uniquely within the collection. passing false disables uniqueness.
-   */
-  constructor(uniqueKey) {
-    super(uniqueKey);
-
-    /**
-     * Event raised if an item is relocated within the collection. Is passed the moved item.
-     * @type {VcsEvent<T>}
-     * @api
-     */
-    this.moved = new VcsEvent();
-
-    /**
-     * @type {symbol}
-     * @private
-     */
-    this._previousIndexSymbol = Symbol('previousIndex');
-  }
-
-  /**
-   * Get the symbol which is attached to an item prior to its removal. If an item is removed, the current index of the item
-   * is set on the item with this symbol.
-   * @type {symbol}
-   * @readonly
-   */
-  get previousIndexSymbol() { return this._previousIndexSymbol; }
-
-  /**
-   * Returns an item at index.
-   * @param {number} index
-   * @returns {T}
-   * @api
-   */
-  get(index) {
-    return this._array[index];
-  }
-
-  /**
-   * Adds an item to the collection. Can optionally be passed an index at which to insert the item.
-   * @param {T} item - the item to be inserted
-   * @param {number=} index - an optional index at which to insert the item. clipped to the last entry
-   * @returns {number|null} the index at which the item was inserted
-   * @api
-   */
-  add(item, index) {
-    if (this._checkUniqueness(item)) {
-      let actualIndex = this._array.length;
-      if (index != null && index < this._array.length) {
-        actualIndex = index >= 0 ? index : 0;
-        this._array.splice(actualIndex, 0, item);
-      } else {
-        this._array.push(item);
-      }
-      this.added.raiseEvent(item);
-      return actualIndex;
-    }
-    return null;
-  }
-
-  /**
-   * @inheritDoc
-   * @param {T} item
-   */
-  remove(item) {
-    item[this._previousIndexSymbol] = this._array.indexOf(item);
-    super.remove(item);
-  }
-
-  /**
-   * @param {T} item
-   * @param {number} itemIndex
-   * @param {number} targetIndex
-   * @returns {number}
-   * @protected
-   */
-  _move(item, itemIndex, targetIndex) {
-    let target = targetIndex;
-    target = target >= 0 ? target : 0;
-    target = target < this._array.length ? target : this._array.length - 1;
-    this._array.splice(itemIndex, 1);
-    this._array.splice(target, 0, item);
-    this.moved.raiseEvent(item);
-    return target;
-  }
-
-  /**
-   * Lowers an item within the array
-   * @param {T} item
-   * @param {number} [steps=1] - an integer number to lower by
-   * @returns {number|null} the new index of the item
-   * @api
-   */
-  lower(item, steps = 1) {
-    const index = this._array.indexOf(item);
-    if (index > -1) {
-      return this._move(item, index, index - Math.ceil(steps));
-    }
-    return null;
-  }
-
-  /**
-   * Raises an item within the array
-   * @param {T} item
-   * @param {number} [steps=1] - an integer number to lower by
-   * @returns {number|null} the new index of the item
-   * @api
-   */
-  raise(item, steps = 1) {
-    const index = this._array.indexOf(item);
-    if (index > -1) {
-      return this._move(item, index, index + Math.ceil(steps));
-    }
-    return null;
-  }
-
-  /**
-   * Returns the index of an item or -1 if it is not part of this collection
-   * @param {T} item
-   * @returns {number}
-   * @api
-   */
-  indexOf(item) {
-    return this._array.indexOf(item);
-  }
-
-  /**
-   * Returns the index of a key. Returns undefined, if there is no uniqueness constraint
-   * @param {*} value
-   * @returns {number}
-   * @api
-   */
-  indexOfKey(value) {
-    if (!this.uniqueKey) {
-      return undefined;
-    }
-    return this._array.findIndex(e => e[this.uniqueKey] === value);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  destroy() {
-    super.destroy();
-    this.moved.destroy();
-  }
-}
-
-export default IndexedCollection;