@vcmap/core 5.0.0-rc.0

package/src/vcs/vcm/interaction/featureAtPixelInteraction.js

@@ -0,0 +1,286 @@
+import { Cartographic, Cartesian3, Math as CesiumMath, Cesium3DTileFeature, Cesium3DTilePointFeature } from '@vcmap/cesium';
+
+import AbstractInteraction from './abstractInteraction.js';
+import Projection from '../util/projection.js';
+import { EventType, ModificationKeyType } from './interactionType.js';
+import { vcsLayerName } from '../layer/layerSymbols.js';
+import { originalFeatureSymbol } from '../layer/vectorSymbols.js';
+
+/**
+ * @class
+ * @extends {AbstractInteraction}
+ */
+class FeatureAtPixelInteraction extends AbstractInteraction {
+  constructor() {
+    super();
+    /**
+     * @type {EventType|number}
+     * @private
+     */
+    this._pickPosition = EventType.CLICK;
+    /**
+     * @type {number}
+     * @private
+     */
+    this._pickPositionMask = -1;
+
+    /**
+     * whether to pick translucent depth or not, defaults to true
+     * @type {boolean}
+     * @api
+     */
+    this.pickTranslucent = true;
+
+    /**
+     * <i>Pulls</i> the picked position towards the camera position by this number
+     * @type {number}
+     * @default 0
+     * @api
+     */
+    this.pullPickedPosition = 0;
+
+    /**
+     * The number of pixels to take into account for picking features
+     * @type {number}
+     * @default 10
+     * @api
+     */
+    this.hitTolerance = 10;
+
+    /**
+     * @inheritDoc
+     * @type {ModificationKeyType|number}
+     * @protected
+     */
+    this._defaultModificationKey = ModificationKeyType.ALL;
+    /**
+     * @inheritDoc
+     * @type {ModificationKeyType|number}
+     * @protected
+     */
+    this._defaultActive = EventType.ALL ^ EventType.MOVE;
+
+    /**
+     * @type {import("ol").Feature<import("ol/geom/Geometry").default>|Object|null}
+     * @private
+     */
+    this._draggingFeature = null;
+    this.setActive();
+  }
+
+  /**
+   * Bitmask of {@link EventType} for which events to pick the position
+   * @type {number}
+   * @api
+   */
+  get pickPosition() { return this._pickPosition; }
+
+  /**
+   * @param {number} position
+   */
+  set pickPosition(position) {
+    this._pickPosition = position & this._pickPositionMask;
+  }
+
+  /**
+   * Bitmask of {@link EventType} for which to never pick positions.
+   * @type {number}
+   * @api
+   */
+  get excludedPickPositionEvents() { return ~this._pickPositionMask; }
+
+  /**
+   * @param {number} position
+   */
+  set excludedPickPositionEvents(position) {
+    this._pickPositionMask = ~position;
+  }
+
+  /**
+   * @inheritDoc
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   */
+  async pipe(event) {
+    if (event.type & EventType.DRAG && !(this._pickPosition & EventType.DRAG)) {
+      if (this._draggingFeature) {
+        event.feature = this._draggingFeature;
+      }
+      return event;
+    }
+
+    if (event.type & EventType.DRAGEND) {
+      this._draggingFeature = null;
+    }
+
+    if (event.map.className === 'vcs.vcm.maps.Openlayers') {
+      await this._openlayersHandler(event);
+    } else if (event.map.className === 'vcs.vcm.maps.Oblique') {
+      await this._obliqueHandler(event);
+    } else if (event.map.className === 'vcs.vcm.maps.Cesium') {
+      await this._cesiumHandler(event);
+    }
+    if (event.type & EventType.DRAGSTART && event.feature) {
+      this._draggingFeature = event.feature;
+    }
+
+    if (event.type & EventType.DRAG && this._draggingFeature) {
+      event.feature = this._draggingFeature;
+    }
+    return event;
+  }
+
+  /**
+   * @inheritDoc
+   * @param {(boolean|number)=} active
+   */
+  setActive(active) {
+    if (typeof active === 'undefined') {
+      this.pickPosition = EventType.CLICK;
+      this.pullPickedPosition = 0;
+    }
+    super.setActive(active);
+  }
+
+  /**
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   * @private
+   */
+  _openlayersHandler(event) {
+    /** @type {null|import("ol").Feature<import("ol/geom/Geometry").default>} */
+    let found = null;
+    /** @type {null|import("ol/layer/Layer").default} */
+    let foundLayer = null;
+    /** @type {import("@vcmap/core").Openlayers} */ (event.map).olMap
+      .forEachFeatureAtPixel([event.windowPosition.x, event.windowPosition.y], (feat, layer) => {
+        if (feat && (feat.get('olcs_allowPicking') == null || feat.get('olcs_allowPicking') === true)) {
+          found = /** @type {import("ol").Feature<import("ol/geom/Geometry").default>} */ (feat);
+          foundLayer = layer;
+        }
+        return true;
+      }, { hitTolerance: this.hitTolerance });
+    if (found && foundLayer) {
+      event.feature = found;
+      if (found.get('features')) {
+        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
+      }
+      event.exactPosition = true;
+    }
+    return Promise.resolve(event);
+  }
+
+  /**
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   * @private
+   */
+  _obliqueHandler(event) {
+    /** @type {null|import("ol").Feature<import("ol/geom/Geometry").default>} */
+    let found = null;
+    /** @type {null|import("ol/layer/Layer").default} */
+    let foundLayer = null;
+    /** @type {import("@vcmap/core").Oblique} */ (event.map).olMap
+      .forEachFeatureAtPixel([event.windowPosition.x, event.windowPosition.y], (feat, layer) => {
+        if (feat) {
+          found = feat[originalFeatureSymbol] || feat;
+        }
+        foundLayer = layer;
+        return true;
+      }, { hitTolerance: this.hitTolerance });
+
+    if (found && foundLayer) {
+      event.feature = found;
+      if (found.get('features')) {
+        event.feature[vcsLayerName] = foundLayer[vcsLayerName];
+      }
+      event.exactPosition = true;
+    }
+    return Promise.resolve(event);
+  }
+
+  /**
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   * @private
+   */
+  _cesiumHandler(event) {
+    const cesiumMap = /** @type {import("@vcmap/core").CesiumMap} */ (event.map);
+    const scene = cesiumMap.getScene();
+
+    const object = scene.pick(event.windowPosition, this.hitTolerance, this.hitTolerance);
+
+    let scratchCartographic = new Cartographic();
+    let scratchCartesian = new Cartesian3();
+    let scratchPullCartesian = new Cartesian3();
+    const { pickTranslucentDepth } = scene;
+
+    const handlePick = () => {
+      if (!scratchCartesian) {
+        scratchCartesian = new Cartesian3();
+        return Promise.resolve(event);
+      }
+      if (this.pullPickedPosition && event.ray) {
+        scratchPullCartesian = Cartesian3
+          .multiplyByScalar(event.ray.direction, this.pullPickedPosition, scratchPullCartesian);
+
+        scratchCartesian = Cartesian3.subtract(scratchCartesian, scratchPullCartesian, scratchCartesian);
+      }
+      scratchCartographic = Cartographic
+        .fromCartesian(scratchCartesian, scene.globe.ellipsoid, scratchCartographic);
+      event.position = Projection.wgs84ToMercator([
+        CesiumMath.toDegrees(scratchCartographic.longitude),
+        CesiumMath.toDegrees(scratchCartographic.latitude),
+        scratchCartographic.height,
+      ], true);
+      event.positionOrPixel = event.position;
+      scene.pickTranslucentDepth = pickTranslucentDepth;
+      return Promise.resolve(event);
+    };
+
+    if (object) {
+      if (object.primitive && object.primitive.olFeature) { // vector & vectorCluster
+        event.feature = object.primitive.olFeature;
+      } else if (
+        object.primitive &&
+        object.primitive[vcsLayerName] &&
+        (object instanceof Cesium3DTileFeature || object instanceof Cesium3DTilePointFeature)
+      ) { // building
+        event.feature = object;
+        const symbols = Object.getOwnPropertySymbols(object.primitive);
+        const symbolLength = symbols.length;
+        for (let i = 0; i < symbolLength; i++) {
+          event.feature[symbols[i]] = object.primitive[symbols[i]];
+        }
+      } else if (object.id && object.id.olFeature) { // cluster size === 1
+        event.feature = object.id.olFeature;
+      } else if (object.id && object.id[vcsLayerName]) { // entity
+        event.feature = object;
+        event.feature[vcsLayerName] = object.id[vcsLayerName];
+      } else {
+        event.feature = object;
+      }
+
+      if (!(event.type & this.pickPosition)) {
+        return Promise.resolve(event);
+      }
+
+      if (scene.pickPositionSupported) {
+        if (
+          object.primitive &&
+          this.pickTranslucent &&
+          !(object.primitive.pointCloudShading && object.primitive.pointCloudShading.attenuation)
+        ) { // XXX should this always be on, also for non vector?
+          scene.pickTranslucentDepth = true;
+          scene.render(cesiumMap.getCesiumWidget().clock.currentTime);
+          event.exactPosition = true;
+        }
+        scratchCartesian = scene.pickPosition(event.windowPosition, scratchCartesian);
+        return handlePick();
+      }
+    }
+    return Promise.resolve(event);
+  }
+}
+
+export default FeatureAtPixelInteraction;

