@vcmap/core 5.0.0-rc.3 → 5.0.0-rc.31

package/src/vcs/vcm/util/math.js

@@ -1,71 +0,0 @@
-import { Math as CesiumMath, Cartesian3 } from '@vcmap/cesium';
-
-/**
- * returns a new coordinate ([lon, lat] in degrees) from a distance, bearing and starting coordinate
- * @param {Array.<number>} coord [lon, lat] in degrees
- * @param {number} d distance in m to new coordinate
- * @param {number} brng bearing in degrees ( 0 == north, 90° == east)
- * @returns {Array.<number>};
- */
-export function coordinateAtDistance(coord, d, brng) {
-  const R = 6371000;
-  const brngRadians = CesiumMath.toRadians(brng);
-  const lat1 = CesiumMath.toRadians(coord[1]);
-  const lon1 = CesiumMath.toRadians(coord[0]);
-  const lat2 = Math.asin((Math.sin(lat1) * Math.cos(d / R)) +
-    (Math.cos(lat1) * Math.sin(d / R) * Math.cos(brngRadians)));
-  const lon2 = lon1 + Math.atan2(
-    Math.sin(brngRadians) * Math.sin(d / R) * Math.cos(lat1),
-    Math.cos(d / R) - (Math.sin(lat1) * Math.sin(lat2)),
-  );
-  return [parseFloat(CesiumMath.toDegrees(lon2).toFixed(5)), parseFloat(CesiumMath.toDegrees(lat2).toFixed(5))];
-}
-
-
-/**
- * returns the initial bearing in degrees (0-360) between two coordinates
- * @param {Array.<number>} coords1 [lon, lat] in degrees
- * @param {Array.<number>} coords2 [lon, lat] in degrees
- * @returns {number};
- */
-export function initialBearingBetweenCoords(coords1, coords2) {
-  // long
-  const l1 = CesiumMath.toRadians(coords1[0]);
-  // lat
-  const f1 = CesiumMath.toRadians(coords1[1]);
-  // long
-  const l2 = CesiumMath.toRadians(coords2[0]);
-  // lat
-  const f2 = CesiumMath.toRadians(coords2[1]);
-
-  const y = Math.sin(l2 - l1) * Math.cos(f2);
-  const x = (Math.cos(f1) * Math.sin(f2)) - (Math.sin(f1) * Math.cos(f2) * Math.cos(l2 - l1));
-  let brng = CesiumMath.toDegrees(Math.atan2(y, x));
-  brng = (brng + 360) % 360;
-  return brng;
-}
-
-
-/**
- * returns distance between two coordinates
- * @param {import("ol/coordinate").Coordinate} point0
- * @param {import("ol/coordinate").Coordinate} point1
- * @returns {number}
- */
-export function cartesian2DDistance(point0, point1) {
-  const distX = point0[0] - point1[0];
-  const distY = point0[1] - point1[1];
-  return Math.sqrt((distX ** 2) + (distY ** 2));
-}
-
-/**
- * @param {import("ol/coordinate").Coordinate} p1
- * @param {import("ol/coordinate").Coordinate} p2
- * @returns {number}
- */
-export function cartesian3DDistance(p1, p2) {
-  const point0 = Cartesian3.fromElements(p1[0], p1[1], p1[2]);
-  const point1 = Cartesian3.fromElements(p2[0], p2[1], p2[2]);
-  return Cartesian3.distance(point0, point1);
-}
-

package/src/vcs/vcm/util/splitScreen.js

