@vcmap/core 5.0.0-rc.8 → 5.0.0

package/dist/src/layer/oblique/layerObliqueImpl.d.ts

@@ -0,0 +1,15 @@
+import type { Layer as OLLayer } from 'ol/layer.js';
+import LayerImplementation from '../layerImplementation.js';
+import type ObliqueMap from '../../map/obliqueMap.js';
+declare class LayerObliqueImpl extends LayerImplementation<ObliqueMap> {
+    olLayer: OLLayer | null;
+    initialize(): Promise<void>;
+    activate(): Promise<void>;
+    deactivate(): void;
+    /**
+     * returns the ol Layer
+     */
+    getOLLayer(): OLLayer;
+    destroy(): void;
+}
+export default LayerObliqueImpl;

package/dist/src/layer/oblique/layerObliqueImpl.js

@@ -0,0 +1,41 @@
+import LayerImplementation from '../layerImplementation.js';
+import { vcsLayerName } from '../layerSymbols.js';
+class LayerObliqueImpl extends LayerImplementation {
+    olLayer = null;
+    initialize() {
+        if (!this.initialized) {
+            this.olLayer = this.getOLLayer();
+            this.olLayer[vcsLayerName] = this.name;
+            this.map.addOLLayer(this.olLayer);
+        }
+        return super.initialize();
+    }
+    async activate() {
+        await super.activate();
+        if (this.active && this.olLayer) {
+            this.olLayer.setVisible(true);
+        }
+    }
+    deactivate() {
+        super.deactivate();
+        if (this.olLayer) {
+            this.olLayer.setVisible(false);
+        }
+    }
+    /**
+     * returns the ol Layer
+     */
+    // eslint-disable-next-line class-methods-use-this
+    getOLLayer() {
+        throw new Error();
+    }
+    destroy() {
+        if (this.olLayer) {
+            this.map.removeOLLayer(this.olLayer);
+        }
+        this.olLayer = null;
+        super.destroy();
+    }
+}
+export default LayerObliqueImpl;
+//# sourceMappingURL=layerObliqueImpl.js.map

package/dist/src/layer/oblique/layerObliqueImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layerObliqueImpl.js","sourceRoot":"","sources":["../../../../src/layer/oblique/layerObliqueImpl.ts"],"names":[],"mappings":"AACA,OAAO,mBAAmB,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,MAAM,gBAAiB,SAAQ,mBAA+B;IAC5D,OAAO,GAAmB,IAAI,CAAC;IAE/B,UAAU;QACR,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YACjC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YACvC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACnC;QACD,OAAO,KAAK,CAAC,UAAU,EAAE,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,KAAK,CAAC,QAAQ,EAAE,CAAC;QACvB,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE;YAC/B,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SAC/B;IACH,CAAC;IAED,UAAU;QACR,KAAK,CAAC,UAAU,EAAE,CAAC;QACnB,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;SAChC;IACH,CAAC;IAED;;OAEG;IACH,kDAAkD;IAClD,UAAU;QACR,MAAM,IAAI,KAAK,EAAE,CAAC;IACpB,CAAC;IAED,OAAO;QACL,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACtC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;CACF;AAED,eAAe,gBAAgB,CAAC"}

package/dist/src/layer/oblique/obliqueHelpers.d.ts

