@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/layer/rasterLayer.js

@@ -1,294 +0,0 @@
-import { ImagerySplitDirection, WebMercatorTilingScheme, GeographicTilingScheme, Cartographic } from '@vcmap/cesium';
-import { getBottomLeft, getBottomRight, getTopLeft, getTopRight } from 'ol/extent.js';
-
-import { parseInteger, parseNumberRange, parseEnumValue } from '@vcsuite/parsers';
-import { wgs84Projection } from '../util/projection.js';
-import Layer from './layer.js';
-import VcsEvent from '../vcsEvent.js';
-import Extent from '../util/extent.js';
-import { VcsClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {LayerOptions} RasterLayerOptions
- * @property {number|undefined} [minLevel=0] -  minLevel to show (if not specified, calculated from extent)
- * @property {number} [maxLevel=18] -  maxLevel to show
- * @property {string} [tilingSchema='geographic'] -  either "geographic" or "mercator"
- * @property {number} [opacity=1.0] - opacity between 0 and 1
- * @property {string|undefined} splitDirection - either 'left' or 'right', none if omitted
- * @api
- */
-
-/**
- * @typedef {LayerImplementationOptions} RasterLayerImplementationOptions
- * @property {number} minLevel
- * @property {number} maxLevel
- * @property {string} tilingSchema
- * @property {number} opacity
- * @property {import("@vcmap/cesium").ImagerySplitDirection} splitDirection
- * @property {Extent|undefined} extent
- */
-
-/**
- * @typedef {import("@vcmap/core").LayerImplementation<import("@vcmap/core").VcsMap>} RasterLayerImplementation
- * @property {function(number):void} updateOpacity
- * @property {function(import("@vcmap/cesium").ImagerySplitDirection):void} updateSplitDirection
- * @api
- */
-
-/**
- * Enumeration of tiling schemes.
- * @enum {string}
- * @api
- * @property {string} GEOGRAPHIC
- * @property {string} MERCATOR
- * @export
- */
-export const TilingScheme = {
-  GEOGRAPHIC: 'geographic',
-  MERCATOR: 'mercator',
-};
-
-/**
- * Gets the tiling scheme associated with this layerConfig
- * @param {Object} layerOptions
- * @returns {import("@vcmap/cesium").WebMercatorTilingScheme|import("@vcmap/cesium").GeographicTilingScheme}
- */
-export function getTilingScheme(layerOptions) {
-  const tilingSchemeOptions = {};
-  if (layerOptions.numberOfLevelZeroTilesX && layerOptions.numberOfLevelZeroTilesX > 1) {
-    tilingSchemeOptions.numberOfLevelZeroTilesX = layerOptions.numberOfLevelZeroTilesX;
-  }
-  if (layerOptions.numberOfLevelZeroTilesY && layerOptions.numberOfLevelZeroTilesY > 1) {
-    tilingSchemeOptions.numberOfLevelZeroTilesY = layerOptions.numberOfLevelZeroTilesY;
-  }
-  if (layerOptions.tilingSchema === TilingScheme.MERCATOR) {
-    return new WebMercatorTilingScheme(tilingSchemeOptions);
-  }
-  return new GeographicTilingScheme(tilingSchemeOptions);
-}
-
-/**
- * @param {Extent} extent
- * @param {import("@vcmap/cesium").GeographicTilingScheme|import("@vcmap/cesium").WebMercatorTilingScheme} tilingScheme
- * @param {number} maxLevel
- * @param {number} [minLevel=0]
- * @returns {number}
- */
-export function calculateMinLevel(extent, tilingScheme, maxLevel, minLevel = 0) {
-  if (!extent.isValid()) {
-    return minLevel;
-  }
-  const wgs84Extent = extent.getCoordinatesInProjection(wgs84Projection);
-  if (wgs84Extent[1] < -85) {
-    wgs84Extent[1] = -85;
-  }
-  if (wgs84Extent[3] > 85) {
-    wgs84Extent[3] = 85;
-  }
-  const olCoords = [
-    getBottomLeft(wgs84Extent),
-    getBottomRight(wgs84Extent),
-    getTopRight(wgs84Extent),
-    getTopLeft(wgs84Extent),
-  ];
-  const extentCoords = olCoords.map(coord => Cartographic.fromDegrees(coord[0], coord[1]));
-  let usedMinLevel = minLevel;
-  while (usedMinLevel < maxLevel) {
-    // eslint-disable-next-line no-loop-func
-    const tileCoords = extentCoords.map(position => tilingScheme.positionToTileXY(position, usedMinLevel));
-    const distances = [];
-    distances.push(Math.abs(tileCoords[0].x - tileCoords[1].x));
-    distances.push(Math.abs(tileCoords[0].y - tileCoords[3].y));
-    if (distances[0] > 1 || distances[1] > 1) {
-      usedMinLevel -= 1;
-      break;
-    }
-    usedMinLevel += 1;
-  }
-  return usedMinLevel;
-}
-
-/**
- * This abstract class allows for automatic loading scheme determination
- * for raster layers
- * @class
- * @export
- * @extends {Layer}
- * @implements {SplitLayer}
- * @abstract
- */
-class RasterLayer extends Layer {
-  static get className() { return 'RasterLayer'; }
-
-  /**
-   * @returns {RasterLayerOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...Layer.getDefaultOptions(),
-      minLevel: 0,
-      maxLevel: 18,
-      tilingSchema: TilingScheme.GEOGRAPHIC,
-      opacity: 1,
-      splitDirection: undefined,
-    };
-  }
-
-  /**
-   * @param {RasterLayerOptions} options
-   */
-  constructor(options) {
-    options.url = options.url || '';
-    super(options);
-    const defaultOptions = RasterLayer.getDefaultOptions();
-    this.extent = this.extent || new Extent();
-    /**
-     * The {@link RasterLayer.TilingScheme} of this layer
-     * @type {string}
-     * @api
-     */
-    this.tilingSchema = parseEnumValue(options.tilingSchema, TilingScheme, defaultOptions.tilingSchema);
-    /** @type {number} */
-    this.maxLevel = parseInteger(options.maxLevel, defaultOptions.maxLevel);
-    /**
-     * @type {number}
-     * @private
-     */
-    this._minLevel = parseInteger(options.minLevel, defaultOptions.minLevel);
-
-    const cesiumTilingScheme = getTilingScheme(options);
-    /** @type {number} */
-    this.minLevel = calculateMinLevel(this.extent, cesiumTilingScheme, this.maxLevel, this._minLevel);
-
-    /**
-     * @type {number}
-     * @private
-     */
-    this._opacity = parseNumberRange(options.opacity, defaultOptions.opacity, 0.0, 1.0);
-
-    /** @type {import("@vcmap/cesium").ImagerySplitDirection} */
-    this._splitDirection = ImagerySplitDirection.NONE;
-
-    if (options.splitDirection) {
-      this._splitDirection = options.splitDirection === 'left' ?
-        ImagerySplitDirection.LEFT :
-        ImagerySplitDirection.RIGHT;
-    }
-
-    /**
-     * raised if the split direction changes, is passed the split direction as its only argument
-     * @type {VcsEvent<import("@vcmap/cesium").ImagerySplitDirection>}
-     * @api
-     */
-    this.splitDirectionChanged = new VcsEvent();
-  }
-
-  /**
-   * The split directions of this layer
-   * @api
-   * @type {import("@vcmap/cesium").ImagerySplitDirection}
-   */
-  get splitDirection() { return this._splitDirection; }
-
-  /**
-   * @param {import("@vcmap/cesium").ImagerySplitDirection} direction
-   */
-  set splitDirection(direction) {
-    if (direction !== this._splitDirection) {
-      this._splitDirection = direction;
-      this.getImplementations().forEach((impl) => {
-        /** @type {RasterLayerImplementation} */
-        (impl).updateSplitDirection(direction);
-      });
-      this.splitDirectionChanged.raiseEvent(this._splitDirection);
-    }
-  }
-
-  /**
-   * The opacity between 0 (fully transparent) and 1 (fully opaque)
-   * @api
-   * @type {number}
-   */
-  get opacity() { return this._opacity; }
-
-  /**
-   * @param {number} opacity
-   */
-  set opacity(opacity) {
-    const parsedValue = parseNumberRange(opacity, this._opacity, 0, 1);
-    if (this._opacity !== parsedValue) {
-      this._opacity = parsedValue;
-      this.getImplementations().forEach((impl) => {
-        /** @type {RasterLayerImplementation} */
-        (impl).updateOpacity(parsedValue);
-      });
-    }
-  }
-
-  /**
-   * @returns {RasterLayerImplementationOptions}
-   */
-  getImplementationOptions() {
-    const options = /** @type {RasterLayerImplementationOptions} */ ({
-      ...super.getImplementationOptions(),
-      minLevel: this.minLevel,
-      maxLevel: this.maxLevel,
-      tilingSchema: this.tilingSchema,
-      opacity: this.opacity,
-      splitDirection: this._splitDirection,
-    });
-
-    if (this.extent.isValid()) {
-      options.extent = this.extent;
-    }
-    return options;
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {RasterLayerOptions}
-   */
-  toJSON() {
-    const config = /** @type {RasterLayerOptions} */ (super.toJSON());
-    const defaultOptions = RasterLayer.getDefaultOptions();
-
-    if (this.extent.equals(new Extent())) {
-      delete config.extent;
-    }
-
-    if (this._minLevel !== defaultOptions.minLevel) {
-      config.minLevel = this._minLevel;
-    }
-
-    if (this.maxLevel !== defaultOptions.maxLevel) {
-      config.maxLevel = this.maxLevel;
-    }
-
-    if (this.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this.tilingSchema;
-    }
-
-    if (this.opacity !== defaultOptions.opacity) {
-      config.opacity = this.opacity;
-    }
-
-    if (this._splitDirection !== ImagerySplitDirection.NONE) {
-      config.splitDirection = this._splitDirection === ImagerySplitDirection.RIGHT ?
-        'right' :
-        'left';
-    }
-
-    return config;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  destroy() {
-    this.splitDirectionChanged.destroy();
-    super.destroy();
-  }
-}
-
-VcsClassRegistry.registerClass(RasterLayer.className, RasterLayer);
-export default RasterLayer;

package/src/layer/singleImageLayer.js

@@ -1,120 +0,0 @@
-import { check } from '@vcsuite/check';
-import RasterLayer from './rasterLayer.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 { wgs84Projection } from '../util/projection.js';
-
-/**
- * @typedef {RasterLayerOptions} SingleImageOptions
- * @property {string|undefined} credit -  credit
- * @api
- */
-
-/**
- * @typedef {RasterLayerImplementationOptions} SingleImageImplementationOptions
- * @property {string|undefined} credit
- */
-
-/**
- * Image layer for Cesium and OpenlayersMap
- * @class
- * @export
- * @extends {RasterLayer}
- * @api stable
- */
-class SingleImageLayer extends RasterLayer {
-  static get className() { return 'SingleImageLayer'; }
-
-  /**
-   * @returns {SingleImageOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...RasterLayer.getDefaultOptions(),
-      credit: undefined,
-    };
-  }
-
-  /**
-   * @param {SingleImageOptions} options
-   */
-  constructor(options) {
-    super(options);
-    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.extent = new Extent({
-        projection: wgs84Projection.toJSON(),
-        coordinates: [-180, -90, 180, 90],
-      });
-    }
-
-    this._supportedMaps = [
-      CesiumMap.className,
-      OpenlayersMap.className,
-    ];
-  }
-
-  /**
-   * @returns {SingleImageImplementationOptions}
-   */
-  getImplementationOptions() {
-    return {
-      ...super.getImplementationOptions(),
-      credit: this.credit,
-    };
-  }
-
-  /**
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<SingleImageOpenlayersImpl|SingleImageCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
-    if (map instanceof CesiumMap) {
-      return [new SingleImageCesiumImpl(map, this.getImplementationOptions())];
-    } else if (map instanceof OpenlayersMap) {
-      return [new SingleImageOpenlayersImpl(map, this.getImplementationOptions())];
-    }
-    return [];
-  }
-
-  /**
-   * sets the image extent
-   * @param {Extent} extent
-   * @api
-   */
-  setExtent(extent) {
-    check(extent, Extent);
-    if (!extent.isValid()) {
-      throw new Error('Cannot set invalid extent');
-    }
-
-    this.extent = extent;
-    this.forceRedraw();
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {SingleImageOptions}
-   */
-  toJSON() {
-    const config = /** @type {SingleImageOptions} */ (super.toJSON());
-    delete config.tilingSchema;
-
-    if (this.credit) {
-      config.credit = this.credit;
-    }
-
-    return config;
-  }
-}
-
-VcsClassRegistry.registerClass(SingleImageLayer.className, SingleImageLayer);
-export default SingleImageLayer;

package/src/layer/terrainHelpers.js

@@ -1,119 +0,0 @@
-import { CesiumTerrainProvider, Cartographic, Cartesian2, sampleTerrainMostDetailed, sampleTerrain } from '@vcmap/cesium';
-import { getTransform } from 'ol/proj.js';
-import { wgs84Projection } from '../util/projection.js';
-
-/**
- * @typedef {Object} TerrainProviderOptions
- * @property {!string} url
- * @property {boolean|undefined} requestVertexNormals
- * @property {boolean|undefined} requestWaterMask
- * @api
- */
-
-/**
- * @type {Object<string, import("@vcmap/cesium").CesiumTerrainProvider>}
- */
-const terrainProviders = {};
-
-/**
- * @param {TerrainProviderOptions} options
- * @returns {import("@vcmap/cesium").CesiumTerrainProvider}
- */
-export function getTerrainProviderForUrl(options) {
-  if (!terrainProviders[options.url]) {
-    terrainProviders[options.url] = new CesiumTerrainProvider(options);
-    return terrainProviders[options.url];
-  }
-  let terrainProvider = terrainProviders[options.url];
-  if ((options.requestVertexNormals !== undefined &&
-    terrainProvider.requestVertexNormals !== options.requestVertexNormals) ||
-    (options.requestWaterMask !== undefined &&
-      terrainProvider.requestWaterMask !== options.requestWaterMask)) {
-    terrainProviders[options.url] = new CesiumTerrainProvider(options);
-    terrainProvider = terrainProviders[options.url];
-  }
-  return terrainProvider;
-}
-
-/**
- * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
- * @param {Array<import("@vcmap/cesium").Cartographic>} positions
- * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
- */
-export function sampleCesiumTerrainMostDetailed(terrainProvider, positions) {
-  return new Promise((resolve, reject) => {
-    sampleTerrainMostDetailed(terrainProvider, positions)
-      .then((updatedPositions) => {
-        resolve(updatedPositions);
-      }, reject);
-  });
-}
-
-/**
- * updates the height of the positions in place.
- * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
- * @param {number} level
- * @param {Array<import("@vcmap/cesium").Cartographic>} positions
- * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
- */
-export function sampleCesiumTerrain(terrainProvider, level, positions) {
-  return new Promise((resolve, reject) => {
-    sampleTerrain(terrainProvider, level, positions)
-      .then((updatedPositions) => {
-        resolve(updatedPositions);
-      }, reject);
-  });
-}
-
-/**
- * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
- * @param {import("@vcmap/cesium").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 new Promise((resolve, reject) => {
-    sampleTerrainMostDetailed(terrainProvider, positions)
-      .then((updatedPositions) => {
-        updatedPositions.forEach((position, index) => {
-          outArray[index][2] = position.height || 0;
-        });
-        resolve(outArray);
-      }, reject);
-  });
-}
-
-/**
- * checks, whether a terrain tile is available at given position or not
- * @param {import("@vcmap/cesium").CesiumTerrainProvider} terrainProvider
- * @param {number} level
- * @param {import("@vcmap/cesium").Cartographic} position
- * @returns {boolean}
- */
-export function isTerrainTileAvailable(terrainProvider, level, position) {
-  if (!terrainProvider.ready) {
-    return false;
-  }
-  const tileXY = terrainProvider.tilingScheme.positionToTileXY(
-    position, level, new Cartesian2(),
-  );
-  return terrainProvider.getTileDataAvailable(tileXY.x, tileXY.y, level);
-}
-

package/src/layer/terrainLayer.js

@@ -1,122 +0,0 @@
-import { parseBoolean } from '@vcsuite/parsers';
-import Layer from './layer.js';
-import { getHeightFromTerrainProvider, getTerrainProviderForUrl } from './terrainHelpers.js';
-import CesiumMap from '../map/cesiumMap.js';
-import TerrainCesiumImpl from './cesium/terrainCesiumImpl.js';
-import { VcsClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {LayerOptions} TerrainOptions
- * @property {boolean} [requestVertexNormals=true] - if the terrain should be shaded
- * @property {boolean} [requestWaterMask=false] - if a watermask should be requested
- * @api
- */
-
-/**
- * @typedef {LayerImplementationOptions} TerrainImplementationOptions
- * @property {boolean} requestVertexNormals
- * @property {boolean} requestWaterMask
- */
-
-/**
- * represents a terrain layer.
- * @class
- * @export
- * @extends {Layer}
- * @api stable
- */
-class TerrainLayer extends Layer {
-  static get className() { return 'TerrainLayer'; }
-
-  /**
-   * @returns {TerrainOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...Layer.getDefaultOptions(),
-      requestVertexNormals: true,
-      requestWaterMask: false,
-    };
-  }
-
-  /**
-   * @param {TerrainOptions} options
-   */
-  constructor(options) {
-    super(options);
-    const defaultOptions = TerrainLayer.getDefaultOptions();
-
-    this._supportedMaps = [
-      CesiumMap.className,
-    ];
-
-    /**
-     * @type {boolean}
-     * @api
-     */
-    this.requestVertexNormals = parseBoolean(options.requestVertexNormals, defaultOptions.requestVertexNormals);
-
-    /**
-     * @type {boolean}
-     * @api
-     */
-    this.requestWaterMask = parseBoolean(options.requestWaterMask, defaultOptions.requestWaterMask);
-  }
-
-  /**
-   * @returns {TerrainImplementationOptions}
-   */
-  getImplementationOptions() {
-    return {
-      ...super.getImplementationOptions(),
-      requestVertexNormals: this.requestVertexNormals,
-      requestWaterMask: this.requestWaterMask,
-    };
-  }
-
-  /**
-   * @inheritDoc
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<TerrainCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
-    if (map instanceof CesiumMap) {
-      return [new TerrainCesiumImpl(map, this.getImplementationOptions())];
-    }
-    return [];
-  }
-
-  /**
-   * getHeight for coordinates
-   * @param {Array<import("ol/coordinate").Coordinate>} coords - the height is added to the coordinates in place
-   * @returns {Promise<Array<import("ol/coordinate").Coordinate>>}
-   * @api stable
-   */
-  getHeightForWGS84Coordinates(coords) {
-    const terrainProvider = getTerrainProviderForUrl({
-      url: this.url,
-      requestVertexNormals: this.requestVertexNormals,
-      requestWaterMask: this.requestWaterMask,
-    });
-    return getHeightFromTerrainProvider(terrainProvider, coords, null, coords);
-  }
-
-  /**
-   * @returns {TerrainOptions}
-   */
-  toJSON() {
-    const config = /** @type {TerrainOptions} */ (super.toJSON());
-    const defaultOptions = TerrainLayer.getDefaultOptions();
-
-    if (this.requestVertexNormals !== defaultOptions.requestVertexNormals) {
-      config.requestVertexNormals = this.requestVertexNormals;
-    }
-    if (this.requestWaterMask !== defaultOptions.requestWaterMask) {
-      config.requestWaterMask = this.requestWaterMask;
-    }
-    return config;
-  }
-}
-
-VcsClassRegistry.registerClass(TerrainLayer.className, TerrainLayer);
-export default TerrainLayer;