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

package/src/{vcs/vcm/oblique → oblique}/parseImageJson.js

@@ -1,7 +1,7 @@
-import { Matrix3, Cartesian3, Matrix4 } from '@vcmap/cesium';
-import ObliqueImage from './ObliqueImage.js';
-import { obliqueViewDirectionNames } from './ObliqueViewDirection.js';
-import ImageMeta from './ObliqueImageMeta.js';
+import { Matrix3, Cartesian3, Matrix4 } from '@vcmap-cesium/engine';
+import ObliqueImage from './obliqueImage.js';
+import { obliqueViewDirectionNames } from './obliqueViewDirection.js';
+import ImageMeta from './obliqueImageMeta.js';
 import Projection from '../util/projection.js';
 
 let customObliqueProjectionId = 0;
@@ -41,16 +41,22 @@ export function getVersionFromImageJson(json) {
  * @param {ObliqueImageJson} json
  * @param {string} url
  * @param {import("@vcmap/core").Projection=} projection
- * @param {import("@vcmap/cesium").CesiumTerrainProvider=} terrainProvider
+ * @param {import("@vcmap-cesium/engine").CesiumTerrainProvider=} terrainProvider
  * @returns {Array<import("@vcmap/core").ObliqueImageMeta>}
  */
 export function parseImageMeta(json, url, projection, terrainProvider) {
   let size;
   if (json.generalImageInfo.width && json.generalImageInfo.height) {
-    size = /** @type {import("ol/size").Size} */ ([json.generalImageInfo.width, json.generalImageInfo.height]);
+    size = /** @type {import("ol/size").Size} */ ([
+      json.generalImageInfo.width,
+      json.generalImageInfo.height,
+    ]);
   }
   const tileResolution = json.generalImageInfo['tile-resolution'];
-  const tileSize = /** @type {import("ol/size").Size} */ ([json.generalImageInfo['tile-width'], json.generalImageInfo['tile-height']]);
+  const tileSize = /** @type {import("ol/size").Size} */ ([
+    json.generalImageInfo['tile-width'],
+    json.generalImageInfo['tile-height'],
+  ]);
   let imageProjection = projection;
   const imageMetas = [];
   if (!imageProjection && json.generalImageInfo.crs) {
@@ -76,9 +82,13 @@ export function parseImageMeta(json, url, projection, terrainProvider) {
         imageMetas.push(new ImageMeta({ ...defaultOptions, ...cameraOption }));
       });
     } else if (typeof json.generalImageInfo.cameraParameter === 'object') {
-      Object.entries(json.generalImageInfo.cameraParameter).forEach(([name, cameraOption]) => {
-        imageMetas.push(new ImageMeta({ name, ...defaultOptions, ...cameraOption }));
-      });
+      Object.entries(json.generalImageInfo.cameraParameter).forEach(
+        ([name, cameraOption]) => {
+          imageMetas.push(
+            new ImageMeta({ name, ...defaultOptions, ...cameraOption }),
+          );
+        },
+      );
     }
   }
 
