@vcmap/core 6.0.7 → 6.1.0-rc.2

package/src/map/vcsMap.ts

@@ -18,6 +18,8 @@ import type Viewpoint from '../util/viewpoint.js';
 import type Layer from '../layer/layer.js';
 import type { MapEvent } from '../interaction/abstractInteraction.js';
 import type { DisableMapControlOptions } from '../util/mapCollection.js';
+import type VectorClusterGroup from '../vectorCluster/vectorClusterGroup.js';
+import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
 function getLogger(): Logger {
   return getLoggerByName('vcMap');
@@ -106,7 +108,9 @@ class VcsMap<
    */
   fallbackToCurrentMap: boolean;
 
-  private _visualizations: Map<string, Set<V>>;
+  private _visualizations = new Map<string, Set<V>>();
+
+  private _clusterVisualizations = new Map<string, Set<V>>();
 
   private _state: MapState;
 
@@ -115,6 +119,16 @@ class VcsMap<
    */
   stateChanged: VcsEvent<MapState>;
 
+  /**
+   * Event raised when a visualization is added to the map
+   */
+  visualizationAdded: VcsEvent<VisualisationType>;
+
+  /**
+   * Event raised when a visualization is removed from the map
+   */
+  visualizationRemoved: VcsEvent<VisualisationType>;
+
   /**
    * Event raised then the map has a pointer interaction. Raises {@link MapEvent}.
    */
@@ -125,7 +139,7 @@ class VcsMap<
    */
   private _splitPosition: number;
 
-  private _postRender: VcsEvent<VcsMapRenderEvent<V>>;
+  private _postRender = new VcsEvent<VcsMapRenderEvent<V>>();
 
   /**
    * @param  options
@@ -162,17 +176,17 @@ class VcsMap<
       defaultOptions.fallbackToCurrentMap,
     );
 
-    this._visualizations = new Map();
-
     this._state = MapState.INACTIVE;
 
     this.stateChanged = new VcsEvent();
 
+    this.visualizationAdded = new VcsEvent();
+
+    this.visualizationRemoved = new VcsEvent();
+
     this.pointerInteractionEvent = new VcsEvent();
 
     this._splitPosition = 0.5;
-
-    this._postRender = new VcsEvent();
   }
 
   /**
@@ -253,12 +267,24 @@ class VcsMap<
     [...this._layerCollection].forEach((l) => {
       l.removedFromMap(this);
     });
+    [...this._layerCollection.vectorClusterGroups].forEach((g) => {
+      g.removedFromMap(this);
+    });
+
     this._layerCollection = layerCollection;
 
     if (this.active) {
       [...this._layerCollection].forEach((l) => {
-        // eslint-disable-next-line no-void
-        void l.mapActivated(this);
+        l.mapActivated(this).catch((_e) => {
+          this.getLogger().error(`Failed to activate map on layer: ${l.name}`);
+        });
+      });
+      [...this._layerCollection.vectorClusterGroups].forEach((g) => {
+        g.mapActivated(this).catch((_e) => {
+          this.getLogger().error(
+            `Failed to activate map on vector cluster group: ${g.name}`,
+          );
+        });
       });
     }
 
@@ -293,16 +319,28 @@ class VcsMap<
       cb();
     });
 
+    const added = (i: Layer | VectorClusterGroup): void => {
+      if (this.active) {
+        i.mapActivated(this).catch((_e) => {
+          this.getLogger().error(`Failed to activate map on layer: ${i.name}`);
+        });
+      }
+    };
+
+    const removed = (i: Layer | VectorClusterGroup): void => {
+      i.removedFromMap(this);
+    };
+
     this._collectionListeners = [
       this.layerCollection.moved.addEventListener((layer) => {
         this.indexChanged(layer);
       }),
-      this.layerCollection.added.addEventListener((layer) => {
-        this._layerAdded(layer);
-      }),
-      this.layerCollection.removed.addEventListener((layer) => {
-        this._layerRemoved(layer);
-      }),
+      this.layerCollection.added.addEventListener(added),
+      this.layerCollection.removed.addEventListener(removed),
+      this.layerCollection.vectorClusterGroups.added.addEventListener(added),
+      this.layerCollection.vectorClusterGroups.removed.addEventListener(
+        removed,
+      ),
     ];
   }
 
@@ -342,28 +380,20 @@ class VcsMap<
   // eslint-disable-next-line no-unused-vars,class-methods-use-this
   indexChanged(_layer: Layer): void {}
 
-  /**
-   * is called if a layer is added to the layerCollection.
-   */
-  private _layerAdded(layer: Layer): void {
-    if (this.active) {
-      // eslint-disable-next-line no-void
-      void layer.mapActivated(this);
-    }
-  }
-
-  /**
-   * is called if a layer is added to the layerCollection.
-   */
-  private _layerRemoved(layer: Layer): void {
-    layer.removedFromMap(this);
-  }
-
   /**
    * Validates a visualization. A visualization must have the vcsLayeName symbol set and a layer with said name must be
    * part of the maps layerCollection.
    */
-  validateVisualization(item: V): item is V & { [vcsLayerName]: string } {
+  validateVisualization(item: V): item is V & {
+    [vcsLayerName]?: string;
+    [vectorClusterGroupName]?: string;
+  } {
+    const vectorCluster = (item as OLLayer)[vectorClusterGroupName];
+    if (vectorCluster) {
+      return this.layerCollection.vectorClusterGroups.hasKey(
+        vectorCluster,
+      ) as boolean;
+    }
     const layerName = item[vcsLayerName];
     if (layerName == null) {
       this.getLogger().warning('item is missing vcsLayerName symbol');
@@ -376,45 +406,77 @@ class VcsMap<
   /**
    * Adds a visualization to the visualizations map for its layer. The visualization must be valid, use validateVisualization first
    */
-  addVisualization(item: V): void {
+  addVisualization(item: V & { [vectorClusterGroupName]?: string }): void {
     if (!this.validateVisualization(item)) {
       throw new Error(
         'Visualization item is not valid, validate before adding',
       );
     }
-    const layerName = item[vcsLayerName];
-    if (!this._visualizations.has(layerName)) {
-      this._visualizations.set(layerName, new Set());
+    let name: string;
+    let setMap;
+    if (item[vectorClusterGroupName]) {
+      name = item[vectorClusterGroupName];
+      setMap = this._clusterVisualizations;
+    } else {
+      name = item[vcsLayerName]!;
+      setMap = this._visualizations;
+    }
+
+    if (!setMap.has(name)) {
+      setMap.set(name, new Set());
     }
-    (this._visualizations.get(layerName) as Set<V>).add(item);
+    (setMap.get(name) as Set<V>).add(item);
+    this.visualizationAdded.raiseEvent(item);
   }
 
   /**
    * Removes a visualization
    */
-  removeVisualization(item: V): void {
-    const layerName = item[vcsLayerName];
-    const viz = layerName ? this._visualizations.get(layerName) : undefined;
-    if (viz && layerName) {
+  removeVisualization(item: V & { [vectorClusterGroupName]?: string }): void {
+    let name: string | undefined;
+    let setMap;
+    if (item[vectorClusterGroupName]) {
+      name = item[vectorClusterGroupName];
+      setMap = this._clusterVisualizations;
+    } else {
+      name = item[vcsLayerName];
+      setMap = this._visualizations;
+    }
+
+    const viz = name ? setMap.get(name) : undefined;
+    if (viz && name) {
       viz.delete(item);
       if (viz.size === 0) {
-        this._visualizations.delete(layerName);
+        setMap.delete(name);
       }
+      this.visualizationRemoved.raiseEvent(item);
     }
   }
 
   /**
-   * Gets the visualizations for a specific layer.
+   * Gets the visualizations for a specific layer
    */
   getVisualizationsForLayer(layer: Layer): Set<V> | undefined {
     return this._visualizations.get(layer.name);
   }
 
+  /**
+   * Gets the visualizations of a vector cluster group
+   */
+  getVisualizationsForVectorClusterGroup(
+    group: VectorClusterGroup,
+  ): Set<V> | undefined {
+    return this._clusterVisualizations.get(group.name);
+  }
+
   /**
    * Get all visualizations added to this map.
    */
   getVisualizations(): V[] {
-    return [...this._visualizations.values()]
+    return [
+      ...this._visualizations.values(),
+      ...this._clusterVisualizations.values(),
+    ]
       .map((layerVisualizations) => [...layerVisualizations])
       .flat();
   }
@@ -433,9 +495,12 @@ class VcsMap<
         return;
       }
       this._state = MapState.ACTIVE;
-      await Promise.all(
-        [...this.layerCollection].map((layer) => layer.mapActivated(this)),
-      );
+      await Promise.all([
+        ...[...this.layerCollection].map((layer) => layer.mapActivated(this)),
+        ...[...this.layerCollection.vectorClusterGroups].map((clusterGroup) =>
+          clusterGroup.mapActivated(this),
+        ),
+      ]);
       if (this._state !== MapState.ACTIVE) {
         return;
       }
@@ -453,6 +518,9 @@ class VcsMap<
       [...this.layerCollection].forEach((layer) => {
         layer.mapDeactivated(this);
       });
+      [...this.layerCollection.vectorClusterGroups].forEach((clusterGroup) =>
+        clusterGroup.mapDeactivated(this),
+      );
       this.stateChanged.raiseEvent(this._state);
     }
   }
@@ -559,11 +627,17 @@ class VcsMap<
       [...this.layerCollection].forEach((l) => {
         l.removedFromMap(this);
       });
+      [...this.layerCollection.vectorClusterGroups].forEach((g) => {
+        g.removedFromMap(this);
+      });
     }
     if (this.stateChanged) {
       this.stateChanged.destroy();
     }
 
+    this.visualizationAdded.destroy();
+    this.visualizationRemoved.destroy();
+
     if (this.destroyLayerCollection && this.layerCollection) {
       this.layerCollection.destroy();
     }

package/src/ol/ol.d.ts

@@ -22,7 +22,10 @@ import {
   originalFeatureSymbol,
 } from '../layer/vectorSymbols.js';
 import { vcsLayerName } from '../layer/layerSymbols.js';
-import { isProvidedFeature } from '../featureProvider/featureProviderSymbols.js';
+import {
+  isProvidedFeature,
+  isProvidedClusterFeature,
+} from '../featureProvider/featureProviderSymbols.js';
 import {
   globalHidden,
   hidden,
@@ -42,6 +45,7 @@ import {
   globalHiderLastUpdated,
 } from '../layer/vectorHelpers.js';
 import { validityPlaceholder } from '../util/editor/interactions/createPolygonInteraction.js';
+import { vectorClusterGroupName } from '../vectorCluster/vectorClusterSymbols.js';
 
 declare module 'ol/geom.js' {
   interface Geometry {
@@ -101,6 +105,7 @@ declare module 'ol/index.js' {
     [vectorStyleSymbol]?: VectorStyleItem;
     [featureArcStruct]?: ArcStruct;
     [isProvidedFeature]?: boolean;
+    [isProvidedClusterFeature]?: boolean;
     [globalHidden]?: boolean;
     [hidden]?: boolean;
     [highlighted]?: VectorStyleItem;
@@ -113,6 +118,7 @@ declare module 'ol/index.js' {
     [handlerSymbol]?: AxisAndPlanes;
     [vertexSymbol]?: boolean;
     [createSync]?: boolean;
+    [vectorClusterGroupName]?: string;
   }
 
   class CanvasTileRenderer extends CanvasImmediateRenderer {
@@ -141,6 +147,7 @@ declare module 'ol/style.js' {
 declare module 'ol/layer.js' {
   interface Layer {
     [vcsLayerName]: string;
+    [vectorClusterGroupName]?: string;
   }
 }
 

package/src/ol/source/{ClusterEnhancedVectorSource.js → ClusterEnhancedVectorSource.ts}

@@ -1,5 +1,5 @@
-import { getUid } from 'ol/util.js';
 import VectorSource from 'ol/source/Vector.js';
+import Feature from 'ol/Feature.js';
 
 /**
  * @class
@@ -11,15 +11,12 @@ class ClusterEnhancedVectorSource extends VectorSource {
    * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
    * @param {boolean=} silent
    */
-  removeFeature(feature, silent) {
-    const featureKey = getUid(feature);
-    if (featureKey in this.nullGeometryFeatures_) {
-      delete this.nullGeometryFeatures_[featureKey];
-    } else if (this.featuresRtree_) {
-      this.featuresRtree_.remove(feature);
+  removeFeature(feature: Feature, silent?: boolean): void {
+    if (!feature) {
+      return;
     }
-    this.removeFeatureInternal(feature);
-    if (!silent) {
+    const removed = this.removeFeatureInternal(feature);
+    if (removed && !silent) {
       this.changed();
     }
   }
@@ -28,7 +25,7 @@ class ClusterEnhancedVectorSource extends VectorSource {
    * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
    * @param {boolean=} silent
    */
-  addFeature(feature, silent) {
+  addFeature(feature: Feature, silent?: boolean): void {
     this.addFeatureInternal(feature);
     if (!silent) {
       this.changed();

package/src/ol/source/VcsCluster.ts

@@ -0,0 +1,58 @@
+import Cluster, { type Options } from 'ol/source/Cluster.js';
+import Feature from 'ol/Feature.js';
+import { Point } from 'ol/geom.js';
+import { vectorClusterGroupName } from '../../vectorCluster/vectorClusterSymbols.js';
+import { hidden } from '../../layer/featureVisibility.js';
+
+/**
+ * @class
+ * @extends {import("ol/source/Cluster").default}
+ * @memberOf ol
+ */
+class VcsCluster extends Cluster<Feature> {
+  private _paused = false;
+
+  constructor(
+    props: Options<Feature>,
+    private _name: string,
+  ) {
+    props.geometryFunction =
+      props.geometryFunction ??
+      ((feature: Feature): Point | null => {
+        if (feature[hidden]) {
+          return null;
+        }
+        return feature.getGeometry() as Point;
+      });
+
+    super(props);
+    /**
+     * @type {boolean}
+     */
+    this._paused = false;
+  }
+
+  addFeatures(features: Feature[]): void {
+    features.forEach((f) => {
+      f[vectorClusterGroupName] = this._name;
+    });
+    super.addFeatures(features);
+  }
+
+  get paused(): boolean {
+    return this._paused;
+  }
+
+  set paused(pause: boolean) {
+    this._paused = pause;
+  }
+
+  refresh(): void {
+    if (this._paused) {
+      return;
+    }
+    super.refresh();
+  }
+}
+
+export default VcsCluster;

package/src/util/clipping/clippingPolygonHelper.ts

@@ -0,0 +1,86 @@
+import {
+  Cesium3DTileset,
+  ClippingPolygon,
+  ClippingPolygonCollection,
+  Globe,
+} from '@vcmap-cesium/engine';
+import type CesiumMap from '../../map/cesiumMap.js';
+import { vcsLayerName } from '../../layer/layerSymbols.js';
+
+export function getTargetTilesets(
+  map: CesiumMap,
+  layerNames: string[] | 'all' = 'all',
+): Cesium3DTileset[] {
+  const tilesets = map
+    .getVisualizations()
+    .filter((v) => v instanceof Cesium3DTileset);
+  if (Array.isArray(layerNames)) {
+    return tilesets.filter((v) => layerNames.includes(v[vcsLayerName]));
+  }
+  return tilesets;
+}
+
+export function addClippingPolygon(
+  clippee: Globe | Cesium3DTileset,
+  polygon: ClippingPolygon | undefined,
+): void {
+  if (polygon) {
+    if (clippee.clippingPolygons === undefined) {
+      clippee.clippingPolygons = new ClippingPolygonCollection();
+    }
+    if (!clippee.clippingPolygons.contains(polygon)) {
+      clippee.clippingPolygons.add(polygon);
+    }
+  }
+}
+
+export function removeClippingPolygon(
+  clippee: Globe | Cesium3DTileset,
+  polygon: ClippingPolygon | undefined,
+): void {
+  if (
+    polygon &&
+    clippee.clippingPolygons &&
+    clippee.clippingPolygons.contains(polygon)
+  ) {
+    clippee.clippingPolygons.remove(polygon);
+  }
+}
+
+export function addClippingPolygonObjectToMap(
+  map: CesiumMap,
+  polygon: ClippingPolygon | undefined,
+  terrain: boolean,
+  layerNames: string[] | 'all',
+): void {
+  if (terrain) {
+    const globe = map.getScene()?.globe;
+    if (globe) {
+      addClippingPolygon(globe, polygon);
+    }
+  }
+
+  const tilesets = getTargetTilesets(map, layerNames);
+  tilesets.forEach((tileset) => {
+    addClippingPolygon(tileset, polygon);
+  });
+}
+
+export function removeClippingPolygonFromMap(
+  map: CesiumMap,
+  polygon: ClippingPolygon | undefined,
+  terrain: boolean,
+  layerNames: string[] | 'all',
+): void {
+  if (terrain) {
+    const globe = map.getScene()?.globe;
+    if (globe) {
+      removeClippingPolygon(globe, polygon);
+    }
+  }
+
+  const tilesets = getTargetTilesets(map, layerNames);
+  tilesets.forEach((tileset) => {
+    removeClippingPolygon(tileset, polygon);
+  });
+}