@@ -1,233 +0,0 @@
-import {
-  Cartesian3,
-  Matrix4,
-  Plane,
-  ClippingPlane,
-  ClippingPlaneCollection,
-  ImagerySplitDirection,
-} from '@vcmap/cesium';
-
-import { check } from '@vcsuite/check';
-import CesiumMap from '../maps/cesium.js';
-import ClippingObject from './clipping/clippingObject.js';
-import Openlayers from '../maps/openlayers.js';
-
-/**
- * @class
- * @api
- */
-class SplitScreen {
-  /**
-   * @param {import("@vcmap/core").ClippingObjectManager} clippingObjectManager
-   */
-  constructor(clippingObjectManager) {
-    /**
-     * @type {number}
-     * @private
-     */
-    this._position = 0.5;
-    /**
-     * @type {import("@vcmap/cesium").Scene|null}
-     */
-    this.scene = null;
-    /**
-     * @type {import("ol/Map").default|null}
-     */
-    this.olMap = null;
-    /**
-     * @type {boolean}
-     * @api
-     */
-    this.initialized = false;
-    /**
-     * @type {ClippingObject}
-     */
-    this.leftScreenClippingObject = new ClippingObject();
-    /**
-     * @type {ClippingObject}
-     */
-    this.rightScreenClippingObject = new ClippingObject();
-    /**
-     * @type {Function|null}
-     * @private
-     */
-    this._cameraListener = null;
-    /**
-     * @type {number|null}
-     */
-    this.originalCameraPercentageChanged = null;
-    /**
-     * @type {Array<Function>}
-     * @private
-     */
-    this._targetsChangedListeners = [];
-
-    this._targetsChangedListeners = [
-      this.rightScreenClippingObject.targetsUpdated.addEventListener(() => { this._targetsChanged(); }),
-      this.leftScreenClippingObject.targetsUpdated.addEventListener(() => { this._targetsChanged(); }),
-    ];
-
-    /**
-     * @type {import("@vcmap/core").ClippingObjectManager}
-     * @private
-     */
-    this._clippingObjectManager = clippingObjectManager;
-    this._clippingObjectManager.addClippingObject(this.rightScreenClippingObject);
-    this._clippingObjectManager.addClippingObject(this.leftScreenClippingObject);
-  }
-
-  /**
-   * @type {number}
-   * @api
-   */
-  get position() { return this._position; }
-
-  /**
-   * @param {number} position
-   */
-  set position(position) {
-    check(position, Number);
-    if (position < 0 || position > 1) {
-      throw new Error('Position must be between 0 and 1');
-    }
-
-    if (Math.abs(this._position - position) > 0.0001) {
-      this._updatePosition(position);
-    }
-  }
-
-  _targetsChanged() {
-    if (this.scene) {
-      const numTargets = this.rightScreenClippingObject.targets.size + this.leftScreenClippingObject.targets.size;
-      const { camera } = this.scene;
-
-      if (this._cameraListener && numTargets === 0) {
-        this._cameraListener();
-        this._cameraListener = null;
-        camera.percentageChanged = this.originalCameraPercentageChanged;
-      } else if (!this._cameraListener && numTargets > 0) {
-        this.originalCameraPercentageChanged = camera.percentageChanged;
-        camera.percentageChanged = 0;
-        this._cameraListener = camera.changed.addEventListener(this._updateClippingPlanes.bind(this));
-        this._updateClippingPlanes();
-      }
-    }
-  }
-
-  /**
-   * @param {number} position
-   * @private
-   */
-  _updatePosition(position) {
-    this._position = position;
-    if (this.scene) {
-      this.scene.imagerySplitPosition = position;
-      this._updateClippingPlanes();
-    } else if (this.olMap) {
-      this.olMap.render();
-    }
-  }
-
-  /**
-   * @param {import("@vcmap/core").VcsMap} map
-   */
-  mapActivated(map) {
-    if (map instanceof CesiumMap) {
-      this.scene = map.getScene();
-      this.olMap = null;
-      this._targetsChanged();
-    } else if (map instanceof Openlayers) {
-      this.scene = null;
-      this.olMap = map.olMap;
-    }
-    this._updatePosition(this.position);
-  }
-
-  /**
-   * calculate a clipping plane from the current swipe position for the given Cesium3DTileset
-   * @returns {import("@vcmap/cesium").ClippingPlane}
-   * @private
-   */
-  _calcClippingPlane() {
-    const { camera } = this.scene;
-    const { fov, near } = /** @type {import("@vcmap/cesium").PerspectiveFrustum} */ (camera.frustum);
-    const screenWidth = this.scene.canvas.width || 1;
-    const screenHeight = this.scene.canvas.height || 1;
-    let pixelSize;
-    if (screenHeight > screenWidth) {
-      pixelSize = (near * Math.tan(0.5 * fov) * 2.0) / screenHeight;
-    } else {
-      pixelSize = (near * Math.tan(0.5 * fov) * 2.0) / screenWidth;
-    }
-
-    // extract 3 points lying on swipe plane
-    const screenX = (screenWidth * this.position) - (screenWidth / 2);
-    const screenY = screenHeight / 2;
-    const p1 = new Cartesian3(pixelSize * screenX, pixelSize * screenY, -1 * near);
-    const p2 = new Cartesian3(pixelSize * screenX, -1 * pixelSize * screenY, -1 * near);
-    Matrix4.multiplyByPoint(camera.inverseViewMatrix, p1, p1);
-    Matrix4.multiplyByPoint(camera.inverseViewMatrix, p2, p2);
-    const p3WC = camera.positionWC;
-
-    Cartesian3.subtract(p3WC, p1, p1);
-    Cartesian3.subtract(p3WC, p2, p2);
-    const normal = Cartesian3.cross(p1, p2, new Cartesian3());
-    Cartesian3.normalize(normal, normal);
-    const planeInFixedFrame = Plane.fromPointNormal(p3WC, normal);
-
-    return ClippingPlane.fromPlane(planeInFixedFrame);
-  }
-
-  /**
-   * update the clipping planes for all Cesium3DTilesets loaded in the vcMap
-   * @private
-   */
-  _updateClippingPlanes() {
-    const plane = this._calcClippingPlane();
-    this.leftScreenClippingObject.clippingPlaneCollection = new ClippingPlaneCollection({ planes: [plane] });
-    const revClippingPlane = ClippingPlane.clone(plane);
-    revClippingPlane.normal = Cartesian3.negate(revClippingPlane.normal, revClippingPlane.normal);
-    revClippingPlane.distance *= -1;
-    this.rightScreenClippingObject.clippingPlaneCollection =
-      new ClippingPlaneCollection({ planes: [revClippingPlane] });
-  }
-
-  /**
-   * Gets the clipping object for a split direction
-   * @param {import("@vcmap/cesium").ImagerySplitDirection} splitDirection
-   * @returns {ClippingObject|null}
-   * @api
-   */
-  getClippingObjectForDirection(splitDirection) {
-    check(splitDirection, [
-      ImagerySplitDirection.LEFT,
-      ImagerySplitDirection.RIGHT,
-      ImagerySplitDirection.NONE,
-    ]);
-
-    if (splitDirection === ImagerySplitDirection.LEFT) {
-      return this.leftScreenClippingObject;
-    }
-    if (splitDirection === ImagerySplitDirection.RIGHT) {
-      return this.rightScreenClippingObject;
-    }
-
-    return null;
-  }
-
-  destroy() {
-    if (this._clippingObjectManager) {
-      this._clippingObjectManager.removeClippingObject(this.rightScreenClippingObject);
-      this._clippingObjectManager.removeClippingObject(this.leftScreenClippingObject);
-    }
-    this._targetsChangedListeners.forEach((cb) => { cb(); });
-    this._targetsChangedListeners = [];
-    this._clippingObjectManager = null;
-    if (this._cameraListener) {
-      this._cameraListener();
-      this._cameraListener = null;
-    }
-  }
-}
-
-export default SplitScreen;

