@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/style/writeStyle.js

@@ -1,48 +0,0 @@
-import VectorStyleItem from './vectorStyleItem.js';
-import DeclarativeStyleItem from './declarativeStyleItem.js';
-import { referenceableStyleSymbol } from './styleItem.js';
-
-/**
- * @param {VectorStyleItemOptions} obj
- * @param {Array<string>=} embeddedIcons
- * @returns {VectorStyleItemOptions}
- */
-export function embedIconsInStyle(obj, embeddedIcons) {
-  if (
-    obj.image &&
-    obj.image.src &&
-    /^data:/.test(obj.image.src)
-  ) {
-    if (embeddedIcons) {
-      let index = embeddedIcons.indexOf(obj.image.src);
-      if (index === -1) {
-        embeddedIcons.push(obj.image.src);
-        index = embeddedIcons.length - 1;
-      }
-      obj.image.src = `:${index}`;
-    } else {
-      obj.image = { // XXX is this the correct fallback?
-        radius: 5,
-      };
-    }
-  }
-  return obj;
-}
-
-/**
- * @param {import("@vcmap/core").StyleItem} style
- * @param {VcsMeta=} vcsMeta
- * @returns {VcsMeta}
- */
-function writeStyle(style, vcsMeta = {}) {
-  if (style[referenceableStyleSymbol]) { // XXX this should be configurable. In some cases, writting out the actual style would be desirable
-    vcsMeta.style = style.getReference();
-  } else if (style instanceof VectorStyleItem) {
-    vcsMeta.style = embedIconsInStyle(style.getOptions(), vcsMeta.embeddedIcons);
-  } else if (style instanceof DeclarativeStyleItem) {
-    vcsMeta.style = style.getOptions();
-  }
-  return vcsMeta;
-}
-
-export default writeStyle;

package/src/util/dateTime.js

