@vcmap/core 5.0.0-rc.9 → 5.0.0

package/src/layer/wmtsLayer.js

@@ -1,235 +0,0 @@
-import { parseInteger } from '@vcsuite/parsers';
-import { getLogger } from '@vcsuite/logger';
-import RasterLayer from './rasterLayer.js';
-import OpenlayersMap from '../map/openlayersMap.js';
-import CesiumMap from '../map/cesiumMap.js';
-import WmtsOpenlayersImpl from './openlayers/wmtsOpenlayersImpl.js';
-import WmtsCesiumImpl from './cesium/wmtsCesiumImpl.js';
-import { layerClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {RasterLayerOptions} WMTSOptions
- * @property {string} layer
- * @property {string|undefined} style
- * @property {string|undefined} format
- * @property {string|undefined} tileMatrixSetID
- * @property {string|undefined} tileMatrixPrefix
- * @property {Array<string>} matrixIds
- * @property {number} [numberOfLevelZeroTilesX=1]
- * @property {number} [numberOfLevelZeroTilesY=1]
- * @property {Object|undefined} openlayersOptions
- * @property {import("ol/size").Size} [tileSize=[256,256]]
- * @api
- */
-
-/**
- * @typedef {RasterLayerImplementationOptions} WMTSImplementationOptions
- * @property {string} layer
- * @property {string} style
- * @property {string} format
- * @property {string} tileMatrixSetID
- * @property {import("ol/size").Size} tileSize
- * @property {number} numberOfLevelZeroTilesX
- * @property {number} numberOfLevelZeroTilesY
- * @property {Array<string>} matrixIds
- * @property {Object} openlayersOptions
- */
-
-
-/**
- * @param {Array<string>} matrixIds
- * @param {number} maxLevel
- * @param {string} prefix
- * @returns {Array<string>}
- */
-function getMatrixIds(matrixIds, maxLevel, prefix) {
-  if (matrixIds.length > 0) {
-    if (matrixIds.length === (maxLevel + 1)) {
-      return matrixIds;
-    } else {
-      getLogger('WmtsCesiumImpl')
-        .log('matrixIds must have the same length as maxLevel');
-    }
-  }
-  return new Array(maxLevel + 1).fill(undefined).map((value, index) => {
-    return `${prefix}${index}`;
-  });
-}
-
-
-/**
- * WmtsLayer layer
- * @class
- * @export
- * @extends {RasterLayer}
- * @api stable
- */
-class WMTSLayer extends RasterLayer {
-  static get className() { return 'WMTSLayer'; }
-
-  /**
-   * @returns {WMTSOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...RasterLayer.getDefaultOptions(),
-      tilingSchema: 'mercator',
-      numberOfLevelZeroTilesX: 1,
-      numberOfLevelZeroTilesY: 1,
-      layer: '',
-      style: '',
-      format: '',
-      tileMatrixPrefix: '',
-      tileMatrixSetID: '',
-      openlayersOptions: {},
-      matrixIds: [],
-      tileSize: /** @type {import("ol/size").Size} */ ([256, 256]),
-    };
-  }
-
-  /**
-   * @param {WMTSOptions} options
-   */
-  constructor(options) {
-    const defaultOptions = WMTSLayer.getDefaultOptions();
-    options.tilingSchema = options.tilingSchema || defaultOptions.tilingSchema;
-    super(options);
-
-    this._supportedMaps = [
-      OpenlayersMap.className,
-      CesiumMap.className,
-    ];
-
-    /** @type {number} */
-    this.numberOfLevelZeroTilesX = parseInteger(
-      options.numberOfLevelZeroTilesX,
-      defaultOptions.numberOfLevelZeroTilesX,
-    );
-
-    /** @type {number} */
-    this.numberOfLevelZeroTilesY = parseInteger(
-      options.numberOfLevelZeroTilesY,
-      defaultOptions.numberOfLevelZeroTilesY,
-    );
-
-    /** @type {string} */
-    this.layer = options.layer || defaultOptions.layer;
-
-    /** @type {string} */
-    this.style = options.style || defaultOptions.style;
-
-    /** @type {string} */
-    this.format = options.format || defaultOptions.format;
-
-    /** @type {string} */
-    this.tileMatrixPrefix = options.tileMatrixPrefix || defaultOptions.tileMatrixPrefix;
-
-    /** @type {string} */
-    this.tileMatrixSetID = options.tileMatrixSetID || defaultOptions.tileMatrixSetID;
-
-    /** @type {Object} */
-    this.openlayersOptions = options.openlayersOptions || defaultOptions.openlayersOptions;
-
-    /** @type {Array.<string> | null} */
-    this.matrixIds = Array.isArray(options.matrixIds) ? options.matrixIds : defaultOptions.matrixIds;
-
-    /** @type {import("ol/size").Size} */
-    this.tileSize = options.tileSize || defaultOptions.tileSize;
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {WMTSImplementationOptions}
-   */
-  getImplementationOptions() {
-    return {
-      ...super.getImplementationOptions(),
-      layer: this.layer,
-      style: this.style,
-      format: this.format,
-      tileMatrixSetID: this.tileMatrixSetID,
-      tileSize: this.tileSize,
-      numberOfLevelZeroTilesX: this.numberOfLevelZeroTilesX,
-      numberOfLevelZeroTilesY: this.numberOfLevelZeroTilesY,
-      matrixIds: getMatrixIds(this.matrixIds, this.maxLevel, this.tileMatrixPrefix),
-      openlayersOptions: this.openlayersOptions,
-    };
-  }
-
-  /**
-   * @inheritDoc
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<WmtsOpenlayersImpl|WmtsCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
-    if (map instanceof OpenlayersMap) {
-      return [new WmtsOpenlayersImpl(map, this.getImplementationOptions())];
-    }
-
-    if (map instanceof CesiumMap) {
-      return [new WmtsCesiumImpl(map, this.getImplementationOptions())];
-    }
-    return [];
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {WMTSOptions}
-   */
-  toJSON() {
-    const config = /** @type {WMTSOptions} */ (super.toJSON());
-    const defaultOptions = WMTSLayer.getDefaultOptions();
-
-    if (this.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this.tilingSchema;
-    } else {
-      delete config.tilingSchema;
-    }
-
-    if (this.numberOfLevelZeroTilesX !== defaultOptions.numberOfLevelZeroTilesX) {
-      config.numberOfLevelZeroTilesX = this.numberOfLevelZeroTilesX;
-    }
-
-    if (this.numberOfLevelZeroTilesY !== defaultOptions.numberOfLevelZeroTilesY) {
-      config.numberOfLevelZeroTilesY = this.numberOfLevelZeroTilesY;
-    }
-
-    if (this.layer !== defaultOptions.layer) {
-      config.layer = this.layer;
-    }
-
-    if (this.style !== defaultOptions.style) {
-      config.style = this.style;
-    }
-
-    if (this.format !== defaultOptions.format) {
-      config.format = this.format;
-    }
-
-    if (this.tileMatrixPrefix !== defaultOptions.tileMatrixPrefix) {
-      config.tileMatrixPrefix = this.tileMatrixPrefix;
-    }
-
-    if (this.tileMatrixSetID !== defaultOptions.tileMatrixSetID) {
-      config.tileMatrixSetID = this.tileMatrixSetID;
-    }
-
-    if (Object.keys(this.openlayersOptions).length > 0) {
-      config.openlayersOptions = { ...this.openlayersOptions };
-    }
-
-    if (this.matrixIds.length > 0) {
-      config.matrixIds = this.matrixIds.slice();
-    }
-
-    if (this.tileSize[0] !== defaultOptions.tileSize[0] || this.tileSize[1] !== defaultOptions.tileSize[1]) {
-      config.tileSize = /** @type {import("ol/size").Size} */ (this.tileSize.slice());
-    }
-
-    return config;
-  }
-}
-
-layerClassRegistry.registerClass(WMTSLayer.className, WMTSLayer);
-export default WMTSLayer;
-