package/src/vcs/vcm/util/style/styleFactory.js

@@ -1,48 +0,0 @@
-import { getLogger as getLoggerByName } from '@vcsuite/logger';
-import StyleItem, { StyleType } from './styleItem.js';
-import DeclarativeStyleItem, { defaultDeclarativeStyle } from './declarativeStyleItem.js';
-import VectorStyleItem from './vectorStyleItem.js';
-import { styleCollection } from '../../globalCollections.js';
-
-/**
- * @returns {import("@vcsuite/logger").Logger}
- */
-function getLogger() {
-  return getLoggerByName('vcs.vcm.util.style.styleFactory');
-}
-
-/**
- * @param {(Reference|DeclarativeStyleItemOptions|VectorStyleItemOptions|StyleItem|string)=} styleOptions
- * @param {(VectorStyleItem|DeclarativeStyleItem)=} defaultStyle
- * @returns {StyleItem}
- */
-// eslint-disable-next-line import/prefer-default-export
-export function getStyleOrDefaultStyle(styleOptions, defaultStyle) {
-  if (typeof styleOptions === 'string') {
-    const styleItem = styleCollection.getByKey(styleOptions);
-    if (styleItem) {
-      return styleItem;
-    }
-    getLogger().warning(`could not find style with name ${styleOptions}`);
-  } else if (styleOptions && (styleOptions instanceof StyleItem)) {
-    return styleOptions;
-  } else if (styleOptions) { // DeclarativeStyleItemOptions || VectorStyleItemOptions || ClusterStyleItemOptions
-    if (
-      /** @type {DeclarativeStyleItemOptions} */ (styleOptions).type === StyleType.DECLARATIVE ||
-      /** @type {DeclarativeStyleItemOptions} */ (styleOptions).declarativeStyle) {
-      return new DeclarativeStyleItem(/** @type {DeclarativeStyleItemOptions} */ (styleOptions));
-    } else if (/** @type {Reference} */ (styleOptions).type === StyleType.REFERENCE) {
-      const { name } = /** @type {Reference} */ (styleOptions);
-      const styleItem = styleCollection.getByKey(name);
-      if (styleItem) {
-        return styleItem;
-      }
-      getLogger().warning(`could not find style with name ${name}`);
-    } else {
-      // @ts-ignore
-      const vectorStyle = new VectorStyleItem(/** @type {VectorStyleItemOptions} */ styleOptions);
-      return defaultStyle instanceof VectorStyleItem ? defaultStyle.assign(vectorStyle) : vectorStyle;
-    }
-  }
-  return defaultStyle || defaultDeclarativeStyle.clone();
-}