@@ -112,7 +122,8 @@ export function parseImageData(json, imageMetas) {
 
   const images = new Array(json.images.length - 1);
   json.images.forEach((img, index) => {
-    if (index === 0) { // skip header image
+    if (index === 0) {
+      // skip header image
       return;
     }
     const coordsArrayPToRealworld = [];
@@ -121,7 +132,9 @@ export function parseImageData(json, imageMetas) {
         coordsArrayPToRealworld.push(...value);
       });
     }
-    const pToRealworld = img[indices.pToRealworld] ? new Matrix3(...coordsArrayPToRealworld) : null;
+    const pToRealworld = img[indices.pToRealworld]
+      ? new Matrix3(...coordsArrayPToRealworld)
+      : null;
 
     const coordsArrayPToImage = [];
     if (img[indices.pToImage]) {
@@ -130,10 +143,12 @@ export function parseImageData(json, imageMetas) {
       });
       coordsArrayPToImage.push(0, 0, 0, 1);
     }
-    const projectionCenter = img[indices.projectionCenter] ?
-      Cartesian3.fromArray(img[indices.projectionCenter]) :
-      null;
-    const pToImage = img[indices.pToImage] ? new Matrix4(...coordsArrayPToImage) : null;
+    const projectionCenter = img[indices.projectionCenter]
+      ? Cartesian3.fromArray(img[indices.projectionCenter])
+      : null;
+    const pToImage = img[indices.pToImage]
+      ? new Matrix4(...coordsArrayPToImage)
+      : null;
 
     const meta = imageMetas[img[indices.cameraIndex] || 0];
     if (!meta.size) {
@@ -180,14 +195,15 @@ export function parseLegacyImageData(json, imageMetas) {
   const { version, buildNumber } = getVersionFromImageJson(json);
   return /** @type {Array<*>} */ (json.images).map((img) => {
     const viewDirection = obliqueViewDirectionNames[img['view-direction']];
-    const viewDirectionAngle = version >= 3.4 && buildNumber >= 18 ?
-      img['view-directionAngle'] :
-      undefined;
+    const viewDirectionAngle =
+      version >= 3.4 && buildNumber >= 18
+        ? img['view-directionAngle']
+        : undefined;
     const projectionCenter = img['projection-center'];
     const { name, groundCoordinates, centerPointOnGround } = img;
 
     const cameraName = img['camera-name'];
-    const imageMeta = imageMetas.find(value => value.name === cameraName);
+    const imageMeta = imageMetas.find((value) => value.name === cameraName);
     const meta = imageMeta || imageMetas[0];
     if (!meta.size) {
       if (img.height && img.width) {
@@ -218,13 +234,28 @@ export function parseLegacyImageData(json, imageMetas) {
 
     if (imageMeta && cameraName) {
       const cameraOptions = cameraParameter[cameraName];
-      const cameraMatrix = Matrix3.fromRowMajorArray([].concat(...cameraOptions['camera-matrix']));
+      const cameraMatrix = Matrix3.fromRowMajorArray(
+        [].concat(...cameraOptions['camera-matrix']),
+      );
       const cameraMatrixInverse = Matrix3.inverse(cameraMatrix, new Matrix3());
-      const rotationMatrix = Matrix3.fromRowMajorArray([].concat(...img['rotation-matrix']));
-      const rotationMatrixTransposed = Matrix3.transpose(rotationMatrix, new Matrix3());
-      const focalLength = cameraOptions['focal-length'] * (-1);
-      Matrix3.multiplyByScalar(cameraMatrixInverse, focalLength, cameraMatrixInverse);
-      const pToRealworld = Matrix3.multiply(rotationMatrixTransposed, cameraMatrixInverse, new Matrix3());
+      const rotationMatrix = Matrix3.fromRowMajorArray(
+        [].concat(...img['rotation-matrix']),
+      );
+      const rotationMatrixTransposed = Matrix3.transpose(
+        rotationMatrix,
+        new Matrix3(),
+      );
+      const focalLength = cameraOptions['focal-length'] * -1;
+      Matrix3.multiplyByScalar(
+        cameraMatrixInverse,
+        focalLength,
+        cameraMatrixInverse,
+      );
+      const pToRealworld = Matrix3.multiply(
+        rotationMatrixTransposed,
+        cameraMatrixInverse,
+        new Matrix3(),
+      );
 
       const cameraMatrix4 = Matrix4.fromRotationTranslation(
         cameraMatrix,
@@ -233,7 +264,11 @@ export function parseLegacyImageData(json, imageMetas) {
       );
       const projectionCenterCartesian = Cartesian3.fromArray(projectionCenter);
       const e = Matrix4.fromTranslation(
-        Cartesian3.multiplyByScalar(projectionCenterCartesian, -1, new Cartesian3()),
+        Cartesian3.multiplyByScalar(
+          projectionCenterCartesian,
+          -1,
+          new Cartesian3(),
+        ),
         new Matrix4(),
       );
       const rotationMatrix4 = Matrix4.fromRotationTranslation(
@@ -253,4 +288,3 @@ export function parseLegacyImageData(json, imageMetas) {
     return new ObliqueImage(imageOptions);
   });
 }
-

package/src/ol/feature.js

@@ -1,4 +1,10 @@
 import Feature from 'ol/Feature.js';
+import { Style } from 'ol/style.js';
+import {
+  globalHidden,
+  hidden,
+  highlighted,
+} from '../layer/featureVisibility.js';
 
 /**
  * To be used for cesium 3D style functions
@@ -39,9 +45,36 @@ Feature.prototype.getProperty = function getProperty(property) {
  * @param {string} property
  * @returns {*}
  */
-Feature.prototype.getPropertyInherited = function getPropertyInherited(property) {
+Feature.prototype.getPropertyInherited = function getPropertyInherited(
+  property,
+) {
   return this.getProperty(property);
 };
 
+const originalStyleFunction = Feature.prototype.getStyleFunction;
+Feature.prototype.getStyleFunction = function getStyleFunction() {
+  if (this[hidden] || this[globalHidden]) {
+    return () => [];
+  }
+
+  if (this[highlighted]) {
+    return () => [this[highlighted].style];
+  }
+  return originalStyleFunction.bind(this)();
+};
+
+const originalGetStyle = Feature.prototype.getStyle;
+Feature.prototype.getStyle = function getStyle() {
+  if (this[hidden] || this[globalHidden]) {
+    return new Style({});
+  }
+
+  if (this[highlighted]) {
+    return this[highlighted].style;
+  }
+
+  return originalGetStyle.bind(this)();
+};
+
 // TODO implement getExactClassName, isClass & isExactClass
 // TODO implement feature.content.tileset.timeSinceLoad

package/src/ol/geom/circle.js

@@ -1,6 +1,6 @@
 import Circle from 'ol/geom/Circle.js';
 import { check } from '@vcsuite/check';
-import { cartesian2DDistance, cartesian3DDistance } from '../../vcs/vcm/util/math.js';
+import { cartesian2DDistance, cartesian3DDistance } from '../../util/math.js';
 
 /**
  * @returns {Array<import("ol/coordinate").Coordinate>} returns an Array where the first coordinate is the center, and the second the center with an x offset of radius
@@ -12,13 +12,22 @@ Circle.prototype.getCoordinates = function getCoordinates() {
 
 /**
  * @param {Array<import("ol/coordinate").Coordinate>} coordinates - array of length two. The first coordinate is treated as the center, the second as the center with an x offset of radius
- * @param {import("ol/geom/GeometryLayout").default=} optLayout
+ * @param {import("ol/geom/Geometry").GeometryLayout=} optLayout
  */
-Circle.prototype.setCoordinates = function setCoordinates(coordinates, optLayout) {
+Circle.prototype.setCoordinates = function setCoordinates(
+  coordinates,
+  optLayout,
+) {
   check(coordinates, [[Number]]);
   check(coordinates.length, 2);
 
   const layout = optLayout || this.getLayout();
-  const getRadius = /XYM?/.test(layout) ? cartesian2DDistance : cartesian3DDistance;
-  this.setCenterAndRadius(coordinates[0], getRadius(coordinates[0], coordinates[1]), optLayout);
+  const getRadius = /XYM?/.test(layout)
+    ? cartesian2DDistance
+    : cartesian3DDistance;
+  this.setCenterAndRadius(
+    coordinates[0],
+    getRadius(coordinates[0], coordinates[1]),
+    optLayout,
+  );
 };

package/src/ol/geom/geometryCollection.js

@@ -1,33 +1,39 @@
 import GeometryCollection from 'ol/geom/GeometryCollection.js';
-import GeometryLayout from 'ol/geom/GeometryLayout.js';
 import { check } from '@vcsuite/check';
 
 /**
  * @returns {Array<import("ol/coordinate").Coordinate|Array<import("ol/coordinate").Coordinate>|Array<Array<import("ol/coordinate").Coordinate>>|Array<Array<Array<import("ol/coordinate").Coordinate>>>>}
  */
 GeometryCollection.prototype.getCoordinates = function getCoordinates() {
-  return this.getGeometries().map(g => g.getCoordinates());
+  return this.getGeometries().map((g) => g.getCoordinates());
 };
 
 /**
  * @param {Array<import("ol/coordinate").Coordinate|Array<import("ol/coordinate").Coordinate>|Array<Array<import("ol/coordinate").Coordinate>>|Array<Array<Array<import("ol/coordinate").Coordinate>>>>} coordinates
- * @param {import("ol/geom/GeometryLayout").default=} optLayout
+ * @param {import("ol/geom/Geometry").GeometryLayout=} optLayout
  */
-GeometryCollection.prototype.setCoordinates = function setCoordinates(coordinates, optLayout) {
+GeometryCollection.prototype.setCoordinates = function setCoordinates(
+  coordinates,
+  optLayout,
+) {
   check(coordinates, Array);
   check(coordinates.length, this.getGeometries().length);
 
-  this.setGeometries(this.getGeometries()
-    .map((g, i) => { g.setCoordinates(coordinates[i], optLayout); return g; }));
+  this.setGeometries(
+    this.getGeometries().map((g, i) => {
+      g.setCoordinates(coordinates[i], optLayout);
+      return g;
+    }),
+  );
 };
 
 /**
- * @returns {import("ol/geom/GeometryLayout").default}
+ * @returns {import("ol/geom/Geometry").GeometryLayout}
  */
 GeometryCollection.prototype.getLayout = function getLayout() {
   const firstGeom = this.getGeometries()[0];
   if (firstGeom) {
     return firstGeom.getLayout();
   }
-  return /** @type {undefined} */ (GeometryLayout.XYZ);
+  return 'XYZ';
 };

package/src/ol/render/canvas/canvasTileRenderer.js

@@ -8,7 +8,6 @@ import { transform2D } from 'ol/geom/flat/transform.js';
  * @class
  * @extends {CanvasImmediateRenderer}
  * @memberOf ol
- * @exports
  * Tile Renderer Implementation of openlayers CanvasImmediateRenderer
  * can be used to allow for a correction Factor to take into account Mercator Tile distortion
  */
@@ -33,7 +32,15 @@ class CanvasTileRenderer extends CanvasImmediateRenderer {
     userTransform,
     scaleY = 1,
   ) {
-    super(context, pixelRatio, extent, transform, viewRotation, squaredTolerance, userTransform);
+    super(
+      context,
+      pixelRatio,
+      extent,
+      transform,
+      viewRotation,
+      squaredTolerance,
+      userTransform,
+    );
 
     /**
      * @private
@@ -68,10 +75,7 @@ class CanvasTileRenderer extends CanvasImmediateRenderer {
    */
   set imageScale_(value) {
     const imageScale = value || [1, 1];
-    this.scaledImageScale_ = [
-      imageScale[0],
-      imageScale[1] * this.scaleY,
-    ];
+    this.scaledImageScale_ = [imageScale[0], imageScale[1] * this.scaleY];
   }
 
   /**
@@ -88,10 +92,7 @@ class CanvasTileRenderer extends CanvasImmediateRenderer {
    */
   set textScale_(value) {
     const textScale = value || [1, 1];
-    this.scaledTextScale_ = [
-      textScale[0],
-      textScale[1] * this.scaleY,
-    ];
+    this.scaledTextScale_ = [textScale[0], textScale[1] * this.scaleY];
   }
 
   /**

package/src/overrideClassRegistry.js

@@ -0,0 +1,214 @@
+import { check } from '@vcsuite/check';
+import { getLogger } from '@vcsuite/logger';
+import VcsEvent from './vcsEvent.js';
+
+/**
+ * @returns {import("@vcsuite/logger").Logger}
+ */
+function logger() {
+  return getLogger('OverrideClassRegistry');
+}
+
+/**
+ * @class
+ * @template {Object|import("@vcmap/core").VcsObject} T
+ */
+class OverrideClassRegistry {
+  /**
+   * @param {import("@vcmap/core").ClassRegistry<T>} coreClassRegistry
+   */
+  constructor(coreClassRegistry) {
+    this._coreClassRegistry = coreClassRegistry;
+    /**
+     * @type {Map<string, { moduleId: string, ctor: function(new: T, ...*) }>}
+     * @private
+     */
+    this._classMap = new Map();
+    /**
+     * @type {Map<string, Array<{ moduleId: string, ctor: function(new: T, ...*) }>>}
+     * @private
+     */
+    this._classShadows = new Map();
+    /**
+     * Called if a class was replaced. Is passed the className
+     * @type {VcsEvent<string>}
+     */
+    this.replaced = new VcsEvent();
+    /**
+     * Called if a class was removed. Is passed the className
+     * @type {VcsEvent<string>}
+     */
+    this.removed = new VcsEvent();
+  }
+
+  /**
+   * @returns {Array<string>}
+   */
+  getClassNames() {
+    return [
+      ...new Set([
+        ...this._classMap.keys(),
+        ...this._coreClassRegistry.getClassNames(),
+      ]),
+    ];
+  }
+
+  /**
+   * Register a class for a given module by name. If the class already exists, it will be replaced and replaced called with the classeName.
+   * @param {string} moduleId
+   * @param {string} className
+   * @param {function(new: T, ...*)} ctor
+   */
+  registerClass(moduleId, className, ctor) {
+    check(moduleId, String);
+    check(className, String);
+    check(ctor, Function);
+
+    const entry = {
+      moduleId,
+      ctor,
+    };
+
+    const replaced = this.hasClass(className);
+
+    if (this._classMap.has(className)) {
+      if (!this._classShadows.has(className)) {
+        this._classShadows.set(className, []);
+      }
+      this._classShadows.get(className).push(this._classMap.get(className));
+    }
+    this._classMap.set(className, entry);
+
+    if (replaced) {
+      this.replaced.raiseEvent(className);
+    }
+  }
+
+  /**
+   * Unregister a previously registered class. You can only unregister classes added to this registry, not the underlying core registry.
+   * If when registering this class you have replaced class, it will be re-instated and replaced called.
+   * If there is no previously registered class, it will be removed and removed will be called.
+   * @param {string} moduleId
+   * @param {string} className
+   */
+  unregisterClass(moduleId, className) {
+    check(moduleId, String);
+    check(className, String);
+
+    if (this._classShadows.has(className)) {
+      const shadowsArray = this._classShadows.get(className);
+      const newShadowsArray = shadowsArray.filter(
+        (e) => e.moduleId !== moduleId,
+      );
+      if (newShadowsArray.length === 0) {
+        this._classShadows.delete(className);
+      } else if (newShadowsArray.length !== shadowsArray.length) {
+        this._classShadows.set(className, newShadowsArray);
+      }
+    }
+
+    if (
+      this._classMap.has(className) &&
+      this._classMap.get(className).moduleId === moduleId
+    ) {
+      this._classMap.delete(className);
+      if (this._classShadows.has(className)) {
+        this._classMap.set(className, this._classShadows.get(className).pop());
+        if (this._classShadows.get(className).length === 0) {
+          this._classShadows.delete(className);
+        }
+        this.replaced.raiseEvent(className);
+      } else if (this._coreClassRegistry.hasClass(className)) {
+        this.replaced.raiseEvent(className);
+      } else {
+        this.removed.raiseEvent(className);
+      }
+    }
+  }
+
+  /**
+   * Gets the constructor for a registered class or undefined, if no such class was registerd
+   * @param {string} className
+   * @returns {function(new: T, ...*)|undefined}
+   * @api
+   */
+  getClass(className) {
+    check(className, String);
+
+    if (this._classMap.has(className)) {
+      return this._classMap.get(className).ctor;
+    }
+    return this._coreClassRegistry.getClass(className);
+  }
+
+  /**
+   * @param {string} className
+   * @returns {boolean}
+   */
+  hasClass(className) {
+    check(className, String);
+
+    return (
+      this._classMap.has(className) ||
+      this._coreClassRegistry.hasClass(className)
+    );
+  }
+
+  /**
+   * Create an object of the given className. The constructor is passed args.
+   * @param {string} className
+   * @param {...*} args
+   * @returns {T}
+   * @api
+   */
+  create(className, ...args) {
+    check(className, String);
+
+    const Ctor = this.getClass(className);
+    if (!Ctor) {
+      logger().error(`could not find constructor ${className}`);
+      return undefined;
+    }
+    return new Ctor(...args);
+  }
+
+  /**
+   * A convenience API to pass in a serialized VcsObject directly. It calls create using options.type as the className.
+   * Will throw an error if options.type is not a string or options is not an Object.
+   * Passes options and args to the constructor in that order.
+   * @param {Object} options
+   * @param {...*} args
+   * @returns {T}
+   */
+  createFromTypeOptions(options, ...args) {
+    check(options, { type: String });
+
+    return this.create(options.type, options, ...args);
+  }
+
+  /**
+   * Removes all classes registered from within a certain module. Will re-instate classes overwritten by the module
+   * and call the appropriate events, outlined in unregisterClass.
+   * @param {string} moduleId
+   */
+  removeModule(moduleId) {
+    check(moduleId, String);
+
+    this._classMap.forEach((cb, className) => {
+      this.unregisterClass(moduleId, className);
+    });
+  }
+
+  /**
+   * Destroys the override class registry
+   */
+  destroy() {
+    this._coreClassRegistry = null;
+    this._classMap.clear();
+    this._classShadows.clear();
+    this.replaced.destroy();
+    this.removed.destroy();
+  }
+}
+
+export default OverrideClassRegistry;