@vcmap/core 5.0.0-rc.0

package/src/vcs/vcm/layer/cesium/rasterLayerCesium.js

@@ -0,0 +1,110 @@
+import { vcsLayerName } from '../layerSymbols.js';
+import LayerImplementation from '../layerImplementation.js';
+
+/**
+ * RasterLayer implementation for {@link Openlayers}
+ * @class
+ * @export
+ * @extends {LayerImplementation<import("@vcmap/core").CesiumMap>}}
+ * @implements {RasterLayerImplementation}
+ */
+class RasterLayerCesium extends LayerImplementation {
+  static get className() { return 'vcs.vcm.layer.cesium.RasterLayerCesium'; }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} map
+   * @param {RasterLayerImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /** @type {import("@vcmap/cesium").ImageryLayer|null} */
+    this.cesiumLayer = null;
+    /** @type {import("@vcmap/cesium").ImagerySplitDirection} */
+    this.splitDirection = options.splitDirection;
+    /** @type {number} */
+    this.minLevel = options.minLevel;
+    /** @type {number} */
+    this.maxLevel = options.maxLevel;
+    /** @type {string} */
+    this.tilingSchema = options.tilingSchema;
+    /** @type {import("@vcmap/core").Extent} */
+    this.extent = options.extent;
+    /** @type {number} */
+    this.opacity = options.opacity;
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  initialize() {
+    if (!this.initialized) {
+      this.cesiumLayer = this.getCesiumLayer();
+      this.cesiumLayer[vcsLayerName] = this.name;
+      this.cesiumLayer.show = false;
+      this.map.addImageryLayer(this.cesiumLayer);
+    }
+    return super.initialize();
+  }
+
+  /**
+   * @param {import("@vcmap/cesium").ImagerySplitDirection} splitDirection
+   */
+  updateSplitDirection(splitDirection) {
+    this.splitDirection = splitDirection;
+    if (this.initialized) {
+      this.cesiumLayer.splitDirection = splitDirection;
+    }
+  }
+
+  // eslint-disable-next-line jsdoc/require-returns-check
+  /**
+   * @returns {import("@vcmap/cesium").ImageryLayer}
+   */
+  // eslint-disable-next-line class-methods-use-this
+  getCesiumLayer() { throw new Error('implementation error'); }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async activate() {
+    await super.activate();
+    if (this.active) {
+      this.cesiumLayer.show = true;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  deactivate() {
+    super.deactivate();
+    if (this.cesiumLayer) {
+      this.cesiumLayer.show = false;
+    }
+  }
+
+  /**
+   * @param {number} opacity
+   */
+  updateOpacity(opacity) {
+    this.opacity = opacity;
+    if (this.initialized && this.cesiumLayer) {
+      this.cesiumLayer.alpha = opacity;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    if (this.cesiumLayer) {
+      this.map.removeImageryLayer(this.cesiumLayer);
+    }
+    this.cesiumLayer = null;
+    super.destroy();
+  }
+}
+
+export default RasterLayerCesium;

package/src/vcs/vcm/layer/cesium/singleImageCesium.js

@@ -0,0 +1,49 @@
+import { Rectangle, SingleTileImageryProvider, ImageryLayer } from '@vcmap/cesium';
+import RasterLayerCesium from './rasterLayerCesium.js';
+import { wgs84Projection } from '../../util/projection.js';
+
+/**
+ * represents a specific Cesium SingleTileImagery Layer class.
+ * @class
+ * @export
+ * @extends {RasterLayerCesium}
+ */
+class SingleImageCesium extends RasterLayerCesium {
+  static get className() { return 'vcs.vcm.layer.cesium.singleImageLayer'; }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} map
+   * @param {SingleImageImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /** @type {string} */
+    this.credit = options.credit;
+  }
+
+  /**
+   * @returns {import("@vcmap/cesium").ImageryLayer}
+   */
+  getCesiumLayer() {
+    const options = {
+      url: this.url,
+      credit: this.credit,
+    };
+
+    const extent = this.extent.getCoordinatesInProjection(wgs84Projection);
+    if (extent) {
+      options.rectangle = Rectangle.fromDegrees(extent[0], extent[1], extent[2], extent[3]);
+    }
+
+    const imageryProvider = new SingleTileImageryProvider(options);
+    const layerOptions = {
+      rectangle: options.rectangle,
+      alpha: this.opacity,
+      defaultAlpha: 1.0,
+      splitDirection: this.splitDirection,
+    };
+    return new ImageryLayer(imageryProvider, layerOptions);
+  }
+}
+
+export default SingleImageCesium;

package/src/vcs/vcm/layer/cesium/terrainCesium.js

@@ -0,0 +1,80 @@
+import LayerImplementation from '../layerImplementation.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import { getTerrainProviderForUrl } from '../terrainHelpers.js';
+
+
+/**
+ * Terrain implementation for {@link CesiumMap}
+ * @class
+ * @export
+ * @extends {LayerImplementation<import("@vcmap/core").CesiumMap>}}
+ */
+class TerrainCesium extends LayerImplementation {
+  static get className() { return 'vcs.vcm.layer.cesium.TerrainCesium'; }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} map
+   * @param {TerrainImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /**
+     * @type {boolean}
+     * @api
+     */
+    this.requestVertexNormals = options.requestVertexNormals;
+
+    /**
+     * @type {boolean}
+     * @api
+     */
+    this.requestWaterMask = options.requestWaterMask;
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  initialize() {
+    if (!this.initialized) {
+      this.terrainProvider = getTerrainProviderForUrl({
+        url: this.url,
+        requestVertexNormals: this.requestVertexNormals,
+        requestWaterMask: this.requestWaterMask,
+      });
+      this.terrainProvider[vcsLayerName] = this.name;
+    }
+    return super.initialize();
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async activate() {
+    await super.activate();
+    if (this.active) {
+      this.map.setTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  deactivate() {
+    super.deactivate();
+    if (this.terrainProvider) {
+      this.map.unsetTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    this.terrainProvider = null;
+    super.destroy();
+  }
+}
+
+export default TerrainCesium;

package/src/vcs/vcm/layer/cesium/tmsCesium.js

@@ -0,0 +1,54 @@
+import { Rectangle, GeographicTilingScheme, TileMapServiceImageryProvider, ImageryLayer as CesiumImageryLayer } from '@vcmap/cesium';
+import RasterLayerCesium from './rasterLayerCesium.js';
+import { wgs84Projection } from '../../util/projection.js';
+import { TilingScheme } from '../rasterLayer.js';
+
+/**
+ * TMS implementation for {@link CesiumMap}.
+ * @class
+ * @export
+ * @extends {RasterLayerCesium}
+ */
+class TMSCesium extends RasterLayerCesium {
+  static get className() { return 'vcs.vcm.layer.cesium.TMSCesium'; }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} map
+   * @param {TMSImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+    /** @type {string} */
+    this.format = options.format;
+  }
+
+  /**
+   * @returns {import("@vcmap/cesium").ImageryLayer}
+   */
+  getCesiumLayer() {
+    const options = {
+      url: this.url,
+      fileExtension: this.format,
+      maximumLevel: this.maxLevel,
+      minimumLevel: this.minLevel,
+      show: false,
+    };
+
+    if (this.extent && this.extent.isValid()) {
+      const extent = this.extent.getCoordinatesInProjection(wgs84Projection);
+      options.rectangle = Rectangle.fromDegrees(extent[0], extent[1], extent[2], extent[3]);
+    }
+    if (this.tilingSchema === TilingScheme.GEOGRAPHIC) {
+      options.tilingScheme = new GeographicTilingScheme();
+    }
+    const imageryProvider = new TileMapServiceImageryProvider(options);
+    const layerOptions = {
+      alpha: this.opacity,
+      splitDirection: this.splitDirection,
+    };
+
+    return new CesiumImageryLayer(imageryProvider, layerOptions);
+  }
+}
+
+export default TMSCesium;

package/src/vcs/vcm/layer/cesium/vectorCesium.js

@@ -0,0 +1,255 @@
+import { unByKey } from 'ol/Observable.js';
+import { PrimitiveCollection } from '@vcmap/cesium';
+
+import convert from '../../util/featureconverter/convert.js';
+import VectorContext from './vectorContext.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import LayerImplementation from '../layerImplementation.js';
+import { getGlobalHider } from '../globalHider.js';
+import { synchronizeFeatureVisibilityWithSource } from '../vectorHelpers.js';
+
+/**
+ * represents a specific vector layer for cesium.
+ * @class
+ * @export
+ * @extends {LayerImplementation<import("@vcmap/core").CesiumMap>}}
+ * @implements {FeatureLayerImplementation}
+ */
+class VectorCesium extends LayerImplementation {
+  static get className() { return 'vcs.vcm.layer.cesium.VectorCesium'; }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} map
+   * @param {VectorImplementationOptions} options
+   */
+  constructor(map, options) {
+    super(map, options);
+
+    /** @type {import("@vcmap/core").VectorProperties} */
+    this.vectorProperties = options.vectorProperties;
+    /** @type {import("ol/source").Vector<import("ol/geom/Geometry").default>} */
+    this.source = options.source;
+    /** @type {import("@vcmap/core").StyleItem} */
+    this.style = options.style;
+    /** @type {import("@vcmap/core").FeatureVisibility} */
+    this.featureVisibility = options.featureVisibility;
+    /**
+     * @type {Array<Function>}
+     * @private
+     */
+    this._featureVisibilityListeners = [];
+    /**
+     * @type {Function}
+     * @private
+     */
+    this._removeVectorPropertiesChangeHandler = () => {};
+
+    /**
+     * @type {import("@vcmap/cesium").PrimitiveCollection|import("@vcmap/cesium").CustomDataSource}
+     * @protected
+     */
+    this._rootCollection = new PrimitiveCollection();
+    this._rootCollection[vcsLayerName] = options.name;
+
+    /**
+     * @type {Array<import("ol/events").EventsKey|Array<import("ol/events").EventsKey>>}
+     * @private
+     */
+    this._olListeners = [];
+    /**
+     * A set of ol.Features to add once the map is back to cesium
+     * @type {Set<import("ol").Feature<import("ol/geom/Geometry").default>>}
+     * @private
+     */
+    this._featureToAdd = new Set();
+    /**
+     * @type {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext|null}
+     * @protected
+     */
+    this._context = null;
+    /**
+     * @type {import("@vcmap/cesium").Scene|null}
+     * @private
+     */
+    this._scene = null;
+    this.globalHider = getGlobalHider();
+  }
+
+  /**
+   * @private
+   */
+  _addListeners() {
+    this._olListeners.push(this.source
+      .on('addfeature', (event) => {
+        this._addFeature(/** @type {import("ol/source/Vector").VectorSourceEvent} */(event).feature);
+      }));
+
+    this._olListeners.push(this.source
+      .on('removefeature', (event) => {
+        this._removeFeature(/** @type {import("ol/source/Vector").VectorSourceEvent} */(event).feature);
+      }));
+
+    this._olListeners.push(this.source
+      .on('changefeature', (event) => {
+        this._featureChanged(/** @type {import("ol/source/Vector").VectorSourceEvent} */(event).feature);
+      }));
+
+    this._removeVectorPropertiesChangeHandler =
+      this.vectorProperties.propertyChanged.addEventListener(this.refresh.bind(this));
+  }
+
+  /**
+   * @param {import("@vcmap/core").CesiumMap} cesiumMap
+   * @returns {Promise<void>}
+   * @protected
+   */
+  async _setupContext(cesiumMap) {
+    const rootCollection = /** @type {import("@vcmap/cesium").PrimitiveCollection} */ (this._rootCollection);
+    this._context = new VectorContext(this._scene, rootCollection);
+    cesiumMap.addPrimitiveCollection(rootCollection);
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!this.initialized) {
+      this._scene = this.map.getScene();
+      await this._setupContext(this.map);
+      this._addListeners();
+      this._addFeatures(this.source.getFeatures());
+    }
+    await super.initialize();
+  }
+
+  /**
+   * @param {Array<import("ol").Feature<import("ol/geom/Geometry").default>>} features
+   * @private
+   */
+  _addFeatures(features) {
+    // TODO we should make this non-blocking to better handle larger data sets check in RIWA Impl
+    features.forEach((f) => { this._addFeature(f); });
+  }
+
+  /**
+   * converts a feature and adds the associated primitives to the collection of primitives
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @private
+   */
+  _addFeature(feature) {
+    if (this.active) { // XXX cluster check here? or on init?
+      convert(feature, this.style.style, this.vectorProperties, this._context, this._scene);
+    } else {
+      this._featureToAdd.add(feature);
+    }
+  }
+
+  /**
+   * Forces a complete re-render of all features.
+   * @api
+   */
+  refresh() {
+    this._context.clear();
+    this._addFeatures(this.source.getFeatures());
+  }
+
+  /**
+   * removes the primitive of the specified feature
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @private
+   */
+  _removeFeature(feature) {
+    this._context.removeFeature(feature);
+    this._featureToAdd.delete(feature);
+  }
+
+  /**
+   * called when a features property have changed
+   * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
+   * @private
+   */
+  _featureChanged(feature) {
+    const cache = this._context.createFeatureCache(feature);
+    this._featureToAdd.delete(feature);
+    this._addFeature(feature);
+    this._context.clearFeatureCache(cache);
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<void>}
+   */
+  async activate() {
+    if (!this.active) {
+      await super.activate();
+      if (this.active) {
+        this._addFeatures([...this._featureToAdd]);
+        this._featureToAdd.clear();
+        this._rootCollection.show = true;
+        if (this._featureVisibilityListeners.length === 0) {
+          this._featureVisibilityListeners =
+            synchronizeFeatureVisibilityWithSource(this.featureVisibility, this.source, this.globalHider);
+        }
+      }
+    }
+  }
+
+  /**
+   * @inheritDoc
+   */
+  deactivate() {
+    super.deactivate();
+    this._rootCollection.show = false;
+    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners = [];
+  }
+
+  /**
+   * @param {import("@vcmap/core").StyleItem} style
+   * @param {boolean=} silent
+   */
+  updateStyle(style, silent) {
+    this.style = style;
+    if (this.initialized && !silent) {
+      const features = this.source.getFeatures().filter(f => !f.getStyle());
+      features.forEach((f) => {
+        this._featureChanged(f);
+      });
+    }
+  }
+
+  /**
+   * @protected
+   */
+  _destroyCollection() {
+    this.map.removePrimitiveCollection(/** @type {undefined} */ (this._rootCollection)); // cast to undefined do to missing inheritance
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    if (this.initialized) {
+      this._context.clear();
+      this._destroyCollection();
+    }
+    this._context = null;
+    this._scene = null;
+    this._removeVectorPropertiesChangeHandler();
+    this._olListeners.forEach((listener) => { unByKey(listener); });
+    this._olListeners = [];
+    this._featureToAdd.clear();
+    this._featureVisibilityListeners.forEach((cb) => { cb(); });
+    this._featureVisibilityListeners = [];
+    this.source = null;
+    this.vectorProperties = null;
+    this.featureVisibility = null;
+    this.style = null;
+    this.globalHider = null;
+    this._rootCollection = null;
+    super.destroy();
+  }
+}
+
+export default VectorCesium;