package/src/vcs/vcm/interaction/featureProviderInteraction.js

@@ -0,0 +1,54 @@
+import AbstractInteraction from './abstractInteraction.js';
+import { EventType, ModificationKeyType } from './interactionType.js';
+
+/**
+ * @class
+ * @extends {AbstractInteraction}
+ */
+class FeatureProviderInteraction extends AbstractInteraction {
+  constructor() {
+    super();
+    /**
+     * @inheritDoc
+     * @type {ModificationKeyType|number}
+     * @protected
+     */
+    this._defaultModificationKey = ModificationKeyType.ALL;
+    /**
+     * @inheritDoc
+     * @type {ModificationKeyType|number}
+     * @protected
+     */
+    this._defaultActive = EventType.CLICK;
+    this.setActive();
+  }
+
+  /**
+   * @inheritDoc
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async pipe(event) {
+    if (!event.feature) {
+      const layersWithProvider = [...event.map.layerCollection]
+        .filter((l) => {
+          return l.featureProvider && l.active && l.isSupported(event.map) && l.featureProvider.isSupported(event.map);
+        });
+
+      if (layersWithProvider.length > 0) {
+        const resolution = event.map.getCurrentResolution(event.position);
+        const features = (await Promise
+          .all(layersWithProvider.map(l => l.featureProvider.getFeaturesByCoordinate(event.position, resolution))))
+          .flat();
+
+        if (features.length > 0) {
+          event.feature = features[0];
+        }
+      }
+    }
+    return event;
+  }
+}
+
+export default FeatureProviderInteraction;

package/src/vcs/vcm/interaction/interactionChain.js

@@ -0,0 +1,124 @@
+import AbstractInteraction from './abstractInteraction.js';
+import { EventType, ModificationKeyType, PointerKeyType } from './interactionType.js';
+
+/**
+ * @class
+ * @extends {AbstractInteraction}
+ * @export
+ */
+class InteractionChain extends AbstractInteraction {
+  /**
+   * @param {Array<AbstractInteraction>=} chain
+   */
+  constructor(chain) {
+    super();
+    /**
+     * The interactions to handle one after the other
+     * @type {Array<AbstractInteraction>}
+     * @api
+     */
+    this.chain = chain || [];
+    /**
+     * @inheritDoc
+     * @type {EventType}
+     * @protected
+     */
+    this._defaultActive = EventType.ALL;
+    /**
+     * @inheritDoc
+     * @type {ModificationKeyType}
+     * @protected
+     */
+    this._defaultModificationKey = ModificationKeyType.ALL;
+    /**
+     * @inheritDoc
+     * @type {PointerKeyType}
+     * @protected
+     */
+    this._defaultPointerKey = PointerKeyType.ALL;
+    this.setActive();
+  }
+
+  /**
+   * Add an interaction to the chain. Optionally passing an index where to add the interaction to.
+   * @param {AbstractInteraction} interaction
+   * @param {number=} index
+   * @api
+   */
+  addInteraction(interaction, index) {
+    if (index != null) {
+      this.chain.splice(index, 0, interaction);
+    } else {
+      this.chain.push(interaction);
+    }
+  }
+
+  /**
+   * Removes an interaction from the chain, returning the index from which it was removed
+   * @param {AbstractInteraction} interaction
+   * @returns {number}
+   * @api
+   */
+  removeInteraction(interaction) {
+    const index = this.chain.findIndex(candidate => candidate.id === interaction.id);
+    if (index > -1) {
+      this.chain.splice(index, 1);
+    }
+    return index;
+  }
+
+  /**
+   * @inheritDoc
+   * @param {InteractionEvent} event
+   * @returns {Promise<InteractionEvent>}
+   */
+  pipe(event) {
+    let promise = Promise.resolve(event);
+    const chainLength = this.chain.length;
+    for (let i = 0; i < chainLength; i++) {
+      const interaction = this.chain[i];
+      if (
+        (interaction.active & event.type) &&
+        (interaction.modificationKey & event.key) &&
+        (interaction.pointerKey & event.pointer)
+      ) {
+        // eslint-disable-next-line
+        promise = promise.then(function (pipedEvent) {
+          if (pipedEvent.stopPropagation) {
+            return Promise.resolve(pipedEvent);
+          }
+          return this.pipe(pipedEvent);
+        }.bind(interaction));
+      }
+    }
+    return promise;
+  }
+
+  /**
+   * You cannot set the modification of an interaction chain, only of its containing interactions
+   * @override
+   */
+  setModification() {
+    this.modificationKey = this._defaultModificationKey;
+  }
+
+  /**
+   * You cannot set the pointer of an interaction chain, only of its containing interactions
+   * @override
+   */
+  setPointer() {
+    this.pointerKey = this._defaultPointerKey;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  destroy() {
+    this.chain.forEach((i) => { i.destroy(); });
+    this.chain = [];
+    super.destroy();
+  }
+}
+
+export default InteractionChain;
+

package/src/vcs/vcm/interaction/interactionType.js

@@ -0,0 +1,114 @@
+let nextBit = 1;
+
+/**
+ * Provides inforamtion to other interaction plugins for creating bitmasks
+ * @class
+ * @export
+ */
+export class BitCounter {
+  /**
+   * @returns {number}
+   */
+  static get interactionTypeCounter() { return nextBit; }
+
+  static getNextBit(counter) {
+    return counter << 1;
+  }
+}
+
+/**
+ * Enumeration of modification key types
+ * @enum {number}
+ * @export
+ * @property {number} NONE
+ * @property {number} ALT
+ * @property {number} CTRL
+ * @property {number} SHIFT
+ * @property {number} ALL
+ * @api
+ */
+export const ModificationKeyType = {
+  NONE: nextBit = BitCounter.getNextBit(nextBit),
+  ALT: nextBit = BitCounter.getNextBit(nextBit),
+  CTRL: nextBit = BitCounter.getNextBit(nextBit),
+  SHIFT: nextBit = BitCounter.getNextBit(nextBit),
+  ALL: 0,
+};
+
+ModificationKeyType.ALL = ModificationKeyType.NONE |
+  ModificationKeyType.ALT |
+  ModificationKeyType.CTRL |
+  ModificationKeyType.SHIFT;
+
+/**
+ * Enumeration of pointer event types
+ * @enum {number}
+ * @property {number} NONE
+ * @property {number} CLICK
+ * @property {number} DBLCLICK
+ * @property {number} DRAG
+ * @property {number} DRAGSTART
+ * @property {number} DRAGEND
+ * @property {number} MOVE
+ * @property {number} DRAGEVENTS
+ * @property {number} CLICKMOVE
+ * @property {number} ALL
+ * @export
+ * @api
+ */
+export const EventType = {
+  NONE: 0,
+  CLICK: nextBit = BitCounter.getNextBit(nextBit),
+  DBLCLICK: nextBit = BitCounter.getNextBit(nextBit),
+  DRAG: nextBit = BitCounter.getNextBit(nextBit),
+  DRAGSTART: nextBit = BitCounter.getNextBit(nextBit),
+  DRAGEND: nextBit = BitCounter.getNextBit(nextBit),
+  MOVE: nextBit = BitCounter.getNextBit(nextBit),
+  DRAGEVENTS: 0,
+  CLICKMOVE: 0,
+  ALL: 0,
+};
+EventType.DRAGEVENTS = EventType.DRAG |
+  EventType.DRAGEND |
+  EventType.DRAGSTART;
+
+EventType.CLICKMOVE = EventType.CLICK |
+  EventType.MOVE;
+
+EventType.ALL = Object.values(EventType)
+  .reduce((val, mask) => val | mask, 0);
+
+/**
+ * Enumeration of pointer keys.
+ * @enum {number}
+ * @property {number} LEFT
+ * @property {number} RIGHT
+ * @property {number} MIDDLE
+ * @property {number} ALL
+ * @export
+ * @api
+ */
+export const PointerKeyType = {
+  LEFT: nextBit = BitCounter.getNextBit(nextBit),
+  RIGHT: nextBit = BitCounter.getNextBit(nextBit),
+  MIDDLE: nextBit = BitCounter.getNextBit(nextBit),
+  ALL: 0,
+};
+
+PointerKeyType.ALL = PointerKeyType.LEFT |
+  PointerKeyType.RIGHT |
+  PointerKeyType.MIDDLE;
+
+/**
+ * Enumeration of pointer key events.
+ * @enum {number}
+ * @property {number} DOWN
+ * @property {number} UP
+ * @property {number} MOVE
+ */
+export const PointerEventType = {
+  DOWN: 1,
+  UP: 2,
+  MOVE: 3,
+};
+

package/src/vcs/vcm/layer/buildings.js

@@ -0,0 +1,17 @@
+import { VcsClassRegistry } from '../classRegistry.js';
+import CesiumTileset from './cesiumTileset.js';
+
+/**
+ * represents a specific Building layer for cesium.
+ * @class
+ * @export
+ * @extends {CesiumTileset}
+ * @api stable
+ */
+class Buildings extends CesiumTileset {
+  /** @type {string} */
+  static get className() { return 'vcs.vcm.layer.Buildings'; }
+}
+
+VcsClassRegistry.registerClass(Buildings.className, Buildings);
+export default Buildings;