@@ -0,0 +1,40 @@
+import type { Coordinate } from 'ol/coordinate.js';
+import type OLMap from 'ol/Map.js';
+import type { Geometry } from 'ol/geom.js';
+import type { Feature } from 'ol/index.js';
+import type ObliqueImage from '../../oblique/obliqueImage.js';
+export declare function getLongestSide(coordinates: Coordinate[]): number;
+export declare function getResolutionOptions(olMap: OLMap, image: ObliqueImage): {
+    size: {
+        height: number;
+        width: number;
+    };
+    fovy: number;
+    metersPerUnit: number;
+};
+export declare function getZoom(olMap: OLMap, image: ObliqueImage, distance: number): number;
+/**
+ * converts a geometry in mercator format to image coordinates
+ * @param  inputSourceGeometry
+ * @param  destinationGeometry
+ * @param  image
+ */
+export declare function mercatorGeometryToImageGeometry(inputSourceGeometry: Geometry, destinationGeometry: Geometry, image: ObliqueImage): Promise<Geometry>;
+/**
+ * returns a cloned geometry geometry with coordinates to format to image coordinates
+ * @param  sourceGeometry
+ * @param  destinationGeometry
+ * @param  image
+ */
+export declare function imageGeometryToMercatorGeometry(sourceGeometry: Geometry, destinationGeometry: Geometry, image: ObliqueImage): Promise<Geometry>;
+/**
+ * @param  feature
+ * @param  [retainRectangle=false]
+ */
+export declare function getPolygonizedGeometry(feature: Feature, retainRectangle?: boolean): Geometry;
+/**
+ * sets the geometry from the originalfeature to the oblique feature
+ * @param  originalFeature
+ * @param  obliqueFeature
+ */
+export declare function setNewGeometry(originalFeature: Feature, obliqueFeature: Feature): void;

package/dist/src/layer/oblique/obliqueHelpers.js

