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

package/src/{vcs/vcm/layer/singleImage.js → layer/singleImageLayer.js}

@@ -1,11 +1,12 @@
 import { check } from '@vcsuite/check';
 import RasterLayer from './rasterLayer.js';
-import SingleImageCesium from './cesium/singleImageCesium.js';
-import SingleImageOpenlayers from './openlayers/singleImageOpenlayers.js';
-import CesiumMap from '../maps/cesium.js';
-import Openlayers from '../maps/openlayers.js';
+import SingleImageCesiumImpl from './cesium/singleImageCesiumImpl.js';
+import SingleImageOpenlayersImpl from './openlayers/singleImageOpenlayersImpl.js';
+import CesiumMap from '../map/cesiumMap.js';
+import OpenlayersMap from '../map/openlayersMap.js';
 import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import { layerClassRegistry } from '../classRegistry.js';
+import { wgs84Projection } from '../util/projection.js';
 
 /**
  * @typedef {RasterLayerOptions} SingleImageOptions
@@ -19,14 +20,15 @@ import { VcsClassRegistry } from '../classRegistry.js';
  */
 
 /**
- * Image layer for Cesium and Openlayers
+ * Image layer for Cesium and OpenlayersMap
  * @class
- * @export
  * @extends {RasterLayer}
  * @api stable
  */
