@vcmap/core 5.0.0-rc.9 → 5.0.1

package/src/layer/cesium/openStreetMapCesiumImpl.ts

@@ -0,0 +1,28 @@
+import {
+  OpenStreetMapImageryProvider,
+  ImageryLayer as CesiumImageryLayer,
+} from '@vcmap-cesium/engine';
+import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
+
+/**
+ * represents a specific OpenStreetMapLayer layer for cesium.
+ */
+class OpenStreetMapCesiumImpl extends RasterLayerCesiumImpl {
+  static get className(): string {
+    return 'OpenStreetMapCesiumImpl';
+  }
+
+  getCesiumLayer(): Promise<CesiumImageryLayer> {
+    return Promise.resolve(
+      new CesiumImageryLayer(
+        new OpenStreetMapImageryProvider({ maximumLevel: this.maxLevel }),
+        {
+          alpha: this.opacity,
+          splitDirection: this.splitDirection,
+        },
+      ),
+    );
+  }
+}
+
+export default OpenStreetMapCesiumImpl;

package/src/layer/cesium/rasterLayerCesiumImpl.ts

@@ -0,0 +1,100 @@
+import type { ImageryLayer, SplitDirection } from '@vcmap-cesium/engine';
+import { vcsLayerName } from '../layerSymbols.js';
+import LayerImplementation from '../layerImplementation.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+import type {
+  RasterLayerImplementation,
+  RasterLayerImplementationOptions,
+  TilingScheme,
+} from '../rasterLayer.js';
+import type Extent from '../../util/extent.js';
+
+class RasterLayerCesiumImpl
+  extends LayerImplementation<CesiumMap>
+  implements RasterLayerImplementation
+{
+  static get className(): string {
+    return 'RasterLayerCesiumImpl';
+  }
+
+  cesiumLayer: ImageryLayer | null = null;
+
+  splitDirection: SplitDirection;
+
+  minLevel: number;
+
+  maxLevel: number;
+
+  extent: Extent | undefined;
+
+  opacity: number;
+
+  tilingSchema: TilingScheme;
+
+  constructor(map: CesiumMap, options: RasterLayerImplementationOptions) {
+    super(map, options);
+    this.splitDirection = options.splitDirection;
+    this.minLevel = options.minLevel;
+    this.maxLevel = options.maxLevel;
+    this.extent = options.extent;
+    this.opacity = options.opacity;
+    this.tilingSchema = options.tilingSchema;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      this.cesiumLayer = await this.getCesiumLayer();
+      if (this.isDestroyed) {
+        this.cesiumLayer.destroy();
+        return Promise.resolve();
+      }
+      this.cesiumLayer[vcsLayerName] = this.name;
+      this.cesiumLayer.show = false;
+      this.map.addImageryLayer(this.cesiumLayer);
+    }
+    return super.initialize();
+  }
+
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    if (this.initialized && this.cesiumLayer) {
+      this.cesiumLayer.splitDirection = splitDirection;
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getCesiumLayer(): Promise<ImageryLayer> {
+    throw new Error('implementation error');
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active && this.cesiumLayer) {
+      this.cesiumLayer.show = true;
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    if (this.cesiumLayer) {
+      this.cesiumLayer.show = false;
+    }
+  }
+
+  updateOpacity(opacity: number): void {
+    this.opacity = opacity;
+    if (this.initialized && this.cesiumLayer) {
+      this.cesiumLayer.alpha = opacity;
+    }
+  }
+
+  destroy(): void {
+    if (this.cesiumLayer) {
+      this.map.removeImageryLayer(this.cesiumLayer);
+    }
+    this.cesiumLayer = null;
+    super.destroy();
+  }
+}
+
+export default RasterLayerCesiumImpl;

package/src/layer/cesium/singleImageCesiumImpl.ts