@@ -0,0 +1,140 @@
+import Circle from 'ol/geom/Circle.js';
+import { fromCircle } from 'ol/geom/Polygon.js';
+import { getTransform } from 'ol/proj.js';
+import { Cartographic, sampleTerrainMostDetailed } from '@vcmap-cesium/engine';
+import { cartesian2DDistance } from '../../util/math.js';
+import Projection, { mercatorProjection, wgs84Projection, } from '../../util/projection.js';
+import { actuallyIsCircle, alreadyTransformedToImage, obliqueGeometry, } from '../vectorSymbols.js';
+import { convertGeometryToPolygon, getFlatCoordinatesFromGeometry, } from '../../util/geometryHelpers.js';
+import { transformFromImage } from '../../oblique/helpers.js';
+export function getLongestSide(coordinates) {
+    let side = 0;
+    for (let i = 0; i < coordinates.length; i++) {
+        let j = i + 1;
+        if (j >= coordinates.length) {
+            j = 0;
+        }
+        const point1 = coordinates[i];
+        const point2 = coordinates[j];
+        const currentSide = cartesian2DDistance(point1, point2);
+        if (currentSide > side) {
+            side = currentSide;
+        }
+    }
+    return side;
+}
+export function getResolutionOptions(olMap, image) {
+    const longestSide = getLongestSide(image.groundCoordinates);
+    const fov = Math.PI / 3.0;
+    const viewport = olMap.getViewport();
+    const size = {
+        height: viewport.offsetHeight || 1,
+        width: viewport.offsetWidth || 1,
+    };
+    const aspectRatio = size.width / size.height;
+    const fovy = Math.atan(Math.tan(fov * 0.5) / aspectRatio) * 2.0;
+    const [imageSizeX, imageSizeY] = image.meta.size;
+    const longestImageSize = imageSizeX > imageSizeY ? imageSizeX : imageSizeY;
+    const metersPerUnit = longestSide / longestImageSize;
+    return {
+        size,
+        fovy,
+        metersPerUnit,
+    };
+}
+export function getZoom(olMap, image, distance) {
+    const { size, fovy, metersPerUnit } = getResolutionOptions(olMap, image);
+    const visibleMeters = 2 * distance * Math.tan(fovy / 2);
+    const visibleMapUnits = visibleMeters / metersPerUnit;
+    const resolution = visibleMapUnits / size.height;
+    return olMap.getView().getZoomForResolution(resolution);
+}
+/**
+ * converts a geometry in mercator format to image coordinates
+ * @param  inputSourceGeometry
+ * @param  destinationGeometry
+ * @param  image
+ */
+export async function mercatorGeometryToImageGeometry(inputSourceGeometry, destinationGeometry, image) {
+    const sourceGeometry = inputSourceGeometry instanceof Circle
+        ? fromCircle(inputSourceGeometry)
+        : inputSourceGeometry;
+    const coordinates = sourceGeometry.getCoordinates();
+    const flattenCoordinates = getFlatCoordinatesFromGeometry(sourceGeometry, coordinates);
+    let transformer = getTransform(mercatorProjection.proj, image.meta.projection.proj);
+    let updatedPositions = [];
+    if (image.meta.terrainProvider) {
+        const cartographicCoordinates = flattenCoordinates.map((coord) => {
+            Projection.mercatorToWgs84(coord, true);
+            return Cartographic.fromDegrees(coord[0], coord[1]);
+        });
+        transformer = getTransform(wgs84Projection.proj, image.meta.projection.proj);
+        updatedPositions = await sampleTerrainMostDetailed(image.meta.terrainProvider, cartographicCoordinates);
+    }
+    flattenCoordinates.forEach((coord, index) => {
+        transformer(coord, coord, 3);
+        const exactHeight = updatedPositions[index]
+            ? updatedPositions[index].height
+            : null;
+        const imageCoords = image.transformRealWorld2Image(coord, exactHeight || coord[2] || image.averageHeight);
+        flattenCoordinates[index][0] = imageCoords[0];
+        flattenCoordinates[index][1] = imageCoords[1];
+    });
+    destinationGeometry.setCoordinates(coordinates);
+    return destinationGeometry;
+}
+/**
+ * returns a cloned geometry geometry with coordinates to format to image coordinates
+ * @param  sourceGeometry
+ * @param  destinationGeometry
+ * @param  image
+ */
+export function imageGeometryToMercatorGeometry(sourceGeometry, destinationGeometry, image) {
+    const coordinates = sourceGeometry.getCoordinates();
+    const flattenCoordinates = getFlatCoordinatesFromGeometry(sourceGeometry, coordinates);
+    const promises = flattenCoordinates.map((coord) => transformFromImage(image, coord).then((coords) => {
+        coord[0] = coords.coords[0];
+        coord[1] = coords.coords[1];
+        coord[2] = coords.coords[2];
+    }));
+    return Promise.all(promises).then(() => {
+        destinationGeometry.setCoordinates(coordinates);
+        return destinationGeometry;
+    });
+}
+/**
+ * @param  feature
+ * @param  [retainRectangle=false]
+ */
+export function getPolygonizedGeometry(feature, retainRectangle = false) {
+    const geom = feature.getGeometry();
+    const isRectangle = geom.get('_vcsGeomType') === 'bbox' ||
+        geom.get('_vcsGeomType') === 'rectangle';
+    if (isRectangle && retainRectangle) {
+        return geom;
+    }
+    const isCircle = geom instanceof Circle;
+    const converted = convertGeometryToPolygon(geom);
+    converted[actuallyIsCircle] = isCircle;
+    return converted;
+}
+/**
+ * sets the geometry from the originalfeature to the oblique feature
+ * @param  originalFeature
+ * @param  obliqueFeature
+ */
+export function setNewGeometry(originalFeature, obliqueFeature) {
+    const originalGeometry = originalFeature.getGeometry();
+    const originalGeometryClone = originalFeature.getGeometry().clone();
+    obliqueFeature.setGeometry(!originalGeometry[alreadyTransformedToImage]
+        ? convertGeometryToPolygon(originalGeometryClone)
+        : originalGeometryClone);
+    if (originalGeometry[alreadyTransformedToImage]) {
+        // TODO handle UI for bbox and rectangle
+        obliqueFeature
+            .getGeometry()
+            .setProperties(originalFeature.getGeometry().getProperties(), false);
+    }
+    originalFeature[obliqueGeometry] = obliqueFeature.getGeometry();
+}
+//# sourceMappingURL=obliqueHelpers.js.map

package/dist/src/layer/oblique/obliqueHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"obliqueHelpers.js","sourceRoot":"","sources":["../../../../src/layer/oblique/obliqueHelpers.ts"],"names":[],"mappings":"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"}

package/dist/src/layer/oblique/vectorObliqueImpl.d.ts