package/src/map/baseOLMap.js

@@ -1,257 +0,0 @@
-import { Cartesian2 } from '@vcmap/cesium';
-import { unByKey } from 'ol/Observable.js';
-import OLMap from 'ol/Map.js';
-import { defaults as defaultInteractions } from 'ol/interaction.js';
-import VcsMap from './vcsMap.js';
-import { vcsLayerName } from '../layer/layerSymbols.js';
-import { ModificationKeyType, PointerEventType, PointerKeyType } from '../interaction/interactionType.js';
-import { mapClassRegistry } from '../classRegistry.js';
-
-/**
- * @param {import("ol/Collection").default<import("ol/layer/Layer").default>} layers
- * @param {import("ol/layer/Layer").default} layer
- * @param {import("@vcmap/core").LayerCollection} layerCollection
- * @private
- */
-export function ensureLayerInCollection(layers, layer, layerCollection) {
-  const targetIndex = layerCollection.indexOfKey(layer[vcsLayerName]);
-  if (targetIndex > -1) {
-    const layerArray = layers.getArray();
-
-    if (!layerArray.includes(layer)) {
-      let indexInOlCollection = layerArray.findIndex((l) => {
-        const layerIndex = layerCollection.indexOfKey(l[vcsLayerName]);
-        return layerIndex > targetIndex;
-      });
-      if (indexInOlCollection === -1) {
-        indexInOlCollection = layerArray.length;
-      }
-      layers.insertAt(indexInOlCollection, layer);
-    }
-  }
-}
-
-/**
- * OpenlayersMap Map base map.
- * @class
- * @abstract
- * @api
- * @export
- * @extends {VcsMap}
- */
-class BaseOLMap extends VcsMap {
-  static get className() { return 'BaseOLMap'; }
-
-  /**
-   * @param {VcsMapOptions} options
-   */
-  constructor(options) {
-    super(options);
-
-    /**
-     * the openlayers map object, set after initialization
-     * @private
-     * @type {import("ol/Map").default|null}
-     */
-    this._olMap = null;
-    /**
-     * @type {Array<import("ol/events").EventsKey>}
-     * @private
-     */
-    this._olListeners = [];
-  }
-
-  /**
-   * @returns {import("ol/Map").default}
-   * @readonly
-   * @api
-   */
-  get olMap() {
-    return this._olMap;
-  }
-
-  /**
-   * @param {import("ol/MapBrowserEvent").default} olEvent
-   * @param {PointerEventType} pointerEvent
-   * @private
-   */
-  _raisePointerInteraction(olEvent, pointerEvent) {
-    const pointerMap = {
-      '-1': PointerKeyType.ALL,
-      0: PointerKeyType.LEFT,
-      1: PointerKeyType.MIDDLE,
-      2: PointerKeyType.RIGHT,
-    };
-    let key = olEvent.originalEvent.shiftKey ? ModificationKeyType.SHIFT : ModificationKeyType.NONE;
-    key = olEvent.originalEvent.ctrlKey ? ModificationKeyType.CTRL : key;
-    key = olEvent.originalEvent.altKey ? ModificationKeyType.ALT : key;
-    if (key !== ModificationKeyType.NONE) {
-      olEvent.preventDefault();
-    }
-    olEvent.originalEvent.preventDefault();
-    const position = [olEvent.coordinate[0], olEvent.coordinate[1], 0];
-    this.pointerInteractionEvent.raiseEvent({
-      map: this,
-      position,
-      positionOrPixel: position,
-      windowPosition: Cartesian2.fromArray(olEvent.pixel, 0, new Cartesian2()),
-      key,
-      pointer: pointerMap[olEvent.originalEvent.button || 0],
-      pointerEvent,
-    });
-  }
-
-  /**
-   * @inheritDoc
-   * @param {string|HTMLElement|null} target
-   */
-  setTarget(target) {
-    super.setTarget(target);
-    if (this._olMap && this.target) {
-      this._olMap.updateSize();
-    }
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    if (!this._olMap) {
-      this._olMap = new OLMap({
-        layers: [],
-        controls: [],
-        interactions: defaultInteractions({
-          altShiftDragRotate: false,
-          pinchRotate: false,
-          shiftDragZoom: false,
-          doubleClickZoom: false,
-        }),
-        target: this.mapElement,
-      });
-
-      // @ts-ignore
-      const pointerDownListener = /** @type {import("ol/events").EventsKey} */ (this.olMap.on('pointerdown', (event) => {
-        this._raisePointerInteraction(
-          /** @type {import("ol/MapBrowserEvent").default}  */ (event),
-          PointerEventType.DOWN,
-        );
-      }));
-      // @ts-ignore
-      const pointerUpListener = /** @type {import("ol/events").EventsKey} */ (this.olMap.on('pointerup', (event) => {
-        this._raisePointerInteraction(
-          /** @type {import("ol/MapBrowserEvent").default}  */ (event),
-          PointerEventType.UP,
-        );
-      }));
-      // @ts-ignore
-      const pointerMoveListener = /** @type {import("ol/events").EventsKey} */ (this.olMap.on('pointermove', (event) => {
-        this._raisePointerInteraction(event, PointerEventType.MOVE);
-      }));
-      this._olListeners.push(pointerDownListener, pointerUpListener, pointerMoveListener);
-    }
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {Promise<void>}
-   */
-  async activate() {
-    await super.activate();
-    if (this.active) {
-      this._olMap.updateSize();
-    }
-  }
-
-  /**
-   * @inheritDoc
-   * @param {import("@vcmap/core").Layer} layer
-   */
-  indexChanged(layer) {
-    const viz = this.getVisualizationsForLayer(layer);
-    if (viz) {
-      viz.forEach(/** @param {import("ol/layer/Layer").default<import("ol/source").Source>} olLayer */ (olLayer) => {
-        const layers = /** @type {import("ol/Collection").default<import("ol/layer/Layer").default<import("ol/source").Source>>} */
-          (this._olMap.getLayers());
-        layers.remove(olLayer);
-        ensureLayerInCollection(layers, olLayer, this.layerCollection);
-      });
-    }
-  }
-
-  /**
-   * Internal API for registering representations.
-   * @param {import("ol/layer/Layer").default<import("ol/source").Source>} olLayer
-   */
-  addOLLayer(olLayer) {
-    if (this.validateVisualization(olLayer)) {
-      this.addVisualization(olLayer);
-      ensureLayerInCollection(
-        /** @type {import("ol/Collection").default<import("ol/layer/Layer").default<import("ol/source").Source>>} */
-        (this._olMap.getLayers()),
-        olLayer,
-        this.layerCollection,
-      );
-    }
-  }
-
-  /**
-   * Internal API for deregistering representations.
-   * @param {import("ol/layer/Layer").default<import("ol/source").Source>} olLayer
-   */
-  removeOLLayer(olLayer) {
-    this.removeVisualization(olLayer);
-    this._olMap.getLayers().remove(olLayer);
-  }
-
-  /**
-   * @param {boolean} prevent
-   * @inheritDoc
-   */
-  disableMovement(prevent) {
-    super.disableMovement(prevent);
-    if (this._olMap) {
-      this._olMap.getInteractions().forEach((i) => { i.setActive(!prevent); });
-    }
-  }
-
-  /**
-   * @inheritDoc
-   * @param {import("ol/coordinate").Coordinate} coordinate
-   * @returns {number}
-   * @api
-   */
-  // eslint-disable-next-line no-unused-vars
-  getCurrentResolution(coordinate) {
-    const view = this.olMap ? this.olMap.getView() : null;
-    if (view) {
-      return view.getResolution();
-    }
-    return 1;
-  }
-
-  /**
-   * @inheritDoc
-   * @api
-   */
-  requestRender() {
-    if (this._olMap) {
-      this._olMap.render();
-    }
-  }
-
-  /**
-   * @inheritDoc
-   * @api
-   */
-  destroy() {
-    if (this._olMap) {
-      this._olMap.setTarget(null);
-    }
-    unByKey(this._olListeners);
-    super.destroy();
-  }
-}
-
-mapClassRegistry.registerClass(BaseOLMap.className, BaseOLMap);
-export default BaseOLMap;

package/src/map/cameraLimiter.js

@@ -1,219 +0,0 @@
-import { Cartographic, Ellipsoid, Math as CesiumMath } from '@vcmap/cesium';
-import { checkMaybe } from '@vcsuite/check';
-import { parseInteger, parseNumber, parseEnumValue } from '@vcsuite/parsers';
-import {
-  sampleCesiumTerrain,
-  sampleCesiumTerrainMostDetailed,
-  getTerrainProviderForUrl,
-  isTerrainTileAvailable,
-} from '../layer/terrainHelpers.js';
-
-/**
- * @typedef {Object} CameraLimiterOptions
- * @property {string|undefined} terrainUrl - required if mode is distance.
- * @property {string|undefined} [mode="height"] - either "height" or "distance".
- * @property {number} [limit=200]
- * @property {number|null} [level=12] - the level at which to request terrain data. setting this to null will request most detailed
- * @api
- */
-
-/**
- * Enumeration of camera limiter modes.
- * @enum {string}
- * @property {string} HEIGHT
- * @property {string} DISTANCE
- */
-export const CameraLimiterMode = {
-  HEIGHT: 'height',
-  DISTANCE: 'distance',
-};
-
-/**
- * Can limit a Cesium.Cameras position based on absolute height or distance to a given terrain
- * @class
- * @export
- * @api
- */
-class CameraLimiter {
-  static get className() { return 'CameraLimiter'; }
-
-  /**
-   * @returns {CameraLimiterOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      mode: CameraLimiterMode.HEIGHT,
-      terrainUrl: undefined,
-      limit: 200,
-      level: 12,
-    };
-  }
-
-  /**
-   * @param {CameraLimiterOptions} options
-   */
-  constructor(options) {
-    const defaultOptions = CameraLimiter.getDefaultOptions();
-    /**
-     * The mode to use. When using DISTANCE mode, be sure to have a terrainProvider set.
-     * @type {CameraLimiterMode}
-     * @api
-     */
-    this.mode = parseEnumValue(options.mode, CameraLimiterMode, defaultOptions.mode);
-    /**
-     * @type {string|null}
-     * @private
-     */
-    this._terrainUrl = options.terrainUrl || defaultOptions.terrainUrl;
-    /**
-     * @type {import("@vcmap/cesium").CesiumTerrainProvider|null}
-     * @private
-     */
-    this._terrainProvider = this._terrainUrl ? getTerrainProviderForUrl({ url: this._terrainUrl }) : null;
-    /**
-     * The minimum height/distance to the terrain the camera must maintain
-     * @type {number}
-     * @api
-     */
-    this.limit = parseNumber(options.limit, defaultOptions.limit);
-    /**
-     * The level to request terrain data at
-     * @type {number|null}
-     * @api
-     */
-    this.level = options.level === null ? null : parseInteger(options.level, defaultOptions.level);
-    /**
-     * last checked camera position
-     * @type {import("@vcmap/cesium").Cartographic}
-     */
-    this.lastCheckedPosition = new Cartographic();
-    /**
-     * last updated terrain height
-     * @type {number|null}
-     * @private
-     */
-    this._terrainHeight = null;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    this._updatingTerrainHeight = false;
-  }
-
-  /**
-   * The url of the terrain to use. Required for mode DISTANCE
-   * @type {string|null}
-   * @api
-   */
-  get terrainUrl() {
-    return this._terrainUrl;
-  }
-
-  /**
-   * @param {string|null} url
-   */
-  set terrainUrl(url) {
-    checkMaybe(url, String);
-
-    if (this._terrainUrl !== url) {
-      this._terrainUrl = url;
-      this._terrainProvider = this._terrainUrl ? getTerrainProviderForUrl({ url: this._terrainUrl }) : null;
-    }
-  }
-
-  /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
-   * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
-   * @private
-   */
-  _limitWithLevel(cameraCartographic) {
-    if (isTerrainTileAvailable(this._terrainProvider, this.level, cameraCartographic)) {
-      return sampleCesiumTerrain(this._terrainProvider, this.level, [cameraCartographic]);
-    }
-    return this._limitMostDetailed(cameraCartographic);
-  }
-
-  /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
-   * @returns {Promise<Array<import("@vcmap/cesium").Cartographic>>}
-   * @private
-   */
-  _limitMostDetailed(cameraCartographic) {
-    return sampleCesiumTerrainMostDetailed(this._terrainProvider, [cameraCartographic]);
-  }
-
-  /**
-   * @param {import("@vcmap/cesium").Cartographic} cameraCartographic
-   * @returns {Promise<void>}
-   * @private
-   */
-  async _updateTerrainHeight(cameraCartographic) {
-    if (!this._updatingTerrainHeight &&
-      !cameraCartographic.equalsEpsilon(this.lastCheckedPosition, CesiumMath.EPSILON5)) {
-      this._updatingTerrainHeight = true;
-      const [updatedPosition] = this.level != null ?
-        await this._limitWithLevel(cameraCartographic.clone()) :
-        await this._limitMostDetailed(cameraCartographic.clone());
-      this._terrainHeight = updatedPosition.height;
-      this.lastCheckedPosition = cameraCartographic;
-      this._updatingTerrainHeight = false;
-    }
-  }
-
-  /**
-   * Limits the given camera based on this limiters specs.
-   * @param {import("@vcmap/cesium").Camera} camera
-   * @api
-   * @returns {Promise<void>}
-   */
-  limitCamera(camera) {
-    let promise = Promise.resolve();
-    const cameraCartographic = Cartographic.fromCartesian(camera.position);
-    if (cameraCartographic) {
-      if (this.mode === CameraLimiterMode.DISTANCE && this._terrainProvider) {
-        promise = this._updateTerrainHeight(cameraCartographic);
-        if (this._terrainHeight && (cameraCartographic.height - this._terrainHeight) < this.limit) {
-          const newHeight = this._terrainHeight + this.limit;
-          Cartographic.toCartesian(
-            new Cartographic(cameraCartographic.longitude, cameraCartographic.latitude, newHeight),
-            Ellipsoid.WGS84,
-            camera.position,
-          );
-        }
-      } else if (cameraCartographic.height < this.limit) {
-        Cartographic.toCartesian(
-          new Cartographic(cameraCartographic.longitude, cameraCartographic.latitude, this.limit),
-          Ellipsoid.WGS84,
-          camera.position,
-        );
-      }
-    }
-    return promise;
-  }
-
-  /**
-   * @returns {CameraLimiterOptions}
-   */
-  toJSON() {
-    const config = {};
-    const defaultOptions = CameraLimiter.getDefaultOptions();
-    if (this.terrainUrl) {
-      config.terrainUrl = this.terrainUrl;
-    }
-
-    if (this.limit !== defaultOptions.limit) {
-      config.limit = this.limit;
-    }
-
-    if (this.mode !== defaultOptions.mode) {
-      config.mode = this.mode;
-    }
-
-    if (this.level !== defaultOptions.level) {
-      config.level = this.level;
-    }
-    return config;
-  }
-}
-
-export default CameraLimiter;