@@ -0,0 +1,55 @@
+import {
+  Rectangle,
+  SingleTileImageryProvider,
+  ImageryLayer,
+} from '@vcmap-cesium/engine';
+import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
+import { wgs84Projection } from '../../util/projection.js';
+import type { SingleImageImplementationOptions } from '../singleImageLayer.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+
+/**
+ * represents a specific Cesium SingleTileImagery Layer class.
+ */
+class SingleImageCesiumImpl extends RasterLayerCesiumImpl {
+  static get className(): string {
+    return 'SingleImageCesiumImpl';
+  }
+
+  credit: string | undefined;
+
+  constructor(map: CesiumMap, options: SingleImageImplementationOptions) {
+    super(map, options);
+    this.credit = options.credit;
+  }
+
+  async getCesiumLayer(): Promise<ImageryLayer> {
+    const options: SingleTileImageryProvider.fromUrlOptions = {
+      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 = await SingleTileImageryProvider.fromUrl(
+      this.url!,
+      options,
+    );
+    const layerOptions = {
+      rectangle: options.rectangle,
+      alpha: this.opacity,
+      defaultAlpha: 1.0,
+      splitDirection: this.splitDirection,
+    };
+    return new ImageryLayer(imageryProvider, layerOptions);
+  }
+}
+
+export default SingleImageCesiumImpl;

package/src/layer/cesium/terrainCesiumImpl.ts

@@ -0,0 +1,63 @@
+import type { CesiumTerrainProvider } from '@vcmap-cesium/engine';
+import LayerImplementation from '../layerImplementation.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import { getTerrainProviderForUrl } from '../terrainHelpers.js';
+import CesiumMap from '../../map/cesiumMap.js';
+import type { TerrainImplementationOptions } from '../terrainLayer.js';
+
+/**
+ * TerrainLayer implementation for {@link CesiumMap}
+ */
+class TerrainCesiumImpl extends LayerImplementation<CesiumMap> {
+  static get className(): string {
+    return 'TerrainCesiumImpl';
+  }
+
+  requestVertexNormals: boolean;
+
+  requestWaterMask: boolean;
+
+  terrainProvider: CesiumTerrainProvider | undefined = undefined;
+
+  constructor(map: CesiumMap, options: TerrainImplementationOptions) {
+    super(map, options);
+
+    this.requestVertexNormals = options.requestVertexNormals;
+    this.requestWaterMask = options.requestWaterMask;
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      this.terrainProvider = await getTerrainProviderForUrl(
+        this.url as string,
+        {
+          requestVertexNormals: this.requestVertexNormals,
+          requestWaterMask: this.requestWaterMask,
+        },
+      );
+      this.terrainProvider[vcsLayerName] = this.name;
+    }
+    return super.initialize();
+  }
+
+  async activate(): Promise<void> {
+    await super.activate();
+    if (this.active && this.terrainProvider) {
+      this.map.setTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    if (this.terrainProvider) {
+      this.map.unsetTerrainProvider(this.terrainProvider);
+    }
+  }
+
+  destroy(): void {
+    this.terrainProvider = undefined;
+    super.destroy();
+  }
+}
+
+export default TerrainCesiumImpl;

package/src/layer/cesium/{tmsCesiumImpl.js → tmsCesiumImpl.ts}

@@ -1,47 +1,56 @@
-import { Rectangle, GeographicTilingScheme, TileMapServiceImageryProvider, ImageryLayer as CesiumImageryLayer } from '@vcmap/cesium';
+import {
+  Rectangle,
+  GeographicTilingScheme,
+  TileMapServiceImageryProvider,
+  ImageryLayer as CesiumImageryLayer,
+} from '@vcmap-cesium/engine';
 import RasterLayerCesiumImpl from './rasterLayerCesiumImpl.js';
 import { wgs84Projection } from '../../util/projection.js';
 import { TilingScheme } from '../rasterLayer.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+import type { TMSImplementationOptions } from '../tmsLayer.js';
 
 /**
  * TmsLayer implementation for {@link CesiumMap}.
- * @class
- * @export
- * @extends {RasterLayerCesiumImpl}
  */
 class TmsCesiumImpl extends RasterLayerCesiumImpl {
-  static get className() { return 'TmsCesiumImpl'; }
+  static get className(): string {
+    return 'TmsCesiumImpl';
+  }
+
+  format: string;
 
-  /**
-   * @param {import("@vcmap/core").CesiumMap} map
-   * @param {TMSImplementationOptions} options
-   */
-  constructor(map, options) {
+  constructor(map: CesiumMap, options: TMSImplementationOptions) {
     super(map, options);
-    /** @type {string} */
     this.format = options.format;
   }
 
-  /**
-   * @returns {import("@vcmap/cesium").ImageryLayer}
-   */
-  getCesiumLayer() {
-    const options = {
-      url: this.url,
+  async getCesiumLayer(): Promise<CesiumImageryLayer> {
+    const options: TileMapServiceImageryProvider.ConstructorOptions = {
       fileExtension: this.format,
       maximumLevel: this.maxLevel,
       minimumLevel: this.minLevel,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
       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]);
+      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 imageryProvider = await TileMapServiceImageryProvider.fromUrl(
+      this.url!,
+      options,
+    );
     const layerOptions = {
       alpha: this.opacity,
       splitDirection: this.splitDirection,

package/src/layer/cesium/vectorCesiumImpl.ts

@@ -0,0 +1,261 @@
+import { unByKey } from 'ol/Observable.js';
+import {
+  PrimitiveCollection,
+  type Scene,
+  type SplitDirection,
+} from '@vcmap-cesium/engine';
+import type VectorSource from 'ol/source/Vector.js';
+import type { EventsKey } from 'ol/events.js';
+import type { Feature } from 'ol/index.js';
+import VectorContext from './vectorContext.js';
+import { vcsLayerName } from '../layerSymbols.js';
+import LayerImplementation from '../layerImplementation.js';
+import { synchronizeFeatureVisibilityWithSource } from '../vectorHelpers.js';
+import type CesiumMap from '../../map/cesiumMap.js';
+import type { FeatureLayerImplementation } from '../featureLayer.js';
+import type { VectorImplementationOptions } from '../vectorLayer.js';
+import type VectorProperties from '../vectorProperties.js';
+import type StyleItem from '../../style/styleItem.js';
+import type FeatureVisibility from '../featureVisibility.js';
+import type GlobalHider from '../globalHider.js';
+
+/**
+ * represents a specific vector layer for cesium.
+ */
+class VectorCesiumImpl
+  extends LayerImplementation<CesiumMap>
+  implements FeatureLayerImplementation
+{
+  static get className(): string {
+    return 'VectorCesiumImpl';
+  }
+
+  vectorProperties: VectorProperties;
+
+  source: VectorSource;
+
+  splitDirection: SplitDirection;
+
+  style: StyleItem;
+
+  featureVisibility: FeatureVisibility;
+
+  private _featureVisibilityListeners: (() => void)[] = [];
+
+  // eslint-disable-next-line class-methods-use-this
+  private _removeVectorPropertiesChangeHandler = (): void => {};
+
+  protected _rootCollection: PrimitiveCollection;
+
+  private _olListeners: (EventsKey | EventsKey[])[] = [];
+
+  /**
+   * A set of ol.Features to add once the map is back to cesium
+   */
+  private _featureToAdd: Set<Feature> = new Set();
+
+  protected _context: VectorContext | null = null;
+
+  private _scene: Scene | undefined = undefined;
+
+  globalHider: GlobalHider | undefined;
+
+  constructor(map: CesiumMap, options: VectorImplementationOptions) {
+    super(map, options);
+
+    this.vectorProperties = options.vectorProperties;
+    this.source = options.source;
+    this.splitDirection = options.splitDirection;
+    this.style = options.style;
+    this.featureVisibility = options.featureVisibility;
+
+    this._rootCollection = new PrimitiveCollection();
+    this._rootCollection[vcsLayerName] = options.name;
+    this.globalHider = options.globalHider;
+  }
+
+  private _addListeners(): void {
+    this._olListeners.push(
+      this.source.on('addfeature', (event) => {
+        this._addFeature(event.feature as Feature);
+      }),
+    );
+
+    this._olListeners.push(
+      this.source.on('removefeature', (event) => {
+        this._removeFeature(event.feature as Feature);
+      }),
+    );
+
+    this._olListeners.push(
+      this.source.on('changefeature', (event) => {
+        this._featureChanged(event.feature as Feature);
+      }),
+    );
+
+    this._removeVectorPropertiesChangeHandler =
+      this.vectorProperties.propertyChanged.addEventListener(
+        this.refresh.bind(this),
+      );
+  }
+
+  protected _setupContext(cesiumMap: CesiumMap): Promise<void> {
+    const rootCollection = this._rootCollection;
+    this._context = new VectorContext(
+      cesiumMap,
+      rootCollection,
+      this.splitDirection,
+    );
+    cesiumMap.addPrimitiveCollection(rootCollection);
+    return Promise.resolve();
+  }
+
+  async initialize(): Promise<void> {
+    if (!this.initialized) {
+      this._scene = this.map.getScene();
+      this._addListeners();
+      this._addFeatures(this.source.getFeatures());
+      await this._setupContext(this.map);
+    }
+    await super.initialize();
+    if (this.splitDirection) {
+      this.updateSplitDirection(this.splitDirection);
+    }
+  }
+
+  _addFeatures(features: Feature[]): void {
+    // 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
+   */
+  private _addFeature(feature: Feature): void {
+    if (this.active) {
+      // XXX cluster check here? or on init?
+      this._context!.convertFeature(
+        feature,
+        this.style.style,
+        this.vectorProperties,
+        this._scene as Scene,
+      );
+    } else {
+      this._featureToAdd.add(feature);
+    }
+  }
+
+  /**
+   * Forces a complete re-render of all features.
+   */
+  refresh(): void {
+    this._context?.clear();
+    this._addFeatures(this.source.getFeatures());
+  }
+
+  /**
+   * removes the primitive of the specified feature
+   */
+  private _removeFeature(feature: Feature): void {
+    this._context?.removeFeature(feature);
+    this._featureToAdd.delete(feature);
+  }
+
+  /**
+   * called when a features property have changed
+   */
+  private _featureChanged(feature: Feature): void {
+    const cache = this._context!.createFeatureCache(feature);
+    this._featureToAdd.delete(feature);
+    this._addFeature(feature);
+    this._context!.clearFeatureCache(cache);
+  }
+
+  async activate(): Promise<void> {
+    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 as GlobalHider,
+            );
+        }
+      }
+    }
+  }
+
+  deactivate(): void {
+    super.deactivate();
+    this._rootCollection.show = false;
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this._featureVisibilityListeners = [];
+  }
+
+  updateStyle(style: StyleItem, silent?: boolean): void {
+    this.style = style;
+    if (this.initialized && !silent) {
+      const features = this.source.getFeatures().filter((f) => !f.getStyle());
+      features.forEach((f) => {
+        // eslint-disable-next-line no-void
+        void this._featureChanged(f);
+      });
+    }
+  }
+
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    if (this.initialized) {
+      this._context?.updateSplitDirection(splitDirection);
+    }
+  }
+
+  protected _destroyCollection(): void {
+    this.map.removePrimitiveCollection(this._rootCollection);
+  }
+
+  destroy(): void {
+    if (this.initialized) {
+      this._context?.destroy();
+      this._destroyCollection();
+    }
+    this._context = null;
+    this._scene = undefined;
+    this._removeVectorPropertiesChangeHandler();
+    this._olListeners.forEach((listener) => {
+      unByKey(listener);
+    });
+    this._olListeners = [];
+    this._featureToAdd.clear();
+    this._featureVisibilityListeners.forEach((cb) => {
+      cb();
+    });
+    this._featureVisibilityListeners = [];
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.source = null;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.vectorProperties = null;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.featureVisibility = null;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.style = null;
+    this.globalHider = undefined;
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this._rootCollection = null;
+    super.destroy();
+  }
+}
+
+export default VectorCesiumImpl;