@@ -1,60 +0,0 @@
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleDate(date, locale) {
-  // dateStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { dateStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @param {string=} locale
- * @returns {string}
- */
-export function getShortLocaleTime(date, locale) {
-  // timeStyle is not within the standard yet
-  // @ts-ignore
-  return new Intl.DateTimeFormat(locale, { timeStyle: 'short' }).format(date);
-}
-
-/**
- * @param {Date} date
- * @returns {string}
- */
-export function getISODateString(date) {
-  const month = date.getMonth() + 1;
-  const day = date.getDate();
-  return `${date.getFullYear()}-${month > 9 ? '' : 0}${month}-${day > 9 ? '' : 0}${day}`;
-}
-
-/**
- * @param {Date} date
- * @returns {number}
- */
-export function getDayOfYear(date) {
-  const start = new Date(date.getFullYear(), 0, 0);
-  // TS cant handle date manipulation
-  // @ts-ignore
-  const diff = (date - start) + ((start.getTimezoneOffset() - date.getTimezoneOffset()) * 60 * 1000);
-  const oneDay = 1000 * 60 * 60 * 24;
-  return Math.floor(diff / oneDay);
-}
-
-/**
- * @param {Date} date
- * @returns {boolean}
- */
-export function isLeapYear(date) {
-  const currentYear = date.getFullYear();
-  if (currentYear % 4 !== 0) {
-    return false;
-  } else if (currentYear % 100 !== 0) {
-    return true;
-  } else if (currentYear % 400 !== 0) {
-    return false;
-  }
-  return true;
-}

package/src/util/extent.js

@@ -1,131 +0,0 @@
-import Projection from './projection.js';
-
-/**
- * @typedef {Object} ExtentOptions
- * @property {string} [type]
- * @property {import("ol/extent").Extent|undefined} [coordinates] - if not specified, the extent of the projection is used
- * @property {ProjectionOptions} [projection] - if not specified the default projection is assumed
- * @api
- */
-
-/**
- * checks extent validity, point extent is also valid
- * @param {import("ol/extent").Extent} extent
- * @returns {boolean}
- */
-function checkExtentValidity(extent) {
-  if (!extent || !Array.isArray(extent) || extent.length !== 4) {
-    return false;
-  }
-
-  if (
-    !Number.isFinite(extent[0]) ||
-    !Number.isFinite(extent[1]) ||
-    !Number.isFinite(extent[2]) ||
-    !Number.isFinite(extent[3])
-  ) {
-    return false;
-  }
-  return extent[0] <= extent[2] && extent[1] <= extent[3];
-}
-
-
-/**
- * Extent Class
- * @class
- * @export
- * @api
- */
-class Extent {
-  /**
-   * @type {string}
-   */
-  static get className() { return 'Extent'; }
-
-  /**
-   * @param {ExtentOptions=} options object
-   */
-  constructor(options = {}) {
-    /** @type {Projection} */
-    this.projection = new Projection(options.projection);
-
-    /** @type {import("ol/extent").Extent|null} */
-    this.extent = options.coordinates || this.projection.proj.getExtent();
-  }
-
-  /**
-   * @param {Projection} destination
-   * @param {import("ol/extent").Extent=} result
-   * @returns {import("ol/extent").Extent}
-   */
-  getCoordinatesInProjection(destination, result) {
-    if (destination.epsg === this.projection.epsg) { // TODO aliases?!
-      const extent = result ? result.splice(0, 4, ...this.extent) : this.extent.slice();
-      return /** @type {import("ol/extent").Extent} */ (extent);
-    }
-    const transformer = Projection
-      .getTransformer(destination, this.projection);
-    const target = result || [];
-    transformer(this.extent, target, 2);
-    return /** @type {import("ol/extent").Extent} */ (target);
-  }
-
-  /**
-   * only checks for null/nan numbers, does not check for spatial validity of the extent
-   * @returns {boolean} true if extent is valid
-   */
-  isValid() {
-    return checkExtentValidity(this.extent);
-  }
-
-  /**
-   * @returns {ExtentOptions}
-   */
-  toJSON() {
-    return {
-      coordinates: this.extent.slice(),
-      projection: this.projection.toJSON(),
-      type: Extent.className,
-    };
-  }
-
-  /**
-   * @returns {Extent}
-   */
-  clone() {
-    return new Extent(this.toJSON());
-  }
-
-  /**
-   * @param {Extent} extent
-   * @returns {boolean}
-   */
-  equals(extent) {
-    if (this === extent) {
-      return true;
-    }
-
-    return this.isValid() &&
-      extent.isValid() &&
-      this.extent.every((c, i) => c === extent.extent[i]) &&
-      this.projection.equals(extent.projection);
-  }
-
-  /**
-   * validates extent options, checks for valid projection and the geometry of the given coordinates.
-   * The Coordinate extent is also valid if its a point extent
-   * @param {ExtentOptions} options
-   * @returns {boolean}
-   * @api
-   */
-  static validateOptions(options) {
-    return Projection.validateOptions(options.projection || {}) && checkExtentValidity(options.coordinates);
-  }
-
-  /**
-   * @type {import("ol/extent").Extent}
-   */
-  static get WGS_84_EXTENT() { return [-180, -90, 180, 90]; }
-}
-
-export default Extent;

package/src/util/featureconverter/circleToCesium.js

@@ -1,215 +0,0 @@
-import { circular } from 'ol/geom/Polygon.js';
-import GeometryType from 'ol/geom/GeometryType.js';
-import {
-  Cartesian3,
-  CircleGeometry,
-  GroundPolylineGeometry,
-  CircleOutlineGeometry,
-  Math as CesiumMath,
-  Cartographic,
-  PolylineGeometry,
-} from '@vcmap/cesium';
-import { parseNumber } from '@vcsuite/parsers';
-import { addPrimitivesToContext } from './featureconverterHelper.js';
-import Projection from '../projection.js';
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").CircleGeometry>}
- * @private
- */
-export function createSolidGeometries(options, height, perPositionHeight, extrudedHeight) {
-  return [new CircleGeometry({
-    ...options,
-    height,
-    granularity: 0.02,
-    extrudedHeight,
-  })];
-}
-
-/**
- * @param {Object} options
- * @param {number} height
- * @param {boolean} perPositionHeight
- * @param {number=} extrudedHeight
- * @returns {Array<import("@vcmap/cesium").CircleOutlineGeometry>}
- * @private
- */
-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>}
- * @private
- */
-export function createFillGeometries(options, height, perPositionHeight) {
-  return createSolidGeometries(options, height, perPositionHeight, undefined);
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {{width: number, positions: Array}}
- * @private
- */
-export function getLineGeometryOptions(options, style) {
-  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,
-  };
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").GroundPolylineGeometry>}
- * @private
- */
-export function createGroundLineGeometries(options, style) {
-  const lineOptions = getLineGeometryOptions(options, style);
-  return [new GroundPolylineGeometry(lineOptions)];
-}
-
-/**
- * @param {Object} options
- * @param {import("ol/style/Style").default} style
- * @returns {Array<import("@vcmap/cesium").PolylineGeometry>}
- * @private
- */
-export function createLineGeometries(options, style) {
-  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 {import("ol/geom/Circle").default} geometry
- * @param {number} positionHeightAdjustment
- * @returns {{center: import("@vcmap/cesium").Cartesian3, radius: Number}}
- * @private
- */
-export function getGeometryOptions(geometry, positionHeightAdjustment) {
-  // 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,
-  };
-}
-
-/**
- * @param {Array<import("ol/geom/Circle").default>} geometries
- * @returns {Array<import("ol/coordinate").Coordinate>}
- * @private
- */
-export function getCoordinates(geometries) {
-  return geometries.map((circle) => {
-    return circle.getCenter();
-  });
-}
-
-/**
- * @type {VectorGeometryFactoryType|null}
- */
-let geometryFactory = null;
-
-/**
- * @returns {VectorGeometryFactoryType}
- */
-function getGeometryFactory() {
-  if (!geometryFactory) {
-    geometryFactory = {
-      getCoordinates,
-      getGeometryOptions,
-      createSolidGeometries,
-      createOutlineGeometries,
-      createFillGeometries,
-      createGroundLineGeometries,
-      createLineGeometries,
-    };
-  }
-  return geometryFactory;
-}
-
-/**
- * validates if a point is renderable
- * @param {import("ol/geom/Circle").default} circle
- * @returns {boolean}
- */
-export function validateCircle(circle) {
-  if (circle.getType() !== GeometryType.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;
-}
-
-
-/**
- * @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/core").VectorContext|import("@vcmap/core").ClusterContext} 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));
-  addPrimitivesToContext(
-    feature, style, validGeometries, vectorProperties, scene, circleGeometryFactory, context,
-  );
-}

package/src/util/featureconverter/convert.js

@@ -1,83 +0,0 @@
-import Polygon from 'ol/geom/Polygon.js';
-import LineString from 'ol/geom/LineString.js';
-import Circle from 'ol/geom/Circle.js';
-import Point from 'ol/geom/Point.js';
-import MultiPolygon from 'ol/geom/MultiPolygon.js';
-import MultiLineString from 'ol/geom/MultiLineString.js';
-import MultiPoint from 'ol/geom/MultiPoint.js';
-import Style from 'ol/style/Style.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';
-
-/**
- * @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/core").VectorContext|import("@vcmap/core").ClusterContext} 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);
-  } else if (geometry instanceof LineString) {
-    lineStringToCesium(feature, style, [geometry], vectorProperties, scene, context);
-  } else if (geometry instanceof Circle) {
-    circleToCesium(feature, style, [geometry], vectorProperties, scene, context);
-  } else if (geometry instanceof MultiPoint) {
-    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) {
-    lineStringToCesium(feature, style, geometry.getLineStrings(), vectorProperties, scene, context);
-  } else if (geometry instanceof GeometryCollection) {
-    geometry.getGeometries().forEach((currentGeometry) => {
-      convertGeometry(feature, currentGeometry, style, vectorProperties, scene, context);
-    });
-  }
-}
-
-/**
- * @param {void|import("ol/style/Style").StyleLike} style
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {number=} resolution
- * @returns {Array<import("ol/style/Style").default>}
- */
-export function getStylesArray(style, feature, resolution = 1) {
-  const styles = [];
-  if (typeof style === 'function') {
-    styles.push(...getStylesArray(style(feature, resolution), 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 contexts 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
- */
-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));
-    if (geometry) {
-      convertGeometry(feature, geometry, currentStyle, vectorProperties, scene, context);
-    }
-  });
-}