@vcmap/core 6.1.11 → 6.2.0-rc.1

package/src/map/panoramaMap.ts

@@ -0,0 +1,410 @@
+import type { JulianDate, Cesium3DTileset, Scene } from '@vcmap-cesium/engine';
+import {
+  Color,
+  PrimitiveCollection,
+  CesiumWidget,
+  ScreenSpaceEventHandler,
+  ShadowMode,
+  Math as CesiumMath,
+} from '@vcmap-cesium/engine';
+import type { Coordinate } from 'ol/coordinate.js';
+import VcsMap, { type VcsMapOptions } from './vcsMap.js';
+import type { PanoramaImage } from '../panorama/panoramaImage.js';
+import { mapClassRegistry } from '../classRegistry.js';
+import type { PanoramaImageView } from '../panorama/panoramaImageView.js';
+import { createPanoramaImageView } from '../panorama/panoramaImageView.js';
+import {
+  getViewpointFromScene,
+  setupCesiumInteractions,
+} from './cesiumMapHelpers.js';
+import VcsEvent from '../vcsEvent.js';
+import type { PanoramaCameraController } from '../panorama/panoramaCameraController.js';
+import { createPanoramaCameraController } from '../panorama/panoramaCameraController.js';
+import type Viewpoint from '../util/viewpoint.js';
+import { ensureInCollection, indexChangedOnPrimitive } from './cesiumMap.js';
+import Projection from '../util/projection.js';
+import type Layer from '../layer/layer.js';
+import { defaultCursorColor } from '../panorama/panoramaTileMaterial.js';
+import LayerState from '../layer/layerState.js';
+import type PanoramaDatasetLayer from '../layer/panoramaDatasetLayer.js';
+
+export type PanoramaMapOptions = VcsMapOptions & {
+  /**
+   * Css color string to use for the overlay NaN color.
+   */
+  overlayNaNColor?: string;
+  /**
+   * Css color string to use for the cursor color.
+   */
+  cursorColor?: string;
+};
+
+export default class PanoramaMap extends VcsMap {
+  static get className(): string {
+    return 'PanoramaMap';
+  }
+
+  static getDefaultOptions(): PanoramaMapOptions {
+    return {
+      ...VcsMap.getDefaultOptions(),
+      overlayNaNColor: 'rgba(255, 0, 0, 1)',
+      cursorColor: defaultCursorColor,
+      fallbackToCurrentMap: false,
+    };
+  }
+
+  /**
+   * The event raised when the current image changes. Can be raised with undefined if the current image is cleared
+   * or a viewpoint fails to load an image.
+   */
+  readonly currentImageChanged = new VcsEvent<PanoramaImage | undefined>();
+
+  private _cesiumWidget: CesiumWidget | undefined;
+
+  private _imageView: PanoramaImageView | undefined;
+
+  private _currentImage: PanoramaImage | undefined;
+
+  private _screenSpaceListener: (() => void) | undefined;
+
+  private _screenSpaceEventHandler: ScreenSpaceEventHandler | undefined;
+
+  private _cameraController: PanoramaCameraController | undefined;
+
+  private _listeners: (() => void)[] = [];
+
+  private _overlayNaNColor: string | undefined;
+
+  private _cursorColor: string | undefined;
+
+  constructor(options: PanoramaMapOptions) {
+    const defaultOptions = PanoramaMap.getDefaultOptions();
+    super({ ...defaultOptions, ...options });
+
+    this._overlayNaNColor =
+      options.overlayNaNColor ?? defaultOptions.overlayNaNColor;
+    this._cursorColor = options.cursorColor ?? defaultOptions.cursorColor;
+  }
+
+  /**
+   * Internal API. throws if not properly initialized
+   */
+  get screenSpaceEventHandler(): ScreenSpaceEventHandler {
+    if (!this._screenSpaceEventHandler) {
+      throw new Error('ScreenSpaceEventHandler not initialized');
+    }
+    return this._screenSpaceEventHandler;
+  }
+
+  get currentPanoramaImage(): PanoramaImage | undefined {
+    return this._currentImage;
+  }
+
+  /**
+   * The panorama image view controlling image loading and rendering.
+   * Throws if not properly initialized
+   */
+  get panoramaView(): PanoramaImageView {
+    if (!this._imageView) {
+      throw new Error('PanoramaImageView not initialized');
+    }
+    return this._imageView;
+  }
+
+  /**
+   * The panorama camera controller controlling the camera movement.
+   * Throws if not properly initialized
+   */
+  get panoramaCameraController(): PanoramaCameraController {
+    if (!this._cameraController) {
+      throw new Error('PanoramaCameraController not initialized');
+    }
+    return this._cameraController;
+  }
+
+  /**
+   * Access to the raw cesium widget for finer control. Throws if not properly initialized.
+   */
+  getCesiumWidget(): CesiumWidget {
+    if (!this._cesiumWidget) {
+      throw new Error('CesiumWidget not initialized');
+    }
+    return this._cesiumWidget;
+  }
+
+  override async initialize(): Promise<void> {
+    if (!this.initialized) {
+      this._cesiumWidget = new CesiumWidget(this.mapElement, {
+        requestRenderMode: false,
+        scene3DOnly: true,
+        baseLayer: false,
+        shadows: false,
+        skyBox: false,
+        skyAtmosphere: false,
+        globe: false,
+        terrainShadows: ShadowMode.DISABLED,
+        msaaSamples: 1,
+      });
+
+      this._cesiumWidget.scene.screenSpaceCameraController.enableInputs = false;
+      this._cesiumWidget.scene.primitives.destroyPrimitives = false;
+
+      this._screenSpaceEventHandler = new ScreenSpaceEventHandler(
+        this._cesiumWidget.canvas,
+      );
+
+      this._screenSpaceListener = setupCesiumInteractions(
+        this,
+        this._cesiumWidget.scene,
+        this.screenSpaceEventHandler,
+      );
+      this._imageView = createPanoramaImageView(this);
+
+      if (this._overlayNaNColor) {
+        this._imageView.tilePrimitiveCollection.overlayNaNColor =
+          Color.fromCssColorString(this._overlayNaNColor);
+      }
+
+      if (this._cursorColor) {
+        this._imageView.tilePrimitiveCollection.cursorColor =
+          Color.fromCssColorString(this._cursorColor);
+      }
+
+      this._cameraController = createPanoramaCameraController(this);
+      this.initialized = true;
+
+      this._listeners.push(
+        this._cesiumWidget.scene.postRender.addEventListener(
+          (eventScene: Scene, time: JulianDate) => {
+            this.postRender.raiseEvent({
+              map: this,
+              originalEvent: { scene: eventScene, time },
+            });
+          },
+        ),
+      );
+    }
+    await super.initialize();
+  }
+
+  override async activate(): Promise<void> {
+    await super.activate();
+    if (this.active && this._cesiumWidget) {
+      this._cesiumWidget.useDefaultRenderLoop = true;
+      this._cesiumWidget.resize();
+    }
+  }
+
+  override deactivate(): void {
+    super.deactivate();
+    if (this._cesiumWidget) {
+      this._cesiumWidget.useDefaultRenderLoop = false;
+    }
+  }
+
+  override getViewpoint(): Promise<null | Viewpoint> {
+    return Promise.resolve(this.getViewpointSync());
+  }
+
+  override getViewpointSync(): Viewpoint | null {
+    if (!this._cesiumWidget || !this._cesiumWidget.scene || !this.target) {
+      return null;
+    }
+    return getViewpointFromScene(this._cesiumWidget.scene);
+  }
+
+  /**
+   * Sets the current image to the closest image to the given coordinate. Unsets the
+   * current image, if there is no image within the default distance.
+   * @param viewpoint
+   */
+  override async gotoViewpoint(viewpoint: Viewpoint): Promise<void> {
+    if (
+      this.movementApiCallsDisabled ||
+      !viewpoint.isValid() ||
+      !this._cesiumWidget
+    ) {
+      return;
+    }
+
+    const position = viewpoint.groundPosition ?? viewpoint.cameraPosition;
+    if (!position) {
+      return;
+    }
+
+    const closestImage = await this.getClosestImageFromViewpoint(viewpoint);
+
+    if (closestImage) {
+      if (viewpoint.heading != null) {
+        this._cesiumWidget.camera.setView({
+          orientation: {
+            heading: CesiumMath.toRadians(viewpoint.heading),
+          },
+        });
+      }
+    }
+    this.setCurrentImage(closestImage);
+  }
+
+  /**
+   * {@link getClosestImage} for the given viewpoint. Prefers the ground position
+   * @param viewpoint
+   */
+  async getClosestImageFromViewpoint(
+    viewpoint: Viewpoint,
+  ): Promise<PanoramaImage | undefined> {
+    if (viewpoint.isValid()) {
+      const position = viewpoint.groundPosition ?? viewpoint.cameraPosition;
+      if (position) {
+        return this.getClosestImage(Projection.wgs84ToMercator(position), 200);
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Returns the closest image to the given coordinate within the given distance from all the datasets in the panorama datasets collection.
+   * @param coordinate
+   * @param maxDistance
+   */
+  async getClosestImage(
+    coordinate: Coordinate,
+    maxDistance = 200,
+  ): Promise<PanoramaImage | undefined> {
+    const loadPromises = [...this.layerCollection]
+      .filter(
+        (dataset): dataset is PanoramaDatasetLayer =>
+          dataset.state !== LayerState.INACTIVE &&
+          dataset.className === 'PanoramaDatasetLayer',
+      )
+      .map(async (dataset) => {
+        const closesImage = await dataset.getClosestImage(
+          coordinate,
+          maxDistance,
+        );
+        if (closesImage) {
+          return {
+            ...closesImage,
+            dataset,
+          };
+        }
+
+        return undefined;
+      });
+
+    const images = await Promise.all(loadPromises);
+
+    let minDistanceSqrd = Infinity;
+    let closestIndex = -1;
+
+    images.forEach((image, index) => {
+      if (image && image.distanceSqrd < minDistanceSqrd) {
+        minDistanceSqrd = image.distanceSqrd;
+        closestIndex = index;
+      }
+    });
+
+    if (closestIndex !== -1) {
+      const { imageName, dataset } = images[closestIndex]!;
+      return dataset.createPanoramaImage(imageName); // XXX position is a HACK to support frankenstein datasets
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Sets the current image to the given panorama image. If the image is undefined, the current image is cleared.
+   * @param image
+   */
+  setCurrentImage(image?: PanoramaImage): void {
+    if (this._currentImage !== image) {
+      this._currentImage = image;
+      this.currentImageChanged.raiseEvent(image);
+    }
+  }
+
+  override indexChanged(layer: Layer): void {
+    const viz = this.getVisualizationsForLayer(layer);
+    if (viz) {
+      viz.forEach((item) => {
+        if (item instanceof PrimitiveCollection) {
+          indexChangedOnPrimitive(
+            this.getCesiumWidget().scene.primitives,
+            item,
+            this.layerCollection,
+          );
+        }
+      });
+    }
+  }
+
+  /**
+   * Internal API used to register visualizations from layer implementations
+   * @param  primitiveCollection
+   */
+  addPrimitiveCollection(
+    primitiveCollection: PrimitiveCollection | Cesium3DTileset,
+  ): void {
+    if (!this._cesiumWidget) {
+      throw new Error('Cannot add primitive to uninitialized map');
+    }
+    if (this.validateVisualization(primitiveCollection)) {
+      this.addVisualization(primitiveCollection);
+      ensureInCollection(
+        this._cesiumWidget.scene.primitives,
+        primitiveCollection,
+        this.layerCollection,
+      );
+    }
+  }
+
+  /**
+   * Internal API to unregister the visualization for a layers implementation
+   * @param  primitiveCollection
+   */
+  removePrimitiveCollection(
+    primitiveCollection: PrimitiveCollection | Cesium3DTileset,
+  ): void {
+    this.removeVisualization(primitiveCollection);
+    this._cesiumWidget?.scene.primitives.remove(primitiveCollection);
+  }
+
+  override toJSON(): PanoramaMapOptions {
+    const config = super.toJSON() as Partial<PanoramaMapOptions>;
+    const defaultOptions = PanoramaMap.getDefaultOptions();
+
+    if (this._overlayNaNColor !== defaultOptions.overlayNaNColor) {
+      config.overlayNaNColor = this._overlayNaNColor;
+    }
+
+    if (this._cursorColor !== defaultOptions.cursorColor) {
+      config.cursorColor = this._cursorColor;
+    }
+
+    if (this.fallbackToCurrentMap !== defaultOptions.fallbackToCurrentMap) {
+      config.fallbackToCurrentMap = this.fallbackToCurrentMap;
+    } else {
+      delete config.fallbackToCurrentMap;
+    }
+
+    return config;
+  }
+
+  override destroy(): void {
+    this.currentImageChanged.destroy();
+    this._currentImage?.destroy();
+    this._cameraController?.destroy();
+    this._imageView?.destroy();
+    this._screenSpaceListener?.();
+    this._screenSpaceEventHandler?.destroy();
+    this._cesiumWidget?.destroy();
+    this._cesiumWidget = undefined;
+    this._listeners.forEach((cb) => {
+      cb();
+    });
+
+    super.destroy();
+  }
+}
+
+mapClassRegistry.registerClass(PanoramaMap.className, PanoramaMap);

package/src/map/vcsMap.ts

@@ -1,4 +1,5 @@
-import { getLogger as getLoggerByName, Logger } from '@vcsuite/logger';
+import type { Logger } from '@vcsuite/logger';
+import { getLogger as getLoggerByName } from '@vcsuite/logger';
 import { parseBoolean } from '@vcsuite/parsers';
 import { v4 as uuidv4 } from 'uuid';
 import type { MapEvent as OLMapEvent } from 'ol';
@@ -6,14 +7,14 @@ import type { Layer as OLLayer } from 'ol/layer.js';
 import type { Coordinate } from 'ol/coordinate.js';
 
 import { check, is, maybe, oneOf } from '@vcsuite/check';
-import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
+import type { VcsObjectOptions } from '../vcsObject.js';
+import VcsObject from '../vcsObject.js';
 import LayerCollection from '../util/layerCollection.js';
 import MapState from './mapState.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
 import VcsEvent from '../vcsEvent.js';
 import { mapClassRegistry } from '../classRegistry.js';
-import type { CesiumMapEvent } from './cesiumMap.js';
-import { CesiumVisualisationType } from './cesiumMap.js';
+import type { CesiumMapEvent, CesiumVisualisationType } from './cesiumMap.js';
 import type Viewpoint from '../util/viewpoint.js';
 import type Layer from '../layer/layer.js';
 import type { MapEvent } from '../interaction/abstractInteraction.js';
@@ -275,12 +276,12 @@ class VcsMap<
 
     if (this.active) {
       [...this._layerCollection].forEach((l) => {
-        l.mapActivated(this).catch((_e) => {
+        l.mapActivated(this).catch(() => {
           this.getLogger().error(`Failed to activate map on layer: ${l.name}`);
         });
       });
       [...this._layerCollection.vectorClusterGroups].forEach((g) => {
-        g.mapActivated(this).catch((_e) => {
+        g.mapActivated(this).catch(() => {
           this.getLogger().error(
             `Failed to activate map on vector cluster group: ${g.name}`,
           );
@@ -321,7 +322,7 @@ class VcsMap<
 
     const added = (i: Layer | VectorClusterGroup): void => {
       if (this.active) {
-        i.mapActivated(this).catch((_e) => {
+        i.mapActivated(this).catch(() => {
           this.getLogger().error(`Failed to activate map on layer: ${i.name}`);
         });
       }
@@ -347,7 +348,7 @@ class VcsMap<
   /**
    * Determines whether this map can show this viewpoint. Returns true in any other map then {@link ObliqueMap}
    */
-  // eslint-disable-next-line class-methods-use-this
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
   canShowViewpoint(_viewpoint: Viewpoint): Promise<boolean> {
     return Promise.resolve(true);
   }
@@ -369,7 +370,7 @@ class VcsMap<
     }
   }
 
-  // eslint-disable-next-line class-methods-use-this,no-empty-function
+  // eslint-disable-next-line class-methods-use-this
   async initialize(): Promise<void> {
     return Promise.resolve();
   }
@@ -377,7 +378,7 @@ class VcsMap<
   /**
    * is called if a layer changes its position in the layerCollection.
    */
-  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
   indexChanged(_layer: Layer): void {}
 
   /**
@@ -518,9 +519,9 @@ class VcsMap<
       [...this.layerCollection].forEach((layer) => {
         layer.mapDeactivated(this);
       });
-      [...this.layerCollection.vectorClusterGroups].forEach((clusterGroup) =>
-        clusterGroup.mapDeactivated(this),
-      );
+      [...this.layerCollection.vectorClusterGroups].forEach((clusterGroup) => {
+        clusterGroup.mapDeactivated(this);
+      });
       this.stateChanged.raiseEvent(this._state);
     }
   }
@@ -550,9 +551,11 @@ class VcsMap<
    * @param _optMaximumHeight during animation (can be used to get rid of the bunny hop)
    * gotoViewpoint
    */
-  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  // eslint-disable-next-line class-methods-use-this
   gotoViewpoint(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _viewpoint: Viewpoint,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _optMaximumHeight?: number,
   ): Promise<void> {
     return Promise.resolve();
@@ -578,12 +581,12 @@ class VcsMap<
    * Resolution in meters per pixe
    * @param _coordinate - coordinate in mercator for which to determine resolution. only required in 3D
    */
-  // eslint-disable-next-line class-methods-use-this,no-unused-vars
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
   getCurrentResolution(_coordinate: Coordinate): number {
     return 1;
   }
 
-  // eslint-disable-next-line no-unused-vars,class-methods-use-this
+  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
   pointIsVisible(_coords: Coordinate): boolean {
     return false;
   }

package/src/moduleIdSymbol.ts

@@ -1,2 +1 @@
-// eslint-disable-next-line import/prefer-default-export
 export const moduleIdSymbol: unique symbol = Symbol('moduleId');

package/src/oblique/defaultObliqueCollection.ts

@@ -26,6 +26,7 @@ class DefaultObliqueCollection extends ObliqueCollection {
 
   getImageForCoordinate(
     mercatorCoordinate: Coordinate,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     _viewDirection: ObliqueViewDirection,
   ): ObliqueImage {
     const groundCoordinates = [

package/src/oblique/helpers.ts

@@ -17,10 +17,8 @@ import {
   cartesian2DDistance,
   cartesian2DDistanceSquared,
 } from '../util/math.js';
-import Projection, {
-  mercatorProjection,
-  wgs84Projection,
-} from '../util/projection.js';
+import type Projection from '../util/projection.js';
+import { mercatorProjection, wgs84Projection } from '../util/projection.js';
 import type ObliqueImage from './obliqueImage.js';
 import { isSameOrigin } from '../util/urlHelpers.js';
 

package/src/oblique/obliqueCollection.ts

@@ -23,7 +23,8 @@ import ObliqueDataSet, {
 } from './obliqueDataSet.js';
 import { ObliqueViewDirection } from './obliqueViewDirection.js';
 import { mercatorProjection } from '../util/projection.js';
-import VcsObject, { VcsObjectOptions } from '../vcsObject.js';
+import type { VcsObjectOptions } from '../vcsObject.js';
+import VcsObject from '../vcsObject.js';
 import type { TerrainProviderOptions } from '../layer/terrainHelpers.js';
 import type ObliqueImage from './obliqueImage.js';
 import type { ObliqueViewOptions } from './obliqueView.js';
@@ -140,15 +141,15 @@ class ObliqueCollection extends VcsObject {
   /**
    * Maps each direction to an RTree
    */
-  private _directionTrees: Map<
+  private _directionTrees = new Map<
     ObliqueViewDirection,
     RBush<ObliqueImageRbushItem>
-  > = new Map();
+  >();
 
   /**
    * Maps image name to image
    */
-  private _images: Map<string, ObliqueImage> = new Map();
+  private _images = new Map<string, ObliqueImage>();
 
   /**
    * Maps urls to general infos & cameras
@@ -162,7 +163,7 @@ class ObliqueCollection extends VcsObject {
   /**
    * Event raised when images are loaded. Is passed an Array of ObliqueImages as its only argument.
    */
-  imagesLoaded: VcsEvent<Array<ObliqueImage>> = new VcsEvent();
+  imagesLoaded = new VcsEvent<Array<ObliqueImage>>();
 
   private _tileFeatureSource: VectorSource | null = null;
 
@@ -327,8 +328,7 @@ class ObliqueCollection extends VcsObject {
       }
     }
 
-    const directions: Map<ObliqueViewDirection, ObliqueImageRbushItem[]> =
-      new Map();
+    const directions = new Map<ObliqueViewDirection, ObliqueImageRbushItem[]>();
     images.forEach((image) => {
       this._images.set(image.name, image);
       if (!directions.has(image.viewDirection)) {

package/src/oblique/obliqueDataSet.ts

@@ -12,7 +12,8 @@ import {
 } from './parseImageJson.js';
 import VcsEvent from '../vcsEvent.js';
 import { getTerrainProviderForUrl } from '../layer/terrainHelpers.js';
-import Projection, { ProjectionOptions } from '../util/projection.js';
+import type { ProjectionOptions } from '../util/projection.js';
+import Projection from '../util/projection.js';
 import { getInitForUrl, requestJson } from '../util/fetch.js';
 import type ObliqueImage from './obliqueImage.js';
 import type {
@@ -72,9 +73,9 @@ class ObliqueDataSet {
    */
   imagesLoaded = new VcsEvent<ObliqueDataSetImagesLoaded>();
 
-  private _tiles: Map<string, DataState> = new Map();
+  private _tiles = new Map<string, DataState>();
 
-  private _loadingPromises: Map<string, Promise<void>> = new Map();
+  private _loadingPromises = new Map<string, Promise<void>>();
 
   private _state = DataState.PENDING;
 
@@ -142,8 +143,8 @@ class ObliqueDataSet {
         .then((data) => {
           return this._initialize(data);
         })
-        .catch((err) => {
-          return Promise.reject(err);
+        .catch((err: unknown) => {
+          return Promise.reject(err as Error);
         });
     }
     return this._loadingPromise;
@@ -328,7 +329,7 @@ class ObliqueDataSet {
           });
         }
       })
-      .catch((err) => {
+      .catch((err: unknown) => {
         // eslint-disable-next-line no-console
         console.error(err);
       })

package/src/oblique/obliqueImage.ts

@@ -2,7 +2,7 @@ import type { Coordinate } from 'ol/coordinate.js';
 import { Cartesian3, Cartesian4, Matrix3, Matrix4 } from '@vcmap-cesium/engine';
 import { transformCWIFC } from './helpers.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
-import { ObliqueViewDirection } from './obliqueViewDirection.js';
+import type { ObliqueViewDirection } from './obliqueViewDirection.js';
 import type ObliqueImageMeta from './obliqueImageMeta.js';
 
 export const isDefaultImageSymbol = Symbol('isDefaultImage');

package/src/oblique/obliqueProvider.ts

@@ -13,9 +13,9 @@ import { mercatorProjection } from '../util/projection.js';
 import VcsEvent from '../vcsEvent.js';
 import type ObliqueImage from './obliqueImage.js';
 import { isDefaultImageSymbol } from './obliqueImage.js';
-import { ObliqueViewDirection } from './obliqueViewDirection.js';
+import type { ObliqueViewDirection } from './obliqueViewDirection.js';
 import type ObliqueCollection from './obliqueCollection.js';
-import ObliqueImageMeta from './obliqueImageMeta.js';
+import type ObliqueImageMeta from './obliqueImageMeta.js';
 
 export type ObliqueViewpoint = {
   /**
@@ -46,7 +46,7 @@ class ObliqueProvider {
 
   private _olMap: olMap;
 
-  private _viewCache: Map<ObliqueImageMeta, ObliqueView> = new Map();
+  private _viewCache = new Map<ObliqueImageMeta, ObliqueView>();
 
   private _currentImage: ObliqueImage | null = null;
 

package/src/oblique/obliqueView.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-deprecated */
 import { v4 as uuidv4 } from 'uuid';
 import { TrustedServers } from '@vcmap-cesium/engine';
 import type { ImageTile } from 'ol';