@@ -0,0 +1,70 @@
+import VectorSource from 'ol/source/Vector.js';
+import OLVectorLayer from 'ol/layer/Vector.js';
+import Feature from 'ol/Feature.js';
+import type { Extent } from 'ol/extent.js';
+import type { SplitDirection } from '@vcmap-cesium/engine';
+import type { Geometry } from 'ol/geom.js';
+import LayerObliqueImpl from './layerObliqueImpl.js';
+import { FeatureLayerImplementation } from '../featureLayer.js';
+import type { VectorImplementationOptions } from '../vectorLayer.js';
+import type ObliqueMap from '../../map/obliqueMap.js';
+import type GlobalHider from '../globalHider.js';
+import type StyleItem from '../../style/styleItem.js';
+import type FeatureVisibility from '../featureVisibility.js';
+/**
+ * represents a specific vector layer for oblique.
+ */
+declare class VectorObliqueImpl extends LayerObliqueImpl implements FeatureLayerImplementation {
+    static get className(): string;
+    obliqueSource: VectorSource<Geometry>;
+    private _featureListeners;
+    private _sourceListener;
+    /**
+     * The extent of the current image for which features where fetched
+     */
+    currentExtent: Extent | null;
+    /**
+     * The image name for which the current features where fetched
+     */
+    fetchedFeaturesForImageName: string | null;
+    private _updatingMercator;
+    private _updatingOblique;
+    private _featureVisibilityListeners;
+    globalHider: GlobalHider;
+    source: VectorSource;
+    style: StyleItem;
+    featureVisibility: FeatureVisibility;
+    olLayer: OLVectorLayer<VectorSource> | null;
+    private _imageChangedListener;
+    constructor(map: ObliqueMap, options: VectorImplementationOptions);
+    getOLLayer(): OLVectorLayer<VectorSource>;
+    updateStyle(style: StyleItem, _silent?: boolean): void;
+    updateSplitDirection(_splitDirection: SplitDirection): void;
+    /**
+     * clears the current image and fetches features for the next
+     */
+    private _onObliqueImageChanged;
+    private _featureInExtent;
+    protected _addSourceListeners(): void;
+    activate(): Promise<void>;
+    private addFeature;
+    private _originalGeometryChanged;
+    private _setFeatureListeners;
+    private _convertToOblique;
+    updateObliqueGeometry(originalFeature: Feature, obliqueFeature: Feature): void;
+    updateMercatorGeometry(originalFeature: Feature, obliqueFeature: Feature): void;
+    /**
+     * Synchronizes image Features if the geometry has been changed.
+     * also clears source and featureListeners
+     */
+    private _clearCurrentImage;
+    /**
+     * Fetches the features within the extent of the current image
+     * @private
+     */
+    private _fetchFeaturesInView;
+    private removeFeature;
+    deactivate(): void;
+    destroy(): void;
+}
+export default VectorObliqueImpl;

package/dist/src/layer/oblique/vectorObliqueImpl.js

@@ -0,0 +1,344 @@
+import VectorSource from 'ol/source/Vector.js';
+import OLVectorLayer from 'ol/layer/Vector.js';
+import { unByKey } from 'ol/Observable.js';
+import Feature from 'ol/Feature.js';
+import { mercatorProjection } from '../../util/projection.js';
+import { mercatorGeometryToImageGeometry, imageGeometryToMercatorGeometry, getPolygonizedGeometry, setNewGeometry, } from './obliqueHelpers.js';
+import { actuallyIsCircle, alreadyTransformedToImage, doNotTransform, obliqueGeometry, originalFeatureSymbol, } from '../vectorSymbols.js';
+import LayerObliqueImpl from './layerObliqueImpl.js';
+import { synchronizeFeatureVisibilityWithSource } from '../vectorHelpers.js';
+/**
+ * represents a specific vector layer for oblique.
+ */
+class VectorObliqueImpl extends LayerObliqueImpl {
+    static get className() {
+        return 'VectorObliqueImpl';
+    }
+    obliqueSource = new VectorSource({});
+    _featureListeners = {};
+    _sourceListener = [];
+    /**
+     * The extent of the current image for which features where fetched
+     */
+    currentExtent = null;
+    /**
+     * The image name for which the current features where fetched
+     */
+    fetchedFeaturesForImageName = null;
+    _updatingMercator = {};
+    _updatingOblique = {};
+    _featureVisibilityListeners = [];
+    globalHider;
+    source;
+    style;
+    featureVisibility;
+    olLayer = null;
+    _imageChangedListener = null;
+    constructor(map, options) {
+        super(map, options);
+        this.globalHider = options.globalHider;
+        this.source = options.source;
+        this.style = options.style;
+        this.featureVisibility = options.featureVisibility;
+    }
+    getOLLayer() {
+        return new OLVectorLayer({
+            visible: false,
+            source: this.obliqueSource,
+            style: this.style.style,
+        });
+    }
+    // eslint-disable-next-line no-unused-vars
+    updateStyle(style, _silent) {
+        this.style = style;
+        if (this.initialized && this.olLayer) {
+            this.olLayer.setStyle(this.style.style);
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this,no-unused-vars
+    updateSplitDirection(_splitDirection) { }
+    /**
+     * clears the current image and fetches features for the next
+     */
+    _onObliqueImageChanged() {
+        this._clearCurrentImage();
+        this._fetchFeaturesInView();
+    }
+    _featureInExtent(feature) {
+        if (this.currentExtent) {
+            const geometry = feature.getGeometry();
+            if (geometry) {
+                return (geometry[alreadyTransformedToImage] ||
+                    geometry.intersectsExtent(this.currentExtent));
+            }
+        }
+        return false;
+    }
+    _addSourceListeners() {
+        this._sourceListener.push(this.source.on('addfeature', (event) => {
+            const f = event.feature;
+            if (this._featureInExtent(f)) {
+                // eslint-disable-next-line no-void
+                void this.addFeature(f);
+            }
+        }));
+        this._sourceListener.push(this.source.on('removefeature', (event) => {
+            this.removeFeature(event.feature);
+        }));
+        this._sourceListener.push(this.source.on('changefeature', (event) => {
+            const f = event.feature;
+            const newFeatureId = f.getId();
+            if (!this._featureListeners[newFeatureId] && this._featureInExtent(f)) {
+                // eslint-disable-next-line no-void
+                void this.addFeature(f);
+            }
+        }));
+    }
+    async activate() {
+        if (!this.active) {
+            await super.activate();
+            if (this.active) {
+                this.olLayer.setVisible(true);
+                if (this._featureVisibilityListeners.length === 0) {
+                    this._featureVisibilityListeners =
+                        synchronizeFeatureVisibilityWithSource(this.featureVisibility, this.source, this.globalHider);
+                }
+                this._addSourceListeners();
+                this._imageChangedListener = this.map.imageChanged?.addEventListener(this._onObliqueImageChanged.bind(this));
+                this._fetchFeaturesInView();
+            }
+        }
+    }
+    addFeature(originalFeature) {
+        if (!this.active) {
+            this.fetchedFeaturesForImageName = null;
+        }
+        if (this.active && this.currentExtent) {
+            const id = originalFeature.getId();
+            const originalGeometry = originalFeature.getGeometry();
+            if (originalFeature[doNotTransform]) {
+                if (originalGeometry && !this.obliqueSource.getFeatureById(id)) {
+                    this.obliqueSource.addFeature(originalFeature);
+                }
+                return Promise.resolve();
+            }
+            if (this.obliqueSource.getFeatureById(id)) {
+                return Promise.resolve();
+            }
+            const obliqueFeature = new Feature({});
+            obliqueFeature.setId(id);
+            obliqueFeature[originalFeatureSymbol] = originalFeature;
+            setNewGeometry(originalFeature, obliqueFeature);
+            obliqueFeature.setStyle(originalFeature.getStyle());
+            this._setFeatureListeners(originalFeature, obliqueFeature);
+            return this._convertToOblique(originalFeature, obliqueFeature).then(() => {
+                this.obliqueSource.addFeature(obliqueFeature);
+            });
+        }
+        return Promise.resolve();
+    }
+    _originalGeometryChanged(listeners, originalFeature, obliqueFeature) {
+        unByKey(listeners.originalGeometryChanged);
+        unByKey(listeners.obliqueGeometryChanged);
+        setNewGeometry(originalFeature, obliqueFeature);
+        this.updateObliqueGeometry(originalFeature, obliqueFeature);
+        listeners.originalGeometryChanged = originalFeature
+            .getGeometry()
+            .on('change', this.updateObliqueGeometry.bind(this, originalFeature, obliqueFeature));
+        listeners.obliqueGeometryChanged = obliqueFeature
+            .getGeometry()
+            .on('change', this.updateMercatorGeometry.bind(this, originalFeature, obliqueFeature));
+    }
+    _setFeatureListeners(originalFeature, obliqueFeature) {
+        const featureId = obliqueFeature.getId();
+        const listeners = {
+            originalFeatureGeometryChanged: originalFeature.on('change:geometry', () => {
+                const originalGeometry = originalFeature.getGeometry();
+                if (originalGeometry[actuallyIsCircle]) {
+                    unByKey(listeners.originalGeometryChanged);
+                    listeners.originalGeometryChanged = originalFeature
+                        .getGeometry()
+                        .on('change', () => {
+                        if (this._updatingMercator[featureId]) {
+                            return;
+                        }
+                        delete originalGeometry[actuallyIsCircle];
+                        this._originalGeometryChanged(listeners, originalFeature, obliqueFeature);
+                    });
+                    return;
+                }
+                this._originalGeometryChanged(listeners, originalFeature, obliqueFeature);
+            }),
+            originalFeatureChanged: originalFeature.on('change', () => {
+                obliqueFeature.setStyle(originalFeature.getStyle());
+            }),
+            originalGeometryChanged: originalFeature
+                .getGeometry()
+                .on('change', this.updateObliqueGeometry.bind(this, originalFeature, obliqueFeature)),
+            obliqueGeometryChanged: obliqueFeature
+                .getGeometry()
+                .on('change', this.updateMercatorGeometry.bind(this, originalFeature, obliqueFeature)),
+        };
+        this._featureListeners[featureId] = listeners;
+    }
+    async _convertToOblique(originalFeature, obliqueFeature) {
+        const id = originalFeature.getId();
+        const vectorGeometry = originalFeature.getGeometry();
+        const imageGeometry = obliqueFeature.getGeometry();
+        this._updatingOblique[id] = true;
+        if (!vectorGeometry[alreadyTransformedToImage]) {
+            await mercatorGeometryToImageGeometry(vectorGeometry, imageGeometry, this.map.currentImage);
+        }
+        else {
+            obliqueFeature
+                .getGeometry()
+                .setCoordinates(vectorGeometry.getCoordinates());
+        }
+        this._updatingOblique[id] = null;
+    }
+    updateObliqueGeometry(originalFeature, obliqueFeature) {
+        const id = originalFeature.getId();
+        if (this._updatingMercator[id]) {
+            return;
+        }
+        if (this._updatingOblique[id] != null) {
+            clearTimeout(this._updatingOblique[id]);
+        }
+        if (originalFeature.getGeometry()?.[alreadyTransformedToImage]) {
+            // eslint-disable-next-line no-void
+            void this._convertToOblique(originalFeature, obliqueFeature);
+        }
+        else {
+            this._updatingOblique[id] = setTimeout(() => {
+                // eslint-disable-next-line no-void
+                void this._convertToOblique(originalFeature, obliqueFeature);
+            }, 200);
+        }
+    }
+    updateMercatorGeometry(originalFeature, obliqueFeature) {
+        const id = originalFeature.getId();
+        if (this._updatingOblique[id]) {
+            return;
+        }
+        if (this._updatingMercator[id] != null) {
+            clearTimeout(this._updatingMercator[id]);
+        }
+        const imageName = this.fetchedFeaturesForImageName;
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        this._updatingMercator[id] = setTimeout(async () => {
+            const originalGeometry = getPolygonizedGeometry(originalFeature, false);
+            if (originalGeometry[actuallyIsCircle]) {
+                originalFeature.setGeometry(originalGeometry);
+            }
+            const imageGeometry = getPolygonizedGeometry(obliqueFeature, true);
+            this._updatingMercator[id] = true;
+            await imageGeometryToMercatorGeometry(imageGeometry, originalGeometry, this.map.collection.getImageByName(imageName));
+            this._updatingMercator[id] = null;
+        }, 200);
+    }
+    /**
+     * Synchronizes image Features if the geometry has been changed.
+     * also clears source and featureListeners
+     */
+    _clearCurrentImage() {
+        Object.values(this._featureListeners).forEach((listeners) => {
+            unByKey(Object.values(listeners));
+        });
+        this._featureListeners = {};
+        this._updatingOblique = {};
+        this._updatingMercator = {};
+        this.obliqueSource.getFeatures().forEach((f) => {
+            const original = f[originalFeatureSymbol];
+            if (original) {
+                delete original[obliqueGeometry];
+                const originalGeometry = original.getGeometry();
+                if (originalGeometry?.[alreadyTransformedToImage]) {
+                    this.updateMercatorGeometry(original, f);
+                }
+                delete originalGeometry?.[alreadyTransformedToImage];
+            }
+        });
+        this.obliqueSource.clear(true);
+        this.fetchedFeaturesForImageName = null;
+    }
+    /**
+     * Fetches the features within the extent of the current image
+     * @private
+     */
+    _fetchFeaturesInView() {
+        if (this.active &&
+            this.map.currentImage &&
+            this.fetchedFeaturesForImageName !== this.map.currentImage.name) {
+            this.currentExtent = this.map
+                .getExtentOfCurrentImage()
+                .getCoordinatesInProjection(mercatorProjection);
+            this.source.forEachFeatureInExtent(this.currentExtent, (feature) => {
+                // eslint-disable-next-line no-void
+                void this.addFeature(feature);
+            });
+            this.source.forEachFeature((feature) => {
+                if (feature.getGeometry()?.[alreadyTransformedToImage]) {
+                    // eslint-disable-next-line no-void
+                    void this.addFeature(feature);
+                }
+            });
+            this.fetchedFeaturesForImageName = this.map.currentImage.name;
+        }
+    }
+    removeFeature(feature) {
+        const feat = this.obliqueSource.getFeatureById(feature.getId());
+        if (feat) {
+            const id = feat.getId();
+            const listeners = this._featureListeners[id];
+            if (listeners) {
+                unByKey(Object.values(listeners));
+                delete this._featureListeners[id];
+            }
+            this.obliqueSource.removeFeature(feat);
+        }
+    }
+    deactivate() {
+        super.deactivate();
+        if (this.olLayer) {
+            this.olLayer.setVisible(false);
+        }
+        this._featureVisibilityListeners.forEach((cb) => {
+            cb();
+        });
+        this._featureVisibilityListeners = [];
+        unByKey(this._sourceListener);
+        this._sourceListener = [];
+        if (this._imageChangedListener) {
+            this._imageChangedListener();
+            this._imageChangedListener = null;
+        }
+        this._clearCurrentImage();
+    }
+    destroy() {
+        if (this.olLayer) {
+            this.map.removeOLLayer(this.olLayer);
+        }
+        this.olLayer = null;
+        unByKey(this._sourceListener);
+        this._sourceListener = [];
+        if (this._imageChangedListener) {
+            this._imageChangedListener();
+            this._imageChangedListener = null;
+        }
+        this.obliqueSource.clear(true);
+        Object.values(this._updatingOblique).forEach((timer) => {
+            if (timer != null) {
+                clearTimeout(timer);
+            }
+        });
+        Object.values(this._updatingMercator).forEach((timer) => {
+            if (timer != null) {
+                clearTimeout(timer);
+            }
+        });
+        this._clearCurrentImage();
+        super.destroy();
+    }
+}
+export default VectorObliqueImpl;
+//# sourceMappingURL=vectorObliqueImpl.js.map