@vcmap/core 5.0.0-rc.0

package/src/vcs/vcm/maps/openlayers.js

@@ -0,0 +1,205 @@
+import { Math as CesiumMath } from '@vcmap/cesium';
+import View from 'ol/View.js';
+import { getTransform } from 'ol/proj.js';
+import { inAndOut } from 'ol/easing.js';
+import { boundingExtent, containsXY } from 'ol/extent.js';
+import { parseBoolean } from '@vcsuite/parsers';
+import ViewPoint from '../util/viewpoint.js';
+import BaseOLMap from './baseOLMap.js';
+import VcsMap from './map.js';
+import { VcsClassRegistry } from '../classRegistry.js';
+
+/**
+ * @typedef {VcsMapOptions} OpenlayersOptions
+ * @property {boolean} [fixedNorthOrientation=true] -  sets whether the openlayers map has a fixed orientation towards north (default true)
+ * @api stable
+ */
+
+/**
+ * Openlayers Map Class (2D map)
+ * @class
+ * @export
+ * @extends {BaseOLMap}
+ * @api stable
+ */
+class Openlayers extends BaseOLMap {
+  /**
+   * @type {string}
+   */
+  static get className() { return 'vcs.vcm.maps.Openlayers'; }
+
+  /**
+   * @returns {OpenlayersOptions}
+   */
+  static getDefaultOptions() {
+    return {
+      ...VcsMap.getDefaultOptions(),
+      fixedNorthOrientation: true,
+    };
+  }
+
+  /**
+   * @param {OpenlayersOptions} options
+   */
+  constructor(options) {
+    super(options);
+
+    const defaultOptions = Openlayers.getDefaultOptions();
+
+    /** @type {boolean} */
+    this.fixedNorthOrientation = parseBoolean(options.fixedNorthOrientation, defaultOptions.fixedNorthOrientation);
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!this.initialized) {
+      await super.initialize();
+      this.olMap.setView(new View({
+        center: [1230922.6203948376, 6350766.117974091],
+        zoom: 13,
+      }));
+      this.initialized = true;
+    }
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {Promise<ViewPoint>}
+   */
+  async getViewPoint() {
+    return this.getViewPointSync();
+  }
+
+  /**
+   * @inheritDoc
+   * @returns {ViewPoint}
+   */
+  getViewPointSync() {
+    const view = this.olMap.getView();
+    const coord = view.getCenter();
+    const toLatLon = getTransform(view.getProjection(), 'EPSG:4326');
+    const fov = Math.PI / 3.0;
+    const viewport = this.olMap.getViewport();
+    const size = {};
+    size.height = viewport.offsetHeight || 1;
+    size.width = viewport.offsetWidth || 1;
+    const aspectRatio = size.width / size.height;
+    const fovy = Math.atan(Math.tan(fov * 0.5) / aspectRatio) * 2.0;
+    const latlon = toLatLon(coord.slice(0, 2));
+    const metersPerUnit = view.getProjection().getMetersPerUnit();
+
+    const resolution = view.getResolution();
+    const visibleMapUnits = resolution * size.height;
+    const relativeCircumference = Math.cos(Math.abs(CesiumMath.toRadians(latlon[1])));
+    const visibleMeters = visibleMapUnits * metersPerUnit * relativeCircumference;
+    const height = Math.abs((visibleMeters / 2) / Math.tan(fovy / 2));
+
+    const heading = -CesiumMath.toDegrees(view.getRotation());
+    // don't add 0;
+    const groundPosition = latlon; // .concat([0]);
+    const pitch = -90;
+    return new ViewPoint({
+      groundPosition,
+      pitch,
+      heading,
+      distance: height,
+    });
+  }
+
+  /**
+   * @param {ViewPoint} viewpoint
+   * @returns {Promise<void>}
+   * @inheritDoc
+   */
+  gotoViewPoint(viewpoint) {
+    if (this.movementDisabled || !viewpoint.isValid()) {
+      return Promise.resolve();
+    }
+    if (this.fixedNorthOrientation) {
+      viewpoint.heading = 0;
+    }
+    const view = this.olMap.getView();
+    const fromLatLon = getTransform('EPSG:4326', view.getProjection());
+    let coords = [];
+    if (viewpoint.groundPosition) {
+      coords = viewpoint.groundPosition.slice(0, 2);
+    } else {
+      coords = viewpoint.cameraPosition.slice(0, 2);
+    }
+    const { distance } = viewpoint;
+    const center = fromLatLon(coords);
+
+    const fov = Math.PI / 3.0;
+    const viewport = this.olMap.getViewport();
+    const size = {};
+    size.height = viewport.offsetHeight ? viewport.offsetHeight : 1;
+    size.width = viewport.offsetWidth ? viewport.offsetWidth : 1;
+    const aspectRatio = size.width / size.height;
+    const fovy = Math.atan(Math.tan(fov * 0.5) / aspectRatio) * 2.0;
+    const visibleMeters = 2 * distance * Math.tan(fovy / 2);
+    const metersPerUnit = view.getProjection().getMetersPerUnit();
+    const relativeCircumference = Math.cos(Math.abs(CesiumMath.toRadians(coords[1])));
+    const visibleMapUnits = visibleMeters / metersPerUnit / relativeCircumference;
+
+    const resolution = visibleMapUnits / size.height;
+
+    if (viewpoint.animate) {
+      let rotation = 0;
+      if (!this.fixedNorthOrientation && viewpoint.heading != null) {
+        rotation = -CesiumMath.toRadians(viewpoint.heading);
+      }
+      return new Promise((resolve) => {
+        view.animate({
+          duration: viewpoint.duration ? viewpoint.duration * 1000 : 100,
+          center,
+          easing: inAndOut, // XXX map to viewpoint easingFunctionName?
+          resolution,
+          rotation,
+        }, () => { resolve(); });
+      });
+    } else {
+      view.setCenter(center);
+      view.setResolution(resolution);
+      if (!this.fixedNorthOrientation && viewpoint.heading != null) {
+        view.setRotation(-CesiumMath.toRadians(viewpoint.heading));
+      }
+    }
+    return Promise.resolve();
+  }
+
+  /**
+   * @param {import("ol/coordinate").Coordinate} coords in WGS84 degrees
+   * @returns {boolean}
+   * @api
+   */
+  pointIsVisible(coords) {
+    const view = this.olMap.getView();
+    const extent = view.calculateExtent(this.olMap.getSize());
+    const toLatLon = getTransform(view.getProjection(), 'EPSG:4326');
+    const topLeft = [extent[0], extent[3]];
+    const bottomRight = [extent[2], extent[1]];
+    const bbox = [toLatLon(topLeft), toLatLon(bottomRight)];
+
+    return containsXY(boundingExtent(bbox), coords[0], coords[1]);
+  }
+
+  /**
+   * @returns {OpenlayersOptions}
+   * @api
+   */
+  getConfigObject() {
+    const config = /** @type {OpenlayersOptions} */ (super.getConfigObject());
+
+    const defaultOptions = Openlayers.getDefaultOptions();
+    if (this.fixedNorthOrientation !== defaultOptions.fixedNorthOrientation) {
+      config.fixedNorthOrientation = this.fixedNorthOrientation;
+    }
+
+    return config;
+  }
+}
+
+VcsClassRegistry.registerClass(Openlayers.className, Openlayers);
+export default Openlayers;

