@vcmap/core 5.0.0-rc.0

package/src/vcs/vcm/util/featureProvider/wmsFeatureProvider.js

@@ -0,0 +1,280 @@
+import axios from 'axios';
+import GML2 from 'ol/format/GML2.js';
+import WFS from 'ol/format/WFS.js';
+import GeoJSON from 'ol/format/GeoJSON.js';
+import GML3 from 'ol/format/GML3.js';
+import Point from 'ol/geom/Point.js';
+import { getTransform } from 'ol/proj.js';
+import { parseInteger } from '@vcsuite/parsers';
+import AbstractFeatureProvider from './abstractFeatureProvider.js';
+import Projection, { mercatorProjection } from '../projection.js';
+import { getWMSSource } from '../../layer/wmsHelpers.js';
+import Extent from '../extent.js';
+
+/**
+ * @typedef {AbstractFeatureProviderOptions} WMSFeatureProviderOptions
+ * @property {string|undefined} [responseType='text/xml'] - the response type for the feature info
+ * @property {Object|undefined} formatOptions - format options for the GeoJSON, WFS or GML format. To overwrite the gmlFormat option in WFS format, use 'GML', 'GML2' or 'GML3' as string
+ * @property {ProjectionOptions|undefined} projection - the projection of the data, if not encoded in the response
+ * @property {string} url
+ * @property {string} [tilingSchema='geographic'] -  either "geographic" or "mercator"
+ * @property {number} [maxLevel=18]
+ * @property {number} [minLevel=0]
+ * @property {import("ol/size").Size} [tileSize=[256,256]]
+ * @property {Extent|ExtentOptions|undefined} extent
+ * @property {Object<string, string>} parameters
+ * @property {string} [version='1.1.1']
+ * @api
+ */
+
+const gmlFormats = {
+  GML: GML3,
+  GML2,
+  GML3,
+};
+
+/**
+ * @type {Array<string>}
+ * @const
+ */
+const geojsonFormats = [
+  'application/geojson',
+  'application/json',
+  'application/vnd.geo+json',
+];
+
+/**
+ * @param {string} responseType
+ * @param {Object} options
+ * @returns {null|import("ol/format/Feature").default}
+ */
+export function getFormat(responseType, options = {}) {
+  if (responseType === 'text/xml') {
+    options.gmlFormat = options.gmlFormat ? new gmlFormats[options.gmlFormat]() : new GML2();
+    return new WFS(options);
+  }
+  if (geojsonFormats.includes(responseType)) {
+    return new GeoJSON(options);
+  }
+  if (responseType === 'application/vnd.ogc.gml') {
+    return new GML2(options);
+  }
+  if (responseType === 'application/vnd.ogc.gml/3.1.1') {
+    return new GML3(options);
+  }
+  return null;
+}
+
+/**
+ * @class
+ * @export
+ * @extends {AbstractFeatureProvider}
+ */
+class WMSFeatureProvider extends AbstractFeatureProvider {
+  static get className() { return 'vcs.vcm.util.featureProvider.WMSFeatureProvider'; }
+
+  /**
+   * @returns {WMSFeatureProviderOptions}
+   */
+  static getDefaultOptions() {
+    return {
+      ...AbstractFeatureProvider.getDefaultOptions(),
+      responseType: 'text/xml',
+      style: undefined,
+      formatOptions: undefined,
+      projection: undefined,
+      url: '',
+      tilingSchema: 'geographic',
+      version: '1.1.1',
+      maxLevel: 0,
+      minLevel: 0,
+      tileSize: [256, 256],
+      parameters: {},
+      extent: undefined,
+    };
+  }
+
+  /**
+   * @param {string} layerName
+   * @param {WMSFeatureProviderOptions} options
+   */
+  constructor(layerName, options) {
+    super(layerName, options);
+    const defaultOptions = WMSFeatureProvider.getDefaultOptions();
+
+    /**
+     * @type {import("@vcmap/core").Extent|null}
+     */
+    this.extent = null;
+    if (options.extent) {
+      if (options.extent instanceof Extent) {
+        this.extent = options.extent;
+      } else {
+        this.extent = new Extent(options.extent);
+      }
+    }
+    /** @type {WMSSourceOptions} */
+    this._wmsSourceOptions = {
+      url: options.url,
+      tilingSchema: options.tilingSchema || defaultOptions.tilingSchema,
+      maxLevel: parseInteger(options.maxLevel, defaultOptions.maxLevel),
+      minLevel: parseInteger(options.minLevel, defaultOptions.minLevel),
+      tileSize: options.tileSize || defaultOptions.tileSize,
+      parameters: options.parameters,
+      version: options.version || defaultOptions.version,
+    };
+    /**
+     * The WMS Source used to generate getFeatureInfo urls
+     * @type {import("ol/source/TileWMS").default}
+     * @api
+     */
+    this.wmsSource = getWMSSource(this._wmsSourceOptions);
+    /**
+     * The response type of the get feature info response, e.g. text/xml
+     * @type {string}
+     * @api
+     */
+    this.featureInfoResponseType = options.responseType || defaultOptions.responseType;
+    /**
+     * @type {Object}
+     * @private
+     */
+    this._formatOptions = options.formatOptions || defaultOptions.formatOptions;
+    /**
+     * The feature response format determined by the response type. Use formatOptions to configure the underlying ol.format.Feature
+     * @type {import("ol/format/Feature").default}
+     * @api
+     */
+    this.featureFormat = getFormat(this.featureInfoResponseType, options.formatOptions);
+    /**
+     * The feature response projection, if not present in the response format.
+     * @type {Projection}
+     * @api
+     */
+    this.projection = options.projection ? new Projection(options.projection) : undefined;
+  }
+
+  /**
+   * @param {import("axios").AxiosResponse<*>} response
+   * @param {import("ol/coordinate").Coordinate} coordinate
+   * @returns {Array<import("ol").Feature<import("ol/geom/Geometry").default>>}
+   */
+  featureResponseCallback(response, coordinate) {
+    const { data } = response;
+    /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
+    let features;
+
+    try {
+      features = /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
+      (this.featureFormat.readFeatures(data, {
+        dataProjection: this.projection ? this.projection.proj : undefined,
+        featureProjection: mercatorProjection.proj,
+      }));
+    } catch (ex) {
+      this.getLogger().warning('Features could not be read, please verify the featureInfoResponseType with the capabilities from the server');
+      return [];
+    }
+
+    if (Array.isArray(features)) {
+      features.forEach((feature) => {
+        const geometry = feature.getGeometry();
+        if (!geometry) {
+          feature.setGeometry(new Point(coordinate));
+        }
+      });
+      return features;
+    }
+
+    return [];
+  }
+
+  /**
+   * @inheritDoc
+   * @param {import("ol/coordinate").Coordinate} coordinate
+   * @param {number} resolution
+   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
+   */
+  async getFeaturesByCoordinate(coordinate, resolution) {
+    const projection = this.wmsSource.getProjection();
+    let coords = coordinate;
+    if (projection) {
+      const transform = getTransform(mercatorProjection.proj, projection);
+      coords = transform(coordinate.slice());
+    }
+
+    const metersPerUnit = 111194.87428468118;
+    const url = this.wmsSource.getFeatureInfoUrl(
+      coords,
+      resolution / metersPerUnit,
+      projection,
+      { INFO_FORMAT: this.featureInfoResponseType },
+    );
+
+    if (url) {
+      const response = await axios.get(url);
+      return this.featureResponseCallback(response, coordinate)
+        .map(f => this.getProviderFeature(f));
+    }
+    return [];
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {WMSFeatureProviderOptions}
+   */
+  getConfigObject() {
+    const config = /** @type {WMSFeatureProviderOptions} */ (super.getConfigObject());
+    const defaultOptions = WMSFeatureProvider.getDefaultOptions();
+    if (this.featureInfoResponseType !== defaultOptions.responseType) {
+      config.responseType = this.featureInfoResponseType;
+    }
+
+    if (this._formatOptions !== defaultOptions.formatOptions) {
+      config.formatOptions = { ...this._formatOptions };
+    }
+
+    if (this.projection !== defaultOptions.projection) {
+      config.projection = this.projection.getConfigObject();
+    }
+
+    config.url = this._wmsSourceOptions.url;
+    config.parameters = { ...this._wmsSourceOptions.parameters };
+
+    if (this._wmsSourceOptions.tilingSchema !== defaultOptions.tilingSchema) {
+      config.tilingSchema = this._wmsSourceOptions.tilingSchema;
+    }
+    if (this._wmsSourceOptions.maxLevel !== defaultOptions.maxLevel) {
+      config.maxLevel = this._wmsSourceOptions.maxLevel;
+    }
+    if (this._wmsSourceOptions.minLevel !== defaultOptions.minLevel) {
+      config.minLevel = this._wmsSourceOptions.minLevel;
+    }
+    if (this._wmsSourceOptions.version !== defaultOptions.version) {
+      config.version = this._wmsSourceOptions.version;
+    }
+    if (
+      this._wmsSourceOptions.tileSize[0] !== defaultOptions.tileSize[0] ||
+      this._wmsSourceOptions.tileSize[1] !== defaultOptions.tileSize[1]
+    ) {
+      config.tileSize = this._wmsSourceOptions.tileSize.slice();
+    }
+    if (this.extent) {
+      config.extent = this.extent.getConfigObject();
+    }
+
+    return config;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    this.wmsSource = undefined;
+    this.featureFormat = undefined;
+    this.projection = undefined;
+    this._formatOptions = undefined;
+    super.destroy();
+  }
+}
+
+export default WMSFeatureProvider;

package/src/vcs/vcm/util/featureconverter/circleToCesium.js

@@ -0,0 +1,215 @@
+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/vcs/vcm/util/featureconverter/convert.js

@@ -0,0 +1,83 @@
+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);
+    }
+  });
+}