@npm9912/v-map 0.1.0

package/dist/collection/map-provider/cesium/i-layer.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/map-provider/cesium/layer-manager.js

@@ -0,0 +1,467 @@
+export class LayerManager {
+    Cesium;
+    layers = new Map();
+    viewer;
+    //private imageryZMutex = new AsyncMutex();
+    constructor(Cesium, viewer) {
+        this.viewer = viewer;
+        this.Cesium = Cesium;
+    }
+    replaceLayer(id, oldlayer, layer) {
+        if (!this.Cesium) {
+            throw new Error('Cesium must be initialized first. Call init() method.');
+        }
+        const zIndex = oldlayer.getZIndex();
+        const visible = oldlayer.getVisible();
+        const opacity = oldlayer.getOpacity();
+        this.removeLayer(id);
+        const wrappedLayer = this.addLayer(id, layer);
+        wrappedLayer.setZIndex(zIndex);
+        wrappedLayer.setVisible(visible);
+        wrappedLayer.setOpacity(opacity);
+        return wrappedLayer;
+    }
+    addLayer(id, layer) {
+        if (!this.Cesium) {
+            throw new Error('Cesium must be initialized first. Call init() method.');
+        }
+        //add layer
+        if (layer instanceof this.Cesium.GeoJsonDataSource) {
+            this.viewer.dataSources.add(layer);
+        }
+        else if (layer instanceof this.Cesium.DataSource) {
+            this.viewer.dataSources.add(layer);
+        }
+        else if (layer instanceof this.Cesium.Cesium3DTileset) {
+            this.viewer.scene.primitives.add(layer);
+            if (!layer.style) {
+                layer.style = new this.Cesium.Cesium3DTileStyle();
+            }
+        }
+        else if (layer instanceof this.Cesium.ImageryLayer) {
+            this.viewer.imageryLayers.add(layer);
+        }
+        layer.id = id;
+        const wrapped = this.wrapLayer(layer);
+        this.layers.set(id, wrapped);
+        return wrapped;
+    }
+    addCustomLayer(id, layer) {
+        this.layers.set(id, layer);
+        return layer;
+    }
+    getLayer(layerId) {
+        const layer = this.layers.get(layerId);
+        if (!layer)
+            throw new Error(`Layer mit ID "${layerId}" nicht gefunden.`);
+        return layer;
+    }
+    getLayerById(layerId) {
+        return this.getLayer(layerId);
+    }
+    removeLayer(layerId) {
+        const layer = this.getLayer(layerId);
+        layer.remove();
+        this.layers.delete(layerId);
+    }
+    setVisible(layerId, visible) {
+        const layer = this.getLayer(layerId);
+        layer.setVisible(visible);
+    }
+    setOpacity(layerId, opacity) {
+        const layer = this.getLayer(layerId);
+        layer.setOpacity(opacity);
+    }
+    async setZIndex(layerId, zindex) {
+        const layer = this.getLayer(layerId);
+        await layer.setZIndex(zindex);
+    }
+    wrapLayer(layer) {
+        if (layer instanceof this.Cesium.ImageryLayer) {
+            return this.wrapImageryLayer(layer);
+        }
+        else if (layer instanceof this.Cesium.Cesium3DTileset) {
+            return this.wrapTilesetLayer(layer);
+        }
+        else {
+            return this.wrapDataSourceLayer(layer);
+        }
+    }
+    async sortImageryLayers(collection, layer, targetZ) {
+        const tempCollection = this.sort(collection, layer, targetZ);
+        // Collection leeren und neu befüllen
+        collection.removeAll(false);
+        tempCollection.forEach(ds => collection.add(ds));
+    }
+    async sort3DTileSets(collection, tileset, targetZ) {
+        const tempCollection = this.sort(collection, tileset, targetZ);
+        // Collection leeren und neu befüllen
+        collection.removeAll();
+        tempCollection.forEach(ds => collection.add(ds));
+    }
+    async sortDataSources(collection, dataSource, zIndex) {
+        const tempCollection = this.sort(collection, dataSource, zIndex);
+        // Collection leeren und neu befüllen
+        collection.removeAll(false);
+        tempCollection.forEach(async (ds) => await collection.add(ds));
+    }
+    sort(collection, dataSource, zIndex) {
+        // 1. Layer entfernen
+        collection.remove(dataSource, false);
+        // 2. Layer an der richtigen Position wieder hinzufügen
+        // Cesium hat keine direkte "setZIndex"-Methode für DataSources,
+        // also müssen wir die Reihenfolge manuell steuern.
+        // Da DataSourceCollection keine Z-Index-Unterstützung hat,
+        // müssen wir alle Layer neu sortieren.
+        //    const dataSources: DataSource[] = [];
+        const tempDataSources = [];
+        // Alle Layer sammeln
+        for (let i = 0; i < collection.length; i++) {
+            tempDataSources.push(collection.get(i));
+        }
+        // Sortieren nach zIndex (falls vorhanden) oder Reihenfolge
+        tempDataSources.sort((a, b) => {
+            const aZIndex = a.zIndex || 0;
+            const bZIndex = b.zIndex || 0;
+            return aZIndex - bZIndex;
+        });
+        // Den Layer mit dem neuen zIndex einfügen
+        dataSource.zIndex = zIndex;
+        tempDataSources.push(dataSource);
+        // Neu sortieren
+        tempDataSources.sort((a, b) => {
+            const aZIndex = a.zIndex || 0;
+            const bZIndex = b.zIndex || 0;
+            return aZIndex - bZIndex;
+        });
+        return tempDataSources;
+    }
+    // /**
+    //  * Verschiebt ein bereits vorhandenes ImageryLayer innerhalb seiner Collection
+    //  * zu einem gewünschten zIndex und hält die Collection nach zIndex sortiert.
+    //  *
+    //  * @param collection  Die Sammlung, in der sich das Layer befindet.
+    //  * @param layer       Das zu verschiebende Layer (ist bereits Teil der Collection).
+    //  * @param targetZ     Der gewünschte neue zIndex.
+    //  */
+    // private moveImageryLayerToZIndex(
+    //   collection: ImageryLayerCollection,
+    //   layer: ImageryLayer,
+    //   targetZ: number,
+    // ): void {
+    //   // fire-and-forget; Thread-Sicherheit via Mutex
+    //   void this.imageryZMutex.runExclusive(async () => {
+    //     // -------------------------------------------------
+    //     // 1️⃣  Neues zIndex setzen (überschreibt das alte)
+    //     // -------------------------------------------------
+    //     (layer as any).zIndex = targetZ;
+    //     // -------------------------------------------------
+    //     // 2️⃣  Aktuelle Position bestimmen
+    //     // -------------------------------------------------
+    //     const curIdx = collection.indexOf(layer);
+    //     if (curIdx === -1) {
+    //       throw new Error('Der übergebene Layer ist nicht Teil der Collection.');
+    //     }
+    //     // -------------------------------------------------
+    //     // 3️⃣  Nach oben schieben, solange Vorgänger einen
+    //     //     größeren zIndex hat (stabile Sortierung)
+    //     // -------------------------------------------------
+    //     let idx = curIdx;
+    //     while (
+    //       idx > 0 && // nicht am Anfang
+    //       collection[idx - 1].zIndex > targetZ // Vorgänger hat höheren zIndex
+    //     ) {
+    //       // `raise` vertauscht das aktuelle Element mit seinem Vorgänger
+    //       collection.raise(collection[idx]);
+    //       idx--;
+    //     }
+    //     // -------------------------------------------------
+    //     // 4️⃣  Nach unten schieben, falls das neue zIndex
+    //     //     größer ist als das der nachfolgenden Elemente
+    //     // -------------------------------------------------
+    //     while (
+    //       idx < collection.length - 1 && // nicht am Ende
+    //       collection[idx + 1].zIndex < targetZ // Nachfolger hat kleineren zIndex
+    //     ) {
+    //       // `lower` vertauscht das aktuelle Element mit seinem Nachfolger
+    //       collection.lower(collection[idx]);
+    //       idx++;
+    //     }
+    //   });
+    //   // -------------------------------------------------
+    //   // 5️⃣  Optional: Guard‑Clause für extreme Werte
+    //   // -------------------------------------------------
+    //   // (Falls du Min/Max‑Grenzen definieren willst)
+    //   // if (targetZ < MIN_Z) (layer as any).zIndex = MIN_Z;
+    //   // if (targetZ > MAX_Z) (layer as any).zIndex = MAX_Z;
+    // }
+    // private moveTilesetToIndex(tileset: Cesium3DTileset, index: number): void {
+    //   const primitives = this.viewer.scene.primitives;
+    //   primitives.remove(tileset);
+    //   if (index >= primitives.length) {
+    //     primitives.add(tileset);
+    //   } else {
+    //     const tilesets = [];
+    //     for (let i = 0; i < primitives.length; i++) {
+    //       const current = primitives.get(i);
+    //       if (i === index) tilesets.push(tileset);
+    //       if (current !== tileset) tilesets.push(current);
+    //     }
+    //     primitives.removeAll();
+    //     tilesets.forEach(t => primitives.add(t));
+    //   }
+    // }
+    // private moveDataSourceToIndex(
+    //   collection: DataSourceCollection,
+    //   dataSource: DataSource,
+    //   zIndex: number,
+    // ): void {
+    //   // 1. Layer entfernen
+    //   collection.remove(dataSource);
+    //   // 2. Layer an der richtigen Position wieder hinzufügen
+    //   // Cesium hat keine direkte "setZIndex"-Methode für DataSources,
+    //   // also müssen wir die Reihenfolge manuell steuern.
+    //   // Da DataSourceCollection keine Z-Index-Unterstützung hat,
+    //   // müssen wir alle Layer neu sortieren.
+    //   //    const dataSources: DataSource[] = [];
+    //   const tempDataSources: DataSource[] = [];
+    //   // Alle Layer sammeln
+    //   for (let i = 0; i < collection.length; i++) {
+    //     tempDataSources.push(collection.get(i));
+    //   }
+    //   // Sortieren nach zIndex (falls vorhanden) oder Reihenfolge
+    //   tempDataSources.sort((a, b) => {
+    //     const aZIndex = (a as any).zIndex || 0;
+    //     const bZIndex = (b as any).zIndex || 0;
+    //     return aZIndex - bZIndex;
+    //   });
+    //   // Den Layer mit dem neuen zIndex einfügen
+    //   (dataSource as any).zIndex = zIndex;
+    //   tempDataSources.push(dataSource);
+    //   // Neu sortieren
+    //   tempDataSources.sort((a, b) => {
+    //     const aZIndex = (a as any).zIndex || 0;
+    //     const bZIndex = (b as any).zIndex || 0;
+    //     return aZIndex - bZIndex;
+    //   });
+    //   // Collection leeren und neu befüllen
+    //   collection.removeAll();
+    //   tempDataSources.forEach(ds => collection.add(ds));
+    // }
+    wrapImageryLayer(layer) {
+        const collection = this.viewer.imageryLayers;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let iLOptions = {};
+        return {
+            getOptions: () => {
+                return iLOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                iLOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => layer.alpha,
+            setOpacity: (value) => {
+                layer.alpha = value;
+            },
+            getZIndex: () => {
+                for (let i = 0; i < collection.length; i++) {
+                    if (collection.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    await this.sortImageryLayers(collection, layer, zIndex);
+                }
+            },
+            remove: () => collection.remove(layer),
+        };
+    }
+    wrapTilesetLayer(layer) {
+        const collection = this.viewer.scene.primitives;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let c3dTSOptions = {};
+        return {
+            getOptions: () => {
+                return c3dTSOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                c3dTSOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => {
+                const style = layer.style;
+                if (style.color && typeof style.color === 'string') {
+                    const colorStr = style.color;
+                    const match = colorStr.match(/color\(.*?,([\d.]+)\)/);
+                    return match ? parseFloat(match[1]) : 1.0;
+                }
+                return 1.0;
+            },
+            setOpacity: (value) => {
+                const currentColor = layer.style.color;
+                let colorExpr;
+                if (typeof currentColor === 'string') {
+                    const colorStr = currentColor;
+                    const colorPart = colorStr.replace(/color\((.*?),[\d.]+\)/, `color($1, ${value})`);
+                    colorExpr = colorPart.includes('color')
+                        ? colorPart
+                        : `color('white', ${value})`;
+                }
+                else {
+                    colorExpr = `color('white', ${value})`;
+                }
+                layer.style = new this.Cesium.Cesium3DTileStyle({
+                    color: colorExpr,
+                    colorBlendMode: this.Cesium.ColorBlendMode.MIX,
+                });
+            },
+            getZIndex: () => {
+                const primitives = this.viewer.scene.primitives;
+                for (let i = 0; i < primitives.length; i++) {
+                    if (primitives.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    this.sort3DTileSets(collection, layer, zIndex);
+                    //this.moveTilesetToIndex(layer, zIndex);
+                }
+            },
+            setColor: (color, opacity = 1.0) => {
+                const cssColor = color instanceof this.Cesium.Color
+                    ? color.toCssHexString()
+                    : color.replace(/[#\s]/g, '');
+                layer.style = new this.Cesium.Cesium3DTileStyle({
+                    color: `color('${cssColor}', ${opacity})`,
+                    colorBlendMode: this.Cesium.ColorBlendMode.MIX,
+                });
+            },
+            setStyle: (style) => {
+                layer.style =
+                    style instanceof this.Cesium.Cesium3DTileStyle
+                        ? style
+                        : new this.Cesium.Cesium3DTileStyle(style);
+            },
+            remove: () => this.viewer.scene.primitives.remove(layer),
+        };
+    }
+    wrapDataSourceLayer(layer) {
+        const collection = this.viewer.dataSources;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+        let dsOptions = {};
+        return {
+            getOptions: () => {
+                return dsOptions;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- matches ILayer interface contract
+            setOptions(options) {
+                dsOptions = options;
+            },
+            getVisible: () => {
+                return layer.show;
+            },
+            setVisible: (value) => {
+                layer.show = value;
+            },
+            getOpacity: () => 1.0, //todo
+            setOpacity: (value) => {
+                if (layer.__vmapLockOpacity)
+                    return;
+                layer.entities.values.forEach((entity) => {
+                    // Helper-Funktion zum Setzen der Opacity
+                    const setColorOpacity = (colorProperty, defaultColor) => {
+                        const { Color: CesiumColor, JulianDate } = this.Cesium;
+                        const applyAlpha = (color) => CesiumColor.fromAlpha(color ?? defaultColor, value, new CesiumColor());
+                        if (!colorProperty) {
+                            return new this.Cesium.ConstantProperty(applyAlpha(defaultColor));
+                        }
+                        const maybeProperty = colorProperty;
+                        if (maybeProperty && typeof maybeProperty.getValue === 'function') {
+                            const currentColor = maybeProperty.getValue(this.viewer?.clock?.currentTime ?? new JulianDate(), new CesiumColor());
+                            const nextColor = applyAlpha(currentColor);
+                            if (typeof maybeProperty.setValue === 'function') {
+                                maybeProperty.setValue(nextColor);
+                                return maybeProperty;
+                            }
+                            return new this.Cesium.ConstantProperty(nextColor);
+                        }
+                        if (colorProperty instanceof this.Cesium.Color) {
+                            return new this.Cesium.ConstantProperty(applyAlpha(colorProperty));
+                        }
+                        return new this.Cesium.ConstantProperty(applyAlpha(defaultColor));
+                    };
+                    // Polygone
+                    if (entity.polygon) {
+                        const material = entity.polygon.material;
+                        if (material instanceof Cesium.ColorMaterialProperty) {
+                            const color = material.color;
+                            material.color = setColorOpacity(color, Cesium.Color.WHITE);
+                        }
+                        else if (material instanceof Cesium.ImageMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                    }
+                    // Polylinien
+                    if (entity.polyline) {
+                        const material = entity.polyline.material;
+                        if (material instanceof Cesium.ColorMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                        else if (material instanceof Cesium.PolylineOutlineMaterialProperty) {
+                            material.color = setColorOpacity(material.color, Cesium.Color.WHITE);
+                        }
+                    }
+                    // Punkte
+                    if (entity.point) {
+                        entity.point.color = setColorOpacity(entity.point.color, Cesium.Color.WHITE);
+                    }
+                    // Billboards
+                    if (entity.billboard) {
+                        entity.billboard.color = setColorOpacity(entity.billboard.color, Cesium.Color.WHITE);
+                    }
+                    // Labels
+                    if (entity.label) {
+                        entity.label.fillColor = setColorOpacity(entity.label.fillColor, Cesium.Color.BLACK);
+                        if (entity.label.outlineColor) {
+                            entity.label.outlineColor = setColorOpacity(entity.label.outlineColor, Cesium.Color.BLACK);
+                        }
+                    }
+                    // 3D-Modelle (falls vorhanden)
+                    if (entity.model) {
+                        entity.model.color = setColorOpacity(entity.model.color, Cesium.Color.WHITE);
+                    }
+                });
+            },
+            getZIndex: () => {
+                for (let i = 0; i < collection.length; i++) {
+                    if (collection.get(i) === layer)
+                        return i;
+                }
+                return -1;
+            },
+            setZIndex: async (zIndex) => {
+                if (zIndex !== undefined) {
+                    await this.sortDataSources(collection, layer, zIndex);
+                }
+            },
+            remove: () => collection.remove(layer),
+        };
+    }
+}