package/src/vcs/vcm/object.js

@@ -0,0 +1,92 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getLogger } from '@vcsuite/logger';
+
+/**
+ * @typedef {Object} VcsObjectOptions
+ * @property {string|undefined} [type] - the type of object, typically only used in configs
+ * @property {string|undefined} [name] - name of the object, if not given a uuid is generated, is used for the framework functions getObjectByName
+ * @property {Object|undefined} [properties] - key value store for framework independent values per Object
+ * @api
+ */
+
+/**
+ * baseclass for all Objects
+ * @class
+ * @api stable
+ */
+class VcsObject {
+  static get className() { return 'vcs.vcm.Framework'; }
+
+  /**
+   * @param {VcsObjectOptions} options
+   */
+  constructor(options) {
+    /**
+     * unique Name
+     * @type {string}
+     * @api
+     * @readonly
+     */
+    this.name = options.name || uuidv4();
+
+
+    /**
+     * @type {Object}
+     * @api
+     */
+    this.properties = options.properties || {};
+  }
+
+  /**
+   * @api
+   * @readonly
+   * @type {string}
+   */
+  get className() {
+    // @ts-ignore
+    return this.constructor.className;
+  }
+
+  /**
+   * @returns {import("@vcsuite/logger").Logger}
+   * @api
+   */
+  getLogger() {
+    return getLogger(this.className);
+  }
+
+  /**
+   * @returns {VcsObjectOptions}
+   * @api
+   */
+  getConfigObject() {
+    const config = {
+      type: this.className,
+      name: this.name,
+    };
+
+    if (Object.keys(this.properties).length > 0) {
+      config.properties = { ...this.properties };
+    }
+
+    return config;
+  }
+
+  /**
+   * @api
+   */
+  destroy() {
+    this.isDestroyed = true;
+    this.properties = {};
+  }
+
+  /**
+   * @deprecated v4.0
+   */
+  dispose() {
+    this.getLogger().deprecate('dispose', 'use destroy()');
+    this.destroy();
+  }
+}
+
+export default VcsObject;