-class SingleImage extends RasterLayer {
-  static get className() { return 'vcs.vcm.layer.SingleImage'; }
+class SingleImageLayer extends RasterLayer {
+  static get className() {
+    return 'SingleImageLayer';
+  }
 
   /**
    * @returns {SingleImageOptions}
@@ -43,22 +45,21 @@ class SingleImage extends RasterLayer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = SingleImage.getDefaultOptions();
+    const defaultOptions = SingleImageLayer.getDefaultOptions();
     /** @type {string} */
     this.credit = options.credit || defaultOptions.credit;
 
     if (!this.extent.isValid()) {
-      this.getLogger().warning(`layer ${this.name} was constructed with an invalid extent, defaulting to global extent`);
+      this.getLogger().warning(
+        `layer ${this.name} was constructed with an invalid extent, defaulting to global extent`,
+      );
       this.extent = new Extent({
-        epsg: 'EPSG:4326',
+        projection: wgs84Projection.toJSON(),
         coordinates: [-180, -90, 180, 90],
       });
     }
 
-    this._supportedMaps = [
-      CesiumMap.className,
-      Openlayers.className,
-    ];
+    this._supportedMaps = [CesiumMap.className, OpenlayersMap.className];
   }
 
   /**
@@ -73,13 +74,15 @@ class SingleImage extends RasterLayer {
 
   /**
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<SingleImageOpenlayers|SingleImageCesium>}
+   * @returns {Array<SingleImageOpenlayersImpl|SingleImageCesiumImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new SingleImageCesium(map, this.getImplementationOptions())];
-    } else if (map instanceof Openlayers) {
-      return [new SingleImageOpenlayers(map, this.getImplementationOptions())];
+      return [new SingleImageCesiumImpl(map, this.getImplementationOptions())];
+    } else if (map instanceof OpenlayersMap) {
+      return [
+        new SingleImageOpenlayersImpl(map, this.getImplementationOptions()),
+      ];
     }
     return [];
   }
@@ -115,5 +118,5 @@ class SingleImage extends RasterLayer {
   }
 }
 
-VcsClassRegistry.registerClass(SingleImage.className, SingleImage);
-export default SingleImage;
+layerClassRegistry.registerClass(SingleImageLayer.className, SingleImageLayer);
+export default SingleImageLayer;

package/src/layer/terrainHelpers.js

@@ -0,0 +1,95 @@
+import {
+  CesiumTerrainProvider,
+  Cartographic,
+  Cartesian2,
+  sampleTerrainMostDetailed,
+} from '@vcmap-cesium/engine';
+import { getTransform } from 'ol/proj.js';
+import { wgs84Projection } from '../util/projection.js';
+
+/**
+ * @typedef {Object} TerrainProviderOptions
+ * @property {boolean|undefined} requestVertexNormals
+ * @property {boolean|undefined} requestWaterMask
+ * @api
+ */
+
+/**
+ * @type {Object<string, import("@vcmap-cesium/engine").CesiumTerrainProvider>}
+ */
+const terrainProviders = {};
+
+/**
+ * @param {string} url
+ * @param {TerrainProviderOptions} options
+ * @returns {Promise<import("@vcmap-cesium/engine").CesiumTerrainProvider>}
+ */
+export async function getTerrainProviderForUrl(url, options) {
+  if (!terrainProviders[url]) {
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    return terrainProviders[url];
+  }
+  let terrainProvider = terrainProviders[url];
+  if (
+    (options.requestVertexNormals !== undefined &&
+      terrainProvider.requestVertexNormals !== options.requestVertexNormals) ||
+    (options.requestWaterMask !== undefined &&
+      terrainProvider.requestWaterMask !== options.requestWaterMask)
+  ) {
+    terrainProviders[url] = await CesiumTerrainProvider.fromUrl(url, options);
+    terrainProvider = terrainProviders[url];
+  }
+  return terrainProvider;
+}
+
+/**
+ * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
+ * @param {import("@vcmap-cesium/engine").CesiumTerrainProvider} terrainProvider
+ * @param {Array<import("ol/coordinate").Coordinate>} coordinates
+ * @param {import("@vcmap/core").Projection=} optSourceProjection - if input is not WGS84
+ * @param {Array<import("ol/coordinate").Coordinate>=} result
+ * @returns {Promise<Array<import("ol/coordinate").Coordinate>>}
+ */
+export function getHeightFromTerrainProvider(
+  terrainProvider,
+  coordinates,
+  optSourceProjection,
+  result,
+) {
+  const sourceTransformer = optSourceProjection
+    ? getTransform(optSourceProjection.proj, wgs84Projection.proj)
+    : null;
+
+  const positions = coordinates.map((coord) => {
+    const wgs84 = sourceTransformer
+      ? sourceTransformer(coord, coord.slice(), coord.length)
+      : coord;
+    return Cartographic.fromDegrees(wgs84[0], wgs84[1]);
+  });
+
+  const outArray = result || coordinates.map((c) => c.slice());
+  return sampleTerrainMostDetailed(terrainProvider, positions).then(
+    (updatedPositions) => {
+      updatedPositions.forEach((position, index) => {
+        outArray[index][2] = position.height || 0;
+      });
+      return outArray;
+    },
+  );
+}
+
+/**
+ * checks, whether a terrain tile is available at given position or not
+ * @param {import("@vcmap-cesium/engine").CesiumTerrainProvider} terrainProvider
+ * @param {number} level
+ * @param {import("@vcmap-cesium/engine").Cartographic} position
+ * @returns {boolean}
+ */
+export function isTerrainTileAvailable(terrainProvider, level, position) {
+  const tileXY = terrainProvider.tilingScheme.positionToTileXY(
+    position,
+    level,
+    new Cartesian2(),
+  );
+  return terrainProvider.getTileDataAvailable(tileXY.x, tileXY.y, level);
+}

package/src/{vcs/vcm/layer/terrain.js → layer/terrainLayer.js}

@@ -1,9 +1,12 @@
 import { parseBoolean } from '@vcsuite/parsers';
 import Layer from './layer.js';
-import { getHeightFromTerrainProvider, getTerrainProviderForUrl } from './terrainHelpers.js';
-import CesiumMap from '../maps/cesium.js';
-import TerrainCesium from './cesium/terrainCesium.js';
-import { VcsClassRegistry } from '../classRegistry.js';
+import {
+  getHeightFromTerrainProvider,
+  getTerrainProviderForUrl,
+} from './terrainHelpers.js';
+import CesiumMap from '../map/cesiumMap.js';
+import TerrainCesiumImpl from './cesium/terrainCesiumImpl.js';
+import { layerClassRegistry } from '../classRegistry.js';
 
 /**
  * @typedef {LayerOptions} TerrainOptions
@@ -21,12 +24,13 @@ import { VcsClassRegistry } from '../classRegistry.js';
 /**
  * represents a terrain layer.
  * @class
- * @export
  * @extends {Layer}
  * @api stable
  */
-class Terrain extends Layer {
-  static get className() { return 'vcs.vcm.layer.Terrain'; }
+class TerrainLayer extends Layer {
+  static get className() {
+    return 'TerrainLayer';
+  }
 
   /**
    * @returns {TerrainOptions}
@@ -44,23 +48,27 @@ class Terrain extends Layer {
    */
   constructor(options) {
     super(options);
-    const defaultOptions = Terrain.getDefaultOptions();
+    const defaultOptions = TerrainLayer.getDefaultOptions();
 
-    this._supportedMaps = [
-      CesiumMap.className,
-    ];
+    this._supportedMaps = [CesiumMap.className];
 
     /**
      * @type {boolean}
      * @api
      */
-    this.requestVertexNormals = parseBoolean(options.requestVertexNormals, defaultOptions.requestVertexNormals);
+    this.requestVertexNormals = parseBoolean(
+      options.requestVertexNormals,
+      defaultOptions.requestVertexNormals,
+    );
 
     /**
      * @type {boolean}
      * @api
      */
-    this.requestWaterMask = parseBoolean(options.requestWaterMask, defaultOptions.requestWaterMask);
+    this.requestWaterMask = parseBoolean(
+      options.requestWaterMask,
+      defaultOptions.requestWaterMask,
+    );
   }
 
   /**
@@ -77,11 +85,11 @@ class Terrain extends Layer {
   /**
    * @inheritDoc
    * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<TerrainCesium>}
+   * @returns {Array<TerrainCesiumImpl>}
    */
   createImplementationsForMap(map) {
     if (map instanceof CesiumMap) {
-      return [new TerrainCesium(map, this.getImplementationOptions())];
+      return [new TerrainCesiumImpl(map, this.getImplementationOptions())];
     }
     return [];
   }
@@ -92,9 +100,8 @@ class Terrain extends Layer {
    * @returns {Promise<Array<import("ol/coordinate").Coordinate>>}
    * @api stable
    */
-  getHeightForWGS84Coordinates(coords) {
-    const terrainProvider = getTerrainProviderForUrl({
-      url: this.url,
+  async getHeightForWGS84Coordinates(coords) {
+    const terrainProvider = await getTerrainProviderForUrl(this.url, {
       requestVertexNormals: this.requestVertexNormals,
       requestWaterMask: this.requestWaterMask,
     });
@@ -106,7 +113,7 @@ class Terrain extends Layer {
    */
   toJSON() {
     const config = /** @type {TerrainOptions} */ (super.toJSON());
-    const defaultOptions = Terrain.getDefaultOptions();
+    const defaultOptions = TerrainLayer.getDefaultOptions();
 
     if (this.requestVertexNormals !== defaultOptions.requestVertexNormals) {
       config.requestVertexNormals = this.requestVertexNormals;
@@ -118,5 +125,5 @@ class Terrain extends Layer {
   }
 }
 
-VcsClassRegistry.registerClass(Terrain.className, Terrain);
-export default Terrain;
+layerClassRegistry.registerClass(TerrainLayer.className, TerrainLayer);
+export default TerrainLayer;

package/src/{vcs/vcm/layer → layer}/tileLoadedHelper.js

@@ -1,7 +1,7 @@
-import CesiumTilesetCesium from './cesium/cesiumTilesetCesium.js';
+import CesiumTilesetCesiumImpl from './cesium/cesiumTilesetCesiumImpl.js';
 
 /**
- * @param {CesiumTilesetCesium} impl
+ * @param {CesiumTilesetCesiumImpl} impl
  * @param {number=} timeout
  * @returns {Promise<void>}
  */
@@ -26,22 +26,27 @@ function waitForImplTilesLoaded(impl, timeout) {
 }
 
 /**
- * @param {import("@vcmap/core").CesiumTileset|import("@vcmap/core").FeatureStore} layer
+ * @param {import("@vcmap/core").CesiumTilesetLayer|import("@vcmap/core").FeatureStoreLayer} layer
  * @param {number=} timeout
  * @returns {Promise<void>}
  */
 export async function tiledLayerLoaded(layer, timeout) {
-  const impls = /** @type {Array<CesiumTilesetCesium>} */
-    (layer.getImplementations().filter(i => i instanceof CesiumTilesetCesium));
-  if (!layer.active || impls.every(i => i.cesium3DTileset.tilesLoaded)) {
+  const impls =
+    /** @type {Array<CesiumTilesetCesiumImpl>} */
+    (
+      layer
+        .getImplementations()
+        .filter((i) => i instanceof CesiumTilesetCesiumImpl)
+    );
+  if (!layer.active || impls.every((i) => i.cesium3DTileset.tilesLoaded)) {
     return;
   }
 
-  await Promise.all(impls.map(i => waitForImplTilesLoaded(i, timeout)));
+  await Promise.all(impls.map((i) => waitForImplTilesLoaded(i, timeout)));
 }
 
 /**
- * @param {import("@vcmap/cesium").Globe} globe
+ * @param {import("@vcmap-cesium/engine").Globe} globe
  * @param {number=} timeout
  * @returns {Promise<void>}
  */

package/src/{vcs/vcm/layer → layer}/tileProvider/mvtTileProvider.js

@@ -1,9 +1,10 @@
-import axios from 'axios';
 import MVT from 'ol/format/MVT.js';
 import Feature from 'ol/Feature.js';
 import { getCenter } from 'ol/extent.js';
 import TileProvider, { rectangleToExtent } from './tileProvider.js';
 import { getURL } from './urlTemplateTileProvider.js';
+import { requestArrayBuffer } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
 
 /**
  * @typedef {TileProviderOptions} MVTTileProviderOptions
@@ -17,7 +18,6 @@ import { getURL } from './urlTemplateTileProvider.js';
  *
  * @class
  * @extends {TileProvider}
- * @export
  * @api
  */
 class MVTTileProvider extends TileProvider {
@@ -25,7 +25,9 @@ class MVTTileProvider extends TileProvider {
    * @readonly
    * @returns {string}
    */
-  static get className() { return 'vcs.vcm.layer.tileProvider.MVTTileProvider'; }
+  static get className() {
+    return 'MVTTileProvider';
+  }
 
   /**
    * @returns {MVTTileProviderOptions}
@@ -62,6 +64,26 @@ class MVTTileProvider extends TileProvider {
     this._MVTFormat = new MVT({ featureClass: Feature });
   }
 
+  /**
+   * @type {string}
+   */
+  get locale() {
+    return super.locale;
+  }
+
+  /**
+   * sets the locale and clears the Cache if the URL is a locale aware Object.
+   * @param {string} value
+   */
+  set locale(value) {
+    if (this.locale !== value) {
+      super.locale = value;
+      if (this.url.includes('{locale}')) {
+        this.clearCache();
+      }
+    }
+  }
+
   /**
    * @inheritDoc
    * @param {number} x
@@ -71,13 +93,14 @@ class MVTTileProvider extends TileProvider {
    */
   async loader(x, y, z) {
     const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
-    const url = getURL(this.url, x, y, z, rectangle);
+    const url = getURL(this.url, x, y, z, rectangle, this.locale);
     const extent = rectangleToExtent(rectangle);
     const center = getCenter(extent);
-    const response = await axios.get(url, { responseType: 'arraybuffer' });
-    const features = /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
-      (this._MVTFormat.readFeatures(response.data));
-    const sx = ((extent[2] - extent[0]) / 4096);
+    const data = await requestArrayBuffer(url);
+    const features =
+      /** @type {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} */
+      (this._MVTFormat.readFeatures(data));
+    const sx = (extent[2] - extent[0]) / 4096;
     const sy = -((extent[3] - extent[1]) / 4096);
     features.forEach((feature) => {
       const idToUse = feature.get(this.idProperty);
@@ -99,6 +122,26 @@ class MVTTileProvider extends TileProvider {
     });
     return features;
   }
+
+  /**
+   * @returns {MVTTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {MVTTileProviderOptions} */ (super.toJSON());
+
+    if (this.url) {
+      config.url = this.url;
+    }
+
+    if (this.idProperty) {
+      config.idProperty = this.idProperty;
+    }
+    return config;
+  }
 }
 
 export default MVTTileProvider;
+tileProviderClassRegistry.registerClass(
+  MVTTileProvider.className,
+  MVTTileProvider,
+);

package/src/layer/tileProvider/staticGeojsonTileProvider.js

@@ -0,0 +1,87 @@
+import { parseGeoJSON } from '../geojsonHelpers.js';
+import TileProvider from './tileProvider.js';
+import { requestJson } from '../../util/fetch.js';
+import { tileProviderClassRegistry } from '../../classRegistry.js';
+
+/**
+ * @typedef {TileProviderOptions} StaticGeoJSONTileProviderOptions
+ * @property {string} url - url to the geojson
+ * @api
+ */
+
+/**
+ * Loads the provided geojson url and tiles the content in memory, data is only requested once
+ *
+ * @class
+ * @extends {TileProvider}
+ * @api
+ */
+class StaticGeoJSONTileProvider extends TileProvider {
+  /**
+   * @readonly
+   * @returns {string}
+   */
+  static get className() {
+    return 'StaticGeoJSONTileProvider';
+  }
+
+  /**
+   * @returns {StaticGeoJSONTileProviderOptions}
+   */
+  static getDefaultOptions() {
+    return {
+      ...TileProvider.getDefaultOptions(),
+      url: undefined,
+      baseLevels: [0],
+    };
+  }
+
+  /**
+   * @param {StaticGeoJSONTileProviderOptions} options
+   */
+  constructor(options) {
+    const defaultOptions = StaticGeoJSONTileProvider.getDefaultOptions();
+    options.baseLevels = defaultOptions.baseLevels;
+    super(options);
+
+    /**
+     * @type {string}
+     */
+    this.url = options.url || defaultOptions.url;
+  }
+
+  /**
+   * @inheritDoc
+   * @param {number} x
+   * @param {number} y
+   * @param {number} z
+   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
+   */
+  // eslint-disable-next-line no-unused-vars
+  async loader(x, y, z) {
+    const data = await requestJson(this.url);
+    const { features } = parseGeoJSON(data, { dynamicStyle: true });
+    return features;
+  }
+
+  /**
+   * @returns {StaticGeoJSONTileProviderOptions}
+   */
+  toJSON() {
+    const config = /** @type {StaticGeoJSONTileProviderOptions} */ (
+      super.toJSON()
+    );
+    delete config.baseLevels;
+
+    if (this.url) {
+      config.url = this.url;
+    }
+    return config;
+  }
+}
+
+export default StaticGeoJSONTileProvider;
+tileProviderClassRegistry.registerClass(
+  StaticGeoJSONTileProvider.className,
+  StaticGeoJSONTileProvider,
+);