package/src/vcs/vcm/util/style/styleItem.js

@@ -1,243 +0,0 @@
-import { Cesium3DTileStyle, Cesium3DTileColorBlendMode } from '@vcmap/cesium';
-import deepEqual from 'fast-deep-equal';
-
-import { parseEnumValue } from '@vcsuite/parsers';
-import VcsObject from '../../object.js';
-import VcsEvent from '../../event/vcsEvent.js';
-
-/**
- * @namespace style
- * @export
- * @api
- */
-
-/**
- * @typedef {Object} StyleItemLegendEntry
- * @property {string} color - the color to display
- * @property {string|Object<string, string>} name - the name to display for the given color
- * @api
- */
-
-/**
- * @typedef {VcsObjectOptions} StyleItemOptions
- * @property {string|undefined} [type] - used in configuration to differentiate vector from declarative styles
- * @property {string|Object<string, string>|undefined} title - name is used when none is specifies
- * @property {Array<StyleItemLegendEntry>|undefined} [legend]
- * @property {number} [colorBlendMode=import("@vcmap/cesium").Cesium3DTileColorBlendMode.HIGHLIGHT] - colorBlendMode for 3D Tiledataset @see https://cesiumjs.org/import("@vcmap/cesium").Build/Documentation/Cesium3DTileColorBlendMode.html
- * @api
- */
-
-/**
- * @typedef {Object} Reference
- * @property {string} [type=StyleType.REFERENCE]
- * @property {string} name
- * @property {string|undefined} [url] - vcs:undocumented this is not yet implemented
- * @api
- */
-
-/**
- * @typedef {Object} StyleItemSections
- * @property {boolean|undefined} [meta]
- * @api
- */
-
-/**
- * Enumeration of possible style types.
- * @enum {string}
- * @property {string} VECTOR
- * @property {string} DECLARATIVE
- * @property {string} REFERENCE
- * @export
- * @api
- */
-export const StyleType = {
-  VECTOR: 'vector',
-  DECLARATIVE: 'declarative',
-  REFERENCE: 'reference',
-  CLUSTER: 'cluster',
-};
-
-/**
- * indicates, that this style is part of the config and can be referenced by name
- * @type {symbol}
- * @export
- * @api
- */
-export const referenceableStyleSymbol = Symbol('referencableStyleSymbol');
-
-/**
- * An abstract style definition which can be applied to a layer
- * @class
- * @export
- * @api
- * @abstract
- * @extends {VcsObject}
- */
-class StyleItem extends VcsObject {
-  static get className() { return 'vcs.vcm.util.style.StyleItem'; }
-
-  /**
-   * @param {StyleItemOptions} options
-   */
-  constructor(options) {
-    super(options);
-
-    /**
-     * @type {string|Object<string, string>}
-     */
-    this.title = options.title || this.name.toString();
-
-    /**
-     * Legend entries
-     * @type {Array<StyleItemLegendEntry>}
-     * @api
-     */
-    this.legend = options.legend || [];
-
-    /** @type {Array<string>} */
-    this.supportedLayers = [];
-
-    /**
-     * The 3D representation of this style
-     * @type {import("@vcmap/cesium").Cesium3DTileStyle}
-     * @api
-     */
-    this.cesiumStyle = new Cesium3DTileStyle({ show: true });
-
-    /**
-     * Fired on style updates
-     * @type {VcsEvent<void>}
-     * @api
-     */
-    this.styleChanged = new VcsEvent();
-
-    /** @type {import("@vcmap/cesium").Cesium3DTileColorBlendMode} */
-    this.colorBlendMode = /** @type {import("@vcmap/cesium").Cesium3DTileColorBlendMode} */(parseEnumValue(
-      options.colorBlendMode, Cesium3DTileColorBlendMode, Cesium3DTileColorBlendMode.HIGHLIGHT,
-    ));
-
-    /**
-     * @type {import("ol/style/Style").default|import("ol/style/Style").StyleFunction}
-     * @protected
-     */
-    this._style = null;
-  }
-
-  /**
-   * The 2D representation of this style
-   * @type {import("ol/style/Style").default|import("ol/style/Style").StyleFunction}
-   * @api
-   */
-  get style() { return this._style; }
-
-  /**
-   * @param {import("ol/style/Style").default|import("ol/style/Style").StyleFunction} style
-   */
-  set style(style) { this._style = style; }
-
-  /**
-   * @param {string} className
-   * @returns {boolean}
-   * @todo redundant, remove
-   */
-  isSupported(className) {
-    return this.supportedLayers.length === 0 ||
-      this.supportedLayers.indexOf(className) > -1;
-  }
-
-  /**
-   * Gets the options for this style item to be used in a config or vcsMeta
-   * @param {(VectorStyleItemSections|DeclarativeStyleItemSections)=} sections
-   * @returns {VectorStyleItemOptions|DeclarativeStyleItemOptions}
-   * @api
-   */
-  getOptions(sections) {
-    if (sections && sections.meta) {
-      return {
-        name: this.name.toString(),
-        title: this.title,
-        legend: this.legend.length ? this.legend : undefined,
-      };
-    }
-    return {};
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {StyleItemOptions}
-   */
-  toJSON() {
-    const config = { ...super.toJSON(), ...this.getOptions() };
-    if (this.title) {
-      config.title = this.title;
-    }
-
-    if (this.legend.length > 0) {
-      config.legend = this.legend.slice();
-    }
-
-    return config;
-  }
-
-  /**
-   * Clones this style
-   * @param {StyleItem=} result
-   * @returns {StyleItem}
-   * @api
-   */
-  // eslint-disable-next-line class-methods-use-this
-  clone(result) { return result; }
-
-  /**
-   * @param {StyleItem} styleItem
-   * @returns {StyleItem}
-   * @api
-   */
-  // eslint-disable-next-line class-methods-use-this
-  assign(styleItem) { return styleItem; }
-
-  /**
-   * @param {StyleItem} styleItem
-   * @returns {boolean}
-   * @api
-   */
-  equals(styleItem) {
-    if (this !== styleItem) {
-      const options = this.getOptions();
-      const candidateOptions = styleItem.getOptions();
-      return deepEqual(options, candidateOptions);
-    }
-
-    return true;
-  }
-
-  /**
-   * gets a reference to this style by its name. should only be used for static styles, aka styles already part of the config
-   * @returns {Reference}
-   * @api
-   */
-  getReference() {
-    return {
-      type: StyleType.REFERENCE,
-      name: this.name.toString(),
-    };
-  }
-
-  /**
-   * @protected
-   */
-  _styleChanged() {
-    this.styleChanged.raiseEvent();
-  }
-
-  /**
-   * @api
-   */
-  destroy() {
-    this.cesiumStyle = null;
-    this.styleChanged.destroy();
-    super.destroy();
-  }
-}
-
-export default StyleItem;