@vcmap/core 5.0.0-rc.36 → 5.0.0-rc.38

package/src/layer/cesium/vectorContext.ts

@@ -301,6 +301,8 @@ class VectorContext implements CesiumVectorContext {
 
   featureToLabelMap: Map<Feature, Array<Label>> = new Map();
 
+  features: Set<Feature> = new Set();
+
   splitDirection: SplitDirection;
 
   private _rootCollection: PrimitiveCollection;
@@ -346,14 +348,16 @@ class VectorContext implements CesiumVectorContext {
     feature: Feature,
     allowPicking = false,
   ): void {
-    addPrimitiveToContext(
-      primitives,
-      feature,
-      allowPicking,
-      this.primitives,
-      this.featureToPrimitiveMap,
-      this.splitDirection,
-    );
+    if (this.features.has(feature)) {
+      addPrimitiveToContext(
+        primitives,
+        feature,
+        allowPicking,
+        this.primitives,
+        this.featureToPrimitiveMap,
+        this.splitDirection,
+      );
+    }
   }
 
   addScaledPrimitives(
@@ -367,15 +371,17 @@ class VectorContext implements CesiumVectorContext {
     feature: Feature,
     allowPicking = false,
   ): void {
-    addPrimitiveToContext(
-      primitives,
-      feature,
-      allowPicking,
-      this.scaledPrimitives,
-      this.featureToScaledPrimitiveMap,
-      this.splitDirection,
-    );
-    this._scaledDirty.value = true;
+    if (this.features.has(feature)) {
+      addPrimitiveToContext(
+        primitives,
+        feature,
+        allowPicking,
+        this.scaledPrimitives,
+        this.featureToScaledPrimitiveMap,
+        this.splitDirection,
+      );
+      this._scaledDirty.value = true;
+    }
   }
 
   addBillboards(
@@ -383,14 +389,16 @@ class VectorContext implements CesiumVectorContext {
     feature: Feature,
     allowPicking = false,
   ): void {
-    addPrimitiveToContext(
-      billboardOptions,
-      feature,
-      allowPicking,
-      this.billboards,
-      this.featureToBillboardMap,
-      this.splitDirection,
-    );
+    if (this.features.has(feature)) {
+      addPrimitiveToContext(
+        billboardOptions,
+        feature,
+        allowPicking,
+        this.billboards,
+        this.featureToBillboardMap,
+        this.splitDirection,
+      );
+    }
   }
 
   addLabels(
@@ -398,20 +406,23 @@ class VectorContext implements CesiumVectorContext {
     feature: Feature,
     allowPicking = false,
   ): void {
-    addPrimitiveToContext(
-      labelOptions,
-      feature,
-      allowPicking,
-      this.labels,
-      this.featureToLabelMap,
-      this.splitDirection,
-    );
+    if (this.features.has(feature)) {
+      addPrimitiveToContext(
+        labelOptions,
+        feature,
+        allowPicking,
+        this.labels,
+        this.featureToLabelMap,
+        this.splitDirection,
+      );
+    }
   }
 
   /**
    * @param  feature
    */
   removeFeature(feature: Feature): void {
+    this.features.delete(feature);
     removeFeatureFromMap(feature, this.featureToPrimitiveMap, this.primitives);
     this._scaledDirty.value = removeFeatureFromMap(
       feature,
@@ -472,6 +483,7 @@ class VectorContext implements CesiumVectorContext {
     this.featureToPrimitiveMap.clear();
     this._scaledDirty.value = this.featureToScaledPrimitiveMap.size > 0;
     this.featureToScaledPrimitiveMap.clear();
+    this.features.clear();
   }
 
   /**
@@ -490,6 +502,7 @@ class VectorContext implements CesiumVectorContext {
     this.featureToBillboardMap.clear();
     this.featureToLabelMap.clear();
     this.featureToPrimitiveMap.clear();
+    this.features.clear();
     this.featureToScaledPrimitiveMap.clear();
     this._postRenderListener();
   }

package/src/layer/cesium/vectorRasterTileCesiumImpl.ts

@@ -43,7 +43,7 @@ class VectorRasterTileCesiumImpl extends RasterLayerCesiumImpl {
     this.tileSize = options.tileSize;
   }
 
-  getCesiumLayer(): CesiumImageryLayer {
+  getCesiumLayer(): Promise<CesiumImageryLayer> {
     this.imageryProvider = new VectorTileImageryProvider({
       tileProvider: this.tileProvider,
       tileSize: this.tileSize,
@@ -64,13 +64,14 @@ class VectorRasterTileCesiumImpl extends RasterLayerCesiumImpl {
         extent[3],
       );
     }
-    const imageryLayer = new CesiumImageryLayer(
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      this.imageryProvider,
-      layerOptions,
+    return Promise.resolve(
+      new CesiumImageryLayer(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.imageryProvider,
+        layerOptions,
+      ),
     );
-    return imageryLayer;
   }
 
   /**

package/src/layer/cesium/wmsCesiumImpl.ts

@@ -32,7 +32,7 @@ class WmsCesiumImpl extends RasterLayerCesiumImpl {
     this.tileSize = options.tileSize;
   }
 
-  getCesiumLayer(): CesiumImageryLayer {
+  getCesiumLayer(): Promise<CesiumImageryLayer> {
     const parameters = { ...this.parameters };
     if (this.highResolution) {
       parameters.width = String(this.tileSize[0] * 2);
@@ -68,7 +68,9 @@ class WmsCesiumImpl extends RasterLayerCesiumImpl {
       alpha: this.opacity,
       splitDirection: this.splitDirection,
     };
-    return new CesiumImageryLayer(imageryProvider, layerOptions);
+    return Promise.resolve(
+      new CesiumImageryLayer(imageryProvider, layerOptions),
+    );
   }
 }
 

package/src/layer/cesium/wmtsCesiumImpl.ts

@@ -47,7 +47,7 @@ class WmtsCesiumImpl extends RasterLayerCesiumImpl {
     this.matrixIds = options.matrixIds;
   }
 
-  getCesiumLayer(): CesiumImageryLayer {
+  getCesiumLayer(): Promise<CesiumImageryLayer> {
     const currentUrl = this.url as string;
     // This is a bug in Cesium, they cant cope with {Layer} placeholder..
     const url =
@@ -85,7 +85,9 @@ class WmtsCesiumImpl extends RasterLayerCesiumImpl {
       alpha: this.opacity,
       splitDirection: this.splitDirection,
     };
-    return new CesiumImageryLayer(imageryProvider, layerOptions);
+    return Promise.resolve(
+      new CesiumImageryLayer(imageryProvider, layerOptions),
+    );
   }
 }
 

package/src/layer/featureVisibility.ts

@@ -105,6 +105,7 @@ export function resetOriginalStyle(feature: HighlightableFeature): void {
   if (!(feature[globalHidden] || feature[hidden] || feature[highlighted])) {
     const style = feature[originalStyle];
     if (
+      style &&
       (feature instanceof Cesium3DTileFeature ||
         feature instanceof Cesium3DTilePointFeature) &&
       featureExists(feature)
@@ -383,21 +384,12 @@ class FeatureVisibility {
 
   hasHiddenFeature(
     id: string | number,
-    feature:
-      | import('ol').Feature<import('ol/geom/Geometry.js').default>
-      | import('@vcmap-cesium/engine').Cesium3DTileFeature
-      | import('@vcmap-cesium/engine').Entity,
+    feature: HighlightableFeature,
   ): boolean {
     return this.hiddenObjects[id] && this.hiddenObjects[id].has(feature);
   }
 
-  addHiddenFeature(
-    id: string | number,
-    feature:
-      | import('ol').Feature<import('ol/geom/Geometry.js').default>
-      | import('@vcmap-cesium/engine').Cesium3DTileFeature
-      | import('@vcmap-cesium/engine').Entity,
-  ): void {
+  addHiddenFeature(id: string | number, feature: HighlightableFeature): void {
     if (this.hiddenObjects[id]) {
       cacheOriginalStyle(feature);
       this.hiddenObjects[id].add(feature);

package/src/layer/layer.ts

@@ -44,6 +44,12 @@ export type LayerOptions = VcsObjectOptions & {
    */
   hiddenObjectIds?: string[];
   copyright?: CopyrightOptions;
+
+  /**
+   * Optional Id to synchronize with the vcPublisher Datasources. This can also be used to track a connection
+   * to other sources of data.
+   */
+  datasourceId?: string;
 };
 
 export type LayerImplementationOptions = {
@@ -75,6 +81,7 @@ class Layer<
       url: undefined,
       hiddenObjectIds: [],
       copyright: undefined,
+      datasourceId: undefined,
     };
   }
 
@@ -138,6 +145,12 @@ class Layer<
 
   private _locale: string;
 
+  /**
+   * Optional Id to synchronize with the vcPublisher Datasources. This can also be used to track a connection
+   * to other sources of data.
+   */
+  datasourceId?: string;
+
   constructor(options: LayerOptions) {
     super(options);
     const defaultOptions = Layer.getDefaultOptions();
@@ -193,6 +206,8 @@ class Layer<
     this.featureProvider = undefined;
 
     this._locale = 'en';
+
+    this.datasourceId = options.datasourceId || defaultOptions.datasourceId;
   }
 
   /**
@@ -633,6 +648,10 @@ class Layer<
       config.copyright = { ...this.copyright };
     }
 
+    if (this.datasourceId !== defaultOptions.datasourceId) {
+      config.datasourceId = this.datasourceId;
+    }
+
     return config;
   }
 

package/src/layer/vectorLayer.ts

@@ -101,6 +101,11 @@ export type VectorGeometryFactoryType = {
     style: Style,
   ): GroundPolylineGeometry[];
   createLineGeometries(obj: unknown, style: Style): PolylineGeometry[];
+  createLineGeometries(
+    obj: unknown,
+    style: Style,
+    groundLevel?: number,
+  ): PolylineGeometry[];
 };
 
 export type VectorHeightInfo = {

package/src/layer/vectorProperties.ts

@@ -1279,6 +1279,197 @@ class VectorProperties {
     return values;
   }
 
+  /**
+   * The common vector properties for the input features.
+   * @param features Features for which the vector property values should be returned.
+   * @returns The common vector properties for the features. When a/all feature(s) does not has a property set, the layer or, if not set, the default value is returned. If features have different values for a property, the property key is not added to the returned obeject.
+   */
+  getValuesForFeatures(features: Feature[]): VectorPropertiesOptions {
+    const values: VectorPropertiesOptions = {};
+
+    /**
+     * Checks if all the values of the array are equal using fast-deep-equal.
+     * @param propertyValues An array of values for a specific property from different features.
+     * @returns Whether all values are equal.
+     */
+    function isAllEqual<T extends string | number | boolean | number[]>(
+      propertyValues: (T | undefined)[],
+    ): boolean {
+      return propertyValues.every((curr, index, array) => {
+        if (index === 0) {
+          return true;
+        }
+        return deepEqual(curr, array[0]);
+      });
+    }
+
+    const altitudeModeValues = features.map((f) => this.getAltitudeMode(f));
+    if (isAllEqual(altitudeModeValues)) {
+      values.altitudeMode = getAltitudeModeOptions(altitudeModeValues[0]);
+    }
+
+    const allowPickingValues = features.map((f) => this.getAllowPicking(f));
+    if (isAllEqual(allowPickingValues)) {
+      values.allowPicking = allowPickingValues[0];
+    }
+
+    const classificationTypeValues = features.map((f) =>
+      this.getClassificationType(f),
+    );
+    if (isAllEqual(classificationTypeValues)) {
+      values.classificationType = getClassificationTypeOptions(
+        classificationTypeValues[0],
+      );
+    }
+
+    const scaleByDistanceValues = features.map((f) =>
+      getNearFarValueOptions(this.getScaleByDistance(f)),
+    );
+    if (isAllEqual(scaleByDistanceValues)) {
+      values.scaleByDistance = scaleByDistanceValues[0];
+    }
+
+    const eyeOffsetValues = features.map((f) =>
+      getCartesian3Options(this.getEyeOffset(f)),
+    );
+    if (isAllEqual(eyeOffsetValues)) {
+      values.eyeOffset = eyeOffsetValues[0];
+    }
+
+    const heightAboveGroundValues = features.map((f) =>
+      this.getHeightAboveGround(f),
+    );
+    if (isAllEqual(heightAboveGroundValues)) {
+      values.heightAboveGround = heightAboveGroundValues[0];
+    }
+
+    const skirtValues = features.map((f) => this.getSkirt(f));
+    if (isAllEqual(skirtValues)) {
+      values.skirt = skirtValues[0];
+    }
+
+    const groundLevelValues = features.map((f) => this.getGroundLevel(f));
+    if (isAllEqual(groundLevelValues)) {
+      values.groundLevel = groundLevelValues[0];
+    }
+
+    const extrudedHeightValues = features.map((f) => this.getExtrudedHeight(f));
+    if (isAllEqual(extrudedHeightValues)) {
+      values.extrudedHeight = extrudedHeightValues[0];
+    }
+
+    const storeysAboveGroundValues = features.map((f) =>
+      this.getStoreysAboveGround(f),
+    );
+    if (isAllEqual(storeysAboveGroundValues)) {
+      values.storeysAboveGround = storeysAboveGroundValues[0];
+    }
+
+    const storeysBelowGroundValues = features.map((f) =>
+      this.getStoreysBelowGround(f),
+    );
+    if (isAllEqual(storeysBelowGroundValues)) {
+      values.storeysBelowGround = storeysBelowGroundValues[0];
+    }
+
+    const storeyHeightsAboveGroundValues = features.map((f) =>
+      this.getStoreyHeightsAboveGround(f),
+    );
+    if (isAllEqual(storeyHeightsAboveGroundValues)) {
+      values.storeyHeightsAboveGround = storeyHeightsAboveGroundValues[0];
+    }
+
+    const storeyHeightsBelowGroundValues = features.map((f) =>
+      this.getStoreyHeightsBelowGround(f),
+    );
+    if (isAllEqual(storeyHeightsBelowGroundValues)) {
+      values.storeyHeightsBelowGround = storeyHeightsBelowGroundValues[0];
+    }
+
+    const modelUrlValues = features.map((f) => this.getModelUrl(f));
+    if (isAllEqual(modelUrlValues)) {
+      values.modelUrl = modelUrlValues[0];
+    }
+
+    const modelScaleXValues = features.map((f) => this.getModelScaleX(f));
+    if (isAllEqual(modelScaleXValues)) {
+      values.modelScaleX = modelScaleXValues[0];
+    }
+
+    const modelScaleYValues = features.map((f) => this.getModelScaleY(f));
+    if (isAllEqual(modelScaleYValues)) {
+      values.modelScaleY = modelScaleYValues[0];
+    }
+
+    const modelScaleZValues = features.map((f) => this.getModelScaleZ(f));
+    if (isAllEqual(modelScaleZValues)) {
+      values.modelScaleZ = modelScaleZValues[0];
+    }
+
+    const modelHeadingValues = features.map((f) => this.getModelHeading(f));
+    if (isAllEqual(modelHeadingValues)) {
+      values.modelHeading = modelHeadingValues[0];
+    }
+
+    const modelPitchValues = features.map((f) => this.getModelPitch(f));
+    if (isAllEqual(modelPitchValues)) {
+      values.modelPitch = modelPitchValues[0];
+    }
+
+    const modelRollValues = features.map((f) => this.getModelRoll(f));
+    if (isAllEqual(modelRollValues)) {
+      values.modelRoll = modelRollValues[0];
+    }
+
+    const baseUrlValues = features.map((f) => this.getBaseUrl(f));
+    if (isAllEqual(baseUrlValues)) {
+      values.baseUrl = baseUrlValues[0];
+    }
+
+    return values;
+  }
+
+  /**
+   * Sets vector property options on a array of features. When a property equals the value that is returned from the getter of the VectorProperties instance, the property is unset from the feature(s).
+   * @param options The vector property options to be set on the features.
+   * @param features The features to set the vector property options on.
+   */
+  setValuesForFeatures(
+    options: VectorPropertiesOptions,
+    features: Feature[],
+  ): void {
+    const layerValues = this.getValues();
+
+    type UpdateConfig<
+      T extends keyof VectorPropertiesOptions = keyof VectorPropertiesOptions,
+    > = {
+      key: T;
+      set: boolean;
+      value: VectorPropertiesOptions[T];
+    };
+
+    const updates: UpdateConfig[] = [];
+    Object.entries(options).forEach(([key, value]) => {
+      const keyCast = key as keyof VectorPropertiesOptions;
+      updates.push({
+        key: keyCast,
+        value,
+        set: !deepEqual(value, layerValues[keyCast]),
+      });
+    });
+
+    features.forEach((f) => {
+      updates.forEach(({ key, set, value }) => {
+        const propertyName = `olcs_${key}`;
+        if (set) {
+          f.set(propertyName, value);
+        } else {
+          f.unset(propertyName);
+        }
+      });
+    });
+  }
+
   // XXX ugly design, this does NOT return a VcsMeta (missing version) but is missued to get config objects too often to change
   getVcsMeta(
     defaultOptions?: VectorPropertiesOptions,

package/src/layer/wfsLayer.ts

@@ -2,7 +2,7 @@ import WFSFormat from 'ol/format/WFS.js';
 import VectorLayer, { VectorOptions } from './vectorLayer.js';
 import Projection from '../util/projection.js';
 import { layerClassRegistry } from '../classRegistry.js';
-import { requestJson } from '../util/fetch.js';
+import { requestUrl } from '../util/fetch.js';
 
 export type WFSOptions = VectorOptions & {
   /**
@@ -18,6 +18,11 @@ export type WFSOptions = VectorOptions & {
    * additional config for [ol/format/WFS/writeGetFeature]{@link https://openlayers.org/en/latest/apidoc/ol.format.WFS.html} excluding featureType, featureNS and featurePrefix
    */
   getFeatureOptions?: Record<string, unknown>;
+
+  /**
+   * Version of the WFS Service, will be forwarded to the openlayers WFS Format.
+   */
+  version?: string;
 };
 
 /**
@@ -34,6 +39,8 @@ class WFSLayer extends VectorLayer {
 
   featurePrefix: string;
 
+  version: string | undefined;
+
   getFeaturesOptions: Record<string, unknown>;
 
   wfsFormat: WFSFormat;
@@ -47,6 +54,7 @@ class WFSLayer extends VectorLayer {
       featureNS: '',
       featurePrefix: '',
       getFeatureOptions: {},
+      version: undefined,
     };
   }
 
@@ -70,10 +78,11 @@ class WFSLayer extends VectorLayer {
     this.featureNS = options.featureNS;
     this.featurePrefix = options.featurePrefix;
     this.getFeaturesOptions = options.getFeatureOptions || {};
-
+    this.version = options.version;
     this.wfsFormat = new WFSFormat({
       featureNS: this.featureNS,
       featureType: this.featureType,
+      version: this.version,
     });
 
     this._dataFetchedPromise = null;
@@ -87,6 +96,11 @@ class WFSLayer extends VectorLayer {
   }
 
   async reload(): Promise<void> {
+    this.wfsFormat = new WFSFormat({
+      featureNS: this.featureNS,
+      featureType: this.featureType,
+      version: this.version,
+    });
     if (this._dataFetchedPromise) {
       this.removeAllFeatures();
       this._dataFetchedPromise = null;
@@ -111,14 +125,15 @@ class WFSLayer extends VectorLayer {
         ...this.getFeaturesOptions,
       });
       const postData = new XMLSerializer().serializeToString(requestDocument);
-      this._dataFetchedPromise = requestJson(this.url, {
+      this._dataFetchedPromise = requestUrl(this.url, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/text+xml',
         },
-        body: JSON.stringify(postData),
+        body: postData,
       })
-        .then((data) => this._parseWFSData(data as Element))
+        .then((response) => response.text())
+        .then((data) => this._parseWFSData(data))
         .catch((err) => {
           this.getLogger().info(
             `Could not send request for loading layer content (${String(err)})`,
@@ -132,7 +147,7 @@ class WFSLayer extends VectorLayer {
     return Promise.reject(new Error('missing url in WFSLayer layer'));
   }
 
-  private _parseWFSData(obj: Element): void {
+  private _parseWFSData(obj: string): void {
     const features = this.wfsFormat.readFeatures(obj);
     this.addFeatures(features);
   }

package/src/map/cesiumMap.ts

@@ -40,7 +40,7 @@ import {
 import type { Coordinate } from 'ol/coordinate.js';
 
 import { checkMaybe } from '@vcsuite/check';
-import { parseBoolean, parseInteger } from '@vcsuite/parsers';
+import { parseBoolean, parseInteger, parseNumber } from '@vcsuite/parsers';
 import VcsMap, { type VcsMapOptions } from './vcsMap.js';
 import Viewpoint from '../util/viewpoint.js';
 import Projection, { mercatorProjection } from '../util/projection.js';
@@ -80,6 +80,12 @@ export type CesiumMapOptions = VcsMapOptions & {
    * This is a global Setting for all VCMap Instances on the same page.
    */
   useOriginalCesiumShader?: boolean;
+
+  /**
+   * changes the default Cesium Sunlight Intensity (default is 3.0)
+   * Cesium Default is 2.0
+   */
+  lightIntensity?: number;
 };
 
 export type CesiumMapEvent = {
@@ -344,6 +350,8 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
 
   private _useOriginalCesiumShader: boolean;
 
+  private _lightIntensity: number;
+
   constructor(options: CesiumMapOptions) {
     super(options);
 
@@ -403,6 +411,8 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
     this._listeners = [];
 
     this._lastEventFrameNumber = null;
+
+    this._lightIntensity = parseNumber(options.lightIntensity, 3.0);
   }
 
   get splitPosition(): number {
@@ -653,6 +663,7 @@ class CesiumMap extends VcsMap<CesiumVisualisationType> {
       this._cesiumWidget.scene.highDynamicRange = false;
       // this._cesiumWidget.scene.logarithmicDepthBuffer = false; // TODO observe this
       this._cesiumWidget.scene.splitPosition = this.splitPosition;
+      this._cesiumWidget.scene.light.intensity = this._lightIntensity;
 
       this._cesiumWidget.scene.globe.enableLighting = this.enableLightning;
 

package/src/oblique/obliqueCollection.ts

@@ -1,4 +1,4 @@
-import { parseBoolean, parseInteger, parseNumber } from '@vcsuite/parsers';
+import { parseInteger, parseNumber } from '@vcsuite/parsers';
 import RBush from 'rbush';
 import knn from 'rbush-knn';
 import { getTransform } from 'ol/proj.js';
@@ -72,7 +72,7 @@ export type ObliqueCollectionOptions = VcsObjectOptions & {
   minZoom?: number;
   scaleFactor?: number;
   hideLevels?: number;
-  activeOnStartup?: boolean;
+  datasourceId?: string;
 };
 
 export type ObliqueImageRbushItem = {
@@ -132,7 +132,7 @@ class ObliqueCollection extends VcsObject {
       scaleFactor: 4,
       dataSets: undefined,
       hideLevels: 0,
-      activeOnStartup: false,
+      datasourceId: undefined,
     };
   }
 
@@ -172,9 +172,10 @@ class ObliqueCollection extends VcsObject {
   private _loadingPromise: Promise<void> | undefined = undefined;
 
   /**
-   * Whether to activate this collection after loading its defining context.
+   * Optional Id to synchronize with the vcPublisher Datasources. This can also be used to track a connection
+   * to other sources of data.
    */
-  activeOnStartup: boolean;
+  datasourceId?: string;
 
   /**
    * @param  options
@@ -196,10 +197,7 @@ class ObliqueCollection extends VcsObject {
       });
     }
 
-    this.activeOnStartup = parseBoolean(
-      options.activeOnStartup,
-      defaultOptions.activeOnStartup,
-    );
+    this.datasourceId = options.datasourceId || defaultOptions.datasourceId;
   }
 
   get dataSets(): ObliqueDataSet[] {
@@ -622,6 +620,9 @@ class ObliqueCollection extends VcsObject {
     if (this.viewOptions.hideLevels !== defaultOptions.hideLevels) {
       config.hideLevels = this.viewOptions.hideLevels;
     }
+    if (this.datasourceId !== defaultOptions.datasourceId) {
+      config.datasourceId = this.datasourceId;
+    }
 
     if (this.dataSets.length > 0) {
       config.dataSets = this.dataSets.map((d) => d.toJSON());