@vcmap/core 6.1.11 → 6.2.0-rc.2

package/src/oblique/parseImageJson.ts

@@ -6,12 +6,12 @@ import {
   Matrix4,
   type CesiumTerrainProvider,
 } from '@vcmap-cesium/engine';
-import ObliqueImage, { ObliqueImageOptions } from './obliqueImage.js';
-import {
-  ObliqueViewDirection,
-  obliqueViewDirectionNames,
-} from './obliqueViewDirection.js';
-import ImageMeta, { ObliqueImageMetaOptions } from './obliqueImageMeta.js';
+import type { ObliqueImageOptions } from './obliqueImage.js';
+import ObliqueImage from './obliqueImage.js';
+import type { ObliqueViewDirection } from './obliqueViewDirection.js';
+import { obliqueViewDirectionNames } from './obliqueViewDirection.js';
+import type { ObliqueImageMetaOptions } from './obliqueImageMeta.js';
+import ImageMeta from './obliqueImageMeta.js';
 import Projection from '../util/projection.js';
 import type {
   ObliqueCameraOptions,
@@ -83,7 +83,7 @@ export function parseImageMeta(
     size,
     tileResolution,
     tileSize,
-    projection: imageProjection,
+    projection: imageProjection!,
     url,
     terrainProvider,
     headers,
@@ -96,7 +96,7 @@ export function parseImageMeta(
           new ImageMeta({
             ...defaultOptions,
             ...cameraOption,
-          } as ObliqueImageMetaOptions),
+          } satisfies ObliqueImageMetaOptions),
         );
       });
     } else if (typeof json.generalImageInfo.cameraParameter === 'object') {
@@ -107,7 +107,7 @@ export function parseImageMeta(
               name,
               ...defaultOptions,
               ...cameraOption,
-            } as ObliqueImageMetaOptions),
+            } satisfies ObliqueImageMetaOptions),
           );
         },
       );
@@ -119,7 +119,7 @@ export function parseImageMeta(
       new ImageMeta({
         name: 'default',
         ...defaultOptions,
-      } as ObliqueImageMetaOptions),
+      } satisfies ObliqueImageMetaOptions),
     );
   }
   return imageMetas;
@@ -233,8 +233,7 @@ export function parseLegacyImageData(
 ): ObliqueImage[] {
   const { cameraParameter } = json.generalImageInfo;
   const { version, buildNumber } = getVersionFromImageJson(json);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
+  // @ts-expect-error: legacy images not properly typed
   return (json.images as LegacyImageJson[]).map((img) => {
     const viewDirection = obliqueViewDirectionNames[img['view-direction']];
     const viewDirectionAngle =

package/src/ol/feature.ts

@@ -62,6 +62,7 @@ Feature.prototype.getAttributes = function getAttributes(
 Feature.prototype.getPropertyInherited = function getPropertyInherited(
   this: Feature,
   property,
+  // eslint-disable-next-line
 ): any {
   return this.getProperty(property);
 };

package/src/ol/geojson.d.ts

@@ -1,6 +1,6 @@
-import { GeoJsonProperties, Geometry } from 'geojson';
+import type { GeoJsonProperties, Geometry } from 'geojson';
 import type { VcsMeta } from '../layer/vectorProperties.js';
-import { FeatureStoreLayerState } from '../layer/featureStoreLayerState.js';
+import type { FeatureStoreLayerState } from '../layer/featureStoreLayerState.js';
 
 declare module 'geojson' {
   interface Point {
@@ -9,6 +9,7 @@ declare module 'geojson' {
 
   interface Feature<
     G extends Geometry | null = Geometry,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     P = GeoJsonProperties,
   > {
     _id?: string;

package/src/ol/geom/circle.ts

@@ -26,7 +26,7 @@ Circle.prototype.setCoordinates = function setCoordinates(
   coordinates: [Coordinate, Coordinate],
   optLayout?: GeometryLayout,
 ): void {
-  check(coordinates as [Coordinate, Coordinate], [[Number]]);
+  check(coordinates, [[Number]]);
   check(coordinates.length, 2);
 
   const layout = optLayout || this.getLayout();

package/src/ol/ol.d.ts

@@ -1,23 +1,14 @@
+/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/consistent-type-imports */
 /**
  * Type overrides for types extended by the @vcmap/core API
  */
-import * as geom from 'ol/geom.js';
-import * as style from 'ol/style.js';
-
-import { Feature } from 'ol/index.js';
-import CanvasImmediateRenderer from 'ol/render/canvas/Immediate.js';
-import {
-  Billboard,
-  Color,
-  type Entity,
-  type Label,
-} from '@vcmap-cesium/engine';
-import { StyleLike } from 'ol/style/Style.js';
-import VectorStyleItem, {
-  vectorStyleSymbol,
-} from '../style/vectorStyleItem.js';
-import { ArcStruct, featureArcStruct } from '../style/arcStyle.js';
-import {
+import type CanvasImmediateRenderer from 'ol/render/canvas/Immediate.js';
+import type { Billboard, Color, Entity, Label } from '@vcmap-cesium/engine';
+import type { StyleLike } from 'ol/style/Style.js';
+import type { vectorStyleSymbol } from '../style/vectorStyleItem.js';
+import type VectorStyleItem from '../style/vectorStyleItem.js';
+import type { ArcStruct, featureArcStruct } from '../style/arcStyle.js';
+import type {
   actuallyIsCircle,
   alreadyTransformedToImage,
   alreadyTransformedToMercator,
@@ -25,34 +16,40 @@ import {
   doNotTransform,
   obliqueGeometry,
   originalFeatureSymbol,
+  panoramaFeature,
   primitives,
 } from '../layer/vectorSymbols.js';
-import { vcsLayerName } from '../layer/layerSymbols.js';
-import {
+import type { vcsLayerName } from '../layer/layerSymbols.js';
+import type {
   isProvidedFeature,
   isProvidedClusterFeature,
 } from '../featureProvider/featureProviderSymbols.js';
-import {
+import type {
   globalHidden,
   hidden,
   highlighted,
   originalStyle,
 } from '../layer/featureVisibility.js';
-import {
+import type {
   FeatureStoreLayerState,
   featureStoreStateSymbol,
 } from '../layer/featureStoreLayerState.js';
-import { isTiledFeature } from '../layer/featureStoreLayer.js';
-import { featureFromOptions } from '../layer/geojsonLayer.js';
-import { handlerSymbol, vertexSymbol } from '../util/editor/editorSymbols.js';
-import { AxisAndPlanes } from '../util/editor/transformation/transformationTypes.js';
-import {
+import type { isTiledFeature } from '../layer/featureStoreLayer.js';
+import type { featureFromOptions } from '../layer/geojsonLayer.js';
+import type {
+  handlerSymbol,
+  vertexSymbol,
+} from '../util/editor/editorSymbols.js';
+import type { AxisAndPlanes } from '../util/editor/transformation/transformationTypes.js';
+import type {
   fvLastUpdated,
   globalHiderLastUpdated,
 } from '../layer/vectorHelpers.js';
-import { validityPlaceholder } from '../util/editor/interactions/createPolygonInteraction.js';
-import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
-import { PrimitiveType } from '../util/featureconverter/convert.js';
+import type { validityPlaceholder } from '../util/editor/interactions/createPolygonInteraction.js';
+import type { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
+import type { PrimitiveType } from '../util/featureconverter/convert.js';
+
+import { PanoramaDatasetFeatureProperties } from '../layer/panoramaDatasetLayer.js';
 
 declare module 'ol/geom.js' {
   interface Geometry {
@@ -127,6 +124,7 @@ declare module 'ol/index.js' {
     [createSync]?: boolean;
     [vectorClusterGroupName]?: string;
     [primitives]?: (PrimitiveType | Label | Billboard | Entity)[];
+    [panoramaFeature]?: PanoramaDatasetFeatureProperties;
   }
 
   class CanvasTileRenderer extends CanvasImmediateRenderer {

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import CanvasImmediateRenderer from 'ol/render/canvas/Immediate.js';
 import { intersects } from 'ol/extent.js';
 import { transformGeom2D } from 'ol/geom/SimpleGeometry.js';

package/src/ol/source/ClusterEnhancedVectorSource.ts

@@ -1,5 +1,5 @@
 import VectorSource from 'ol/source/Vector.js';
-import Feature from 'ol/Feature.js';
+import type Feature from 'ol/Feature.js';
 
 /**
  * @class

package/src/ol/source/VcsCluster.ts

@@ -1,6 +1,6 @@
 import Cluster, { type Options } from 'ol/source/Cluster.js';
-import Feature from 'ol/Feature.js';
-import { Point } from 'ol/geom.js';
+import type Feature from 'ol/Feature.js';
+import type { Point } from 'ol/geom.js';
 import { vectorClusterGroupName } from '../../vectorCluster/vectorClusterSymbols.js';
 import { hidden } from '../../layer/featureVisibility.js';
 
@@ -9,11 +9,11 @@ import { hidden } from '../../layer/featureVisibility.js';
  * @extends {import("ol/source/Cluster").default}
  * @memberOf ol
  */
-class VcsCluster extends Cluster<Feature> {
+class VcsCluster extends Cluster {
   private _paused = false;
 
   constructor(
-    props: Options<Feature>,
+    props: Options,
     private _name: string,
   ) {
     props.geometryFunction =

package/src/overrideClassRegistry.ts

@@ -1,10 +1,10 @@
 import { check } from '@vcsuite/check';
 import { getLogger, type Logger } from '@vcsuite/logger';
 import VcsEvent from './vcsEvent.js';
-import {
+import type {
   // eslint-disable-next-line import/no-named-default
   default as ClassRegistry,
-  Ctor,
+  CtorType,
   AbstractCtor,
 } from './classRegistry.js';
 
@@ -12,24 +12,27 @@ function logger(): Logger {
   return getLogger('OverrideClassRegistry');
 }
 
-type ModuleEntry<T extends AbstractCtor> = { moduleId: string; ctor: Ctor<T> };
+type ModuleEntry<T extends AbstractCtor> = {
+  moduleId: string;
+  ctor: CtorType<T>;
+};
 
 class OverrideClassRegistry<T extends AbstractCtor> {
   private _coreClassRegistry: ClassRegistry<T>;
 
-  private _classMap: Map<string, ModuleEntry<T>> = new Map();
+  private _classMap = new Map<string, ModuleEntry<T>>();
 
-  private _classShadows: Map<string, ModuleEntry<T>[]> = new Map();
+  private _classShadows = new Map<string, ModuleEntry<T>[]>();
 
   /**
    * Called if a class was replaced. Is passed the className
    */
-  replaced: VcsEvent<string> = new VcsEvent();
+  replaced = new VcsEvent<string>();
 
   /**
    * Called if a class was removed. Is passed the className
    */
-  removed: VcsEvent<string> = new VcsEvent();
+  removed = new VcsEvent<string>();
 
   constructor(coreClassRegistry: ClassRegistry<T>) {
     this._coreClassRegistry = coreClassRegistry;
@@ -47,7 +50,7 @@ class OverrideClassRegistry<T extends AbstractCtor> {
   /**
    * Register a class for a given module by name. If the class already exists, it will be replaced and replaced called with the classeName.
    */
-  registerClass(moduleId: string, className: string, ctor: Ctor<T>): void {
+  registerClass(moduleId: string, className: string, ctor: CtorType<T>): void {
     check(moduleId, String);
     check(className, String);
     check(ctor, Function);
@@ -122,7 +125,7 @@ class OverrideClassRegistry<T extends AbstractCtor> {
   /**
    * Gets the constructor for a registered class or undefined, if no such class was registerd
    */
-  getClass(className: string): Ctor<T> | undefined {
+  getClass(className: string): CtorType<T> | undefined {
     check(className, String);
 
     if (this._classMap.has(className)) {
@@ -146,6 +149,7 @@ class OverrideClassRegistry<T extends AbstractCtor> {
   create(className: string, ...args: unknown[]): InstanceType<T> | undefined {
     check(className, String);
 
+    // eslint-disable-next-line @typescript-eslint/naming-convention
     const Constructor = this.getClass(className);
     if (!Constructor) {
       logger().error(`could not find constructor ${className}`);
@@ -167,7 +171,7 @@ class OverrideClassRegistry<T extends AbstractCtor> {
     check(options, { type: String });
 
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-    return this.create(options.type as string, options, ...args);
+    return this.create(options.type, options, ...args);
   }
 
   /**

package/src/panorama/fieldOfView.ts

@@ -0,0 +1,254 @@
+import type { Extent } from 'ol/extent.js';
+import type {
+  Camera,
+  Cartesian2,
+  Matrix4,
+  PerspectiveFrustum,
+} from '@vcmap-cesium/engine';
+import { Cartesian3, Math as CesiumMath } from '@vcmap-cesium/engine';
+import { globalCartesianToImageSpherical } from './sphericalCoordinates.js';
+
+/**
+ * The field of view of a camera in global cartesian coordinates
+ */
+export type Fov = {
+  top: Cartesian3;
+  right: Cartesian3;
+  bottom: Cartesian3;
+  left: Cartesian3;
+  topLeft: Cartesian3;
+  topRight: Cartesian3;
+  bottomLeft: Cartesian3;
+  bottomRight: Cartesian3;
+  center: Cartesian3;
+};
+
+/**
+ * The field of view of a camera in image spherical coordinates ordered ([phi, theta]).
+ * See the sphericalCoordinates module for more information on how for more information.
+ */
+export type ProjectedFov = Record<keyof Fov, [number, number]>;
+
+export function createEmptyFov(): Fov {
+  return {
+    top: new Cartesian3(),
+    right: new Cartesian3(),
+    bottom: new Cartesian3(),
+    left: new Cartesian3(),
+    topLeft: new Cartesian3(),
+    topRight: new Cartesian3(),
+    bottomLeft: new Cartesian3(),
+    bottomRight: new Cartesian3(),
+    center: new Cartesian3(),
+  };
+}
+
+export function createEmptyProjectedFov(): ProjectedFov {
+  return {
+    top: [0, 0],
+    right: [0, 0],
+    bottom: [0, 0],
+    left: [0, 0],
+    topLeft: [0, 0],
+    topRight: [0, 0],
+    bottomLeft: [0, 0],
+    bottomRight: [0, 0],
+    center: [0, 0],
+  };
+}
+
+const scratchUpHalfHeight = new Cartesian3();
+const scratchRightHalfWidth = new Cartesian3();
+
+/**
+ * Returns the field of view of a camera in global cartesian coordinates assuming a perspective frustum & a distance of 1.
+ * an interpretation of https://gamedev.stackexchange.com/a/55248
+ * technically only used for debugging outside of this module.
+ */
+export function getFov(camera: Camera, result?: Fov): Fov {
+  const frustum = camera.frustum as PerspectiveFrustum;
+  const hNear = 2 * Math.tan(frustum.fov / 2) * frustum.near;
+  const wNear = hNear * frustum.aspectRatio;
+
+  const hNearHalf = hNear / 2;
+  const wNearHalf = wNear / 2;
+
+  const output = result ?? createEmptyFov();
+
+  const cNear = Cartesian3.add(
+    camera.position,
+    Cartesian3.multiplyByScalar(camera.direction, frustum.near, output.center),
+    output.center,
+  );
+
+  const upHalf = Cartesian3.multiplyByScalar(
+    camera.up,
+    hNearHalf,
+    scratchUpHalfHeight,
+  );
+
+  const rightHalf = Cartesian3.multiplyByScalar(
+    camera.right,
+    wNearHalf,
+    scratchRightHalfWidth,
+  );
+
+  output.top = Cartesian3.add(cNear, upHalf, output.top);
+  output.right = Cartesian3.add(cNear, rightHalf, output.right);
+  output.bottom = Cartesian3.subtract(cNear, upHalf, output.bottom);
+  output.left = Cartesian3.subtract(cNear, rightHalf, output.left);
+  output.topLeft = Cartesian3.subtract(
+    Cartesian3.add(cNear, upHalf, output.topLeft),
+    rightHalf,
+    output.topLeft,
+  );
+  output.topRight = Cartesian3.add(
+    Cartesian3.add(cNear, upHalf, output.topRight),
+    rightHalf,
+    output.topRight,
+  );
+  output.bottomLeft = Cartesian3.subtract(
+    Cartesian3.subtract(cNear, upHalf, output.bottomLeft),
+    rightHalf,
+    output.bottomLeft,
+  );
+  output.bottomRight = Cartesian3.add(
+    Cartesian3.subtract(cNear, upHalf, output.bottomRight),
+    rightHalf,
+    output.bottomRight,
+  );
+  output.center = cNear;
+  return output;
+}
+
+function projectFov(
+  fov: Fov,
+  invModelMatrix: Matrix4,
+  result?: ProjectedFov,
+): ProjectedFov {
+  const projected = result ?? createEmptyProjectedFov();
+  for (const [key, corner] of Object.entries(fov)) {
+    projected[key as keyof Fov] = globalCartesianToImageSpherical(
+      corner,
+      invModelMatrix,
+    );
+  }
+
+  return projected;
+}
+
+/**
+ * Returns the field of view of a camera projected into the image spherical coordinates
+ * technically only used for debugging outside of this module.
+ * @param camera
+ * @param invModelMatrix - the inverse model matrix of the image.
+ * @returns The projected fov in image spherical coordinates.
+ */
+export function getProjectedFov(
+  camera: Camera,
+  invModelMatrix: Matrix4,
+): ProjectedFov {
+  const fov = getFov(camera);
+  return projectFov(fov, invModelMatrix);
+}
+
+const scratchExtentFov = createEmptyFov();
+const scratchExtentProjectedFov = createEmptyProjectedFov();
+
+function getRightBound(projectedFov: ProjectedFov): number {
+  return Math.max(
+    projectedFov.right[0],
+    projectedFov.topRight[0],
+    projectedFov.bottomRight[0],
+  );
+}
+
+function getLeftBound(projectedFov: ProjectedFov): number {
+  return Math.min(
+    projectedFov.left[0],
+    projectedFov.topLeft[0],
+    projectedFov.bottomLeft[0],
+  );
+}
+
+function getTopBound(projectedFov: ProjectedFov): number {
+  return Math.min(
+    projectedFov.top[1],
+    projectedFov.topLeft[1],
+    projectedFov.topRight[1],
+  );
+}
+
+function getBottomBound(projectedFov: ProjectedFov): number {
+  return Math.max(
+    projectedFov.bottom[1],
+    projectedFov.bottomLeft[1],
+    projectedFov.bottomRight[1],
+  );
+}
+
+/**
+ * Returns the extent of the fov in image spherical coordinates. May return two extents, if the FOV wraps around along the longitude.
+ * it DOES NOT handle the case where the fov wraps around the poles (the pole is in the fov).
+ * Furthermore, the camera has to be aligned with the up axis of the sphere. it is not allowed to be rolled.
+ * @param camera
+ * @param invModelMatrix - the inverse model matrix of the panorama image to create the projected fov for
+ * @returns The extent of the fov in image spherical coordinates and the center. if providing more than on extent, the first will be up until 2 * PI and the second starting at 0.
+ */
+export function getFovImageSphericalExtent(
+  camera: Camera,
+  invModelMatrix: Matrix4,
+): { extents: [Extent] | [Extent, Extent]; center: [number, number] } {
+  const fov = getFov(camera, scratchExtentFov);
+  const projectedFov = projectFov(
+    fov,
+    invModelMatrix,
+    scratchExtentProjectedFov,
+  );
+  const simpleExtent = [
+    getLeftBound(projectedFov),
+    getTopBound(projectedFov),
+    getRightBound(projectedFov),
+    getBottomBound(projectedFov),
+  ];
+
+  let extents: [Extent] | [Extent, Extent];
+  if (simpleExtent[0] > simpleExtent[2]) {
+    extents = [
+      [simpleExtent[0], simpleExtent[1], CesiumMath.TWO_PI, simpleExtent[3]],
+      [0, simpleExtent[1], simpleExtent[2], simpleExtent[3]],
+    ];
+  } else {
+    extents = [simpleExtent];
+  }
+
+  return {
+    extents,
+    center: projectedFov.center,
+  };
+}
+
+/**
+ * creates a ray from the camera to the window position and try to intersect it with the unit sphere.
+ * @param windowPosition
+ * @param camera
+ * @param invModelMatrix
+ */
+export function windowPositionToImageSpherical(
+  windowPosition: Cartesian2,
+  camera: Camera,
+  invModelMatrix: Matrix4,
+): [number, number] | undefined {
+  const ray = camera.getPickRay(windowPosition);
+  if (!ray) {
+    return undefined;
+  }
+
+  const intersectionPoint = Cartesian3.add(
+    ray.origin,
+    ray.direction,
+    new Cartesian3(),
+  );
+
+  return globalCartesianToImageSpherical(intersectionPoint, invModelMatrix);
+}