@vcmap/core 6.0.0-rc.4 → 6.0.0-rc.6

package/src/layer/vectorLayer.ts

@@ -1,19 +1,6 @@
 import VectorSource from 'ol/source/Vector.js';
 import Style, { type StyleFunction } from 'ol/style/Style.js';
 import Feature from 'ol/Feature.js';
-import type { SimpleGeometry } from 'ol/geom.js';
-import type { Coordinate } from 'ol/coordinate.js';
-import type {
-  CircleGeometry,
-  CircleOutlineGeometry,
-  GroundPolylineGeometry,
-  HeightReference,
-  PolygonGeometry,
-  PolygonOutlineGeometry,
-  PolylineGeometry,
-  WallGeometry,
-  WallOutlineGeometry,
-} from '@vcmap-cesium/engine';
 
 import { v4 as uuidv4 } from 'uuid';
 import { check, oneOf } from '@vcsuite/check';
@@ -76,64 +63,6 @@ export type VectorOptions = FeatureLayerOptions & {
   vectorProperties?: VectorPropertiesOptions;
 };
 
-export type VectorGeometryFactoryType = {
-  getCoordinates(geom: SimpleGeometry[]): Coordinate[];
-  getGeometryOptions(
-    geom: SimpleGeometry,
-    num: number,
-    perPositionHeight: boolean,
-    groundLevelOrMinHeight: number,
-  ): unknown;
-  createSolidGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-    num2?: number,
-  ): (PolygonGeometry | CircleGeometry | WallGeometry)[];
-  createOutlineGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-    num2?: number,
-  ): (CircleOutlineGeometry | WallOutlineGeometry | PolygonOutlineGeometry)[];
-  createFillGeometries(
-    obj: unknown,
-    num: number,
-    bool: boolean,
-  ): (CircleGeometry | PolygonGeometry)[];
-  createGroundLineGeometries(
-    obj: unknown,
-    style: Style,
-  ): GroundPolylineGeometry[];
-  createLineGeometries(obj: unknown, style: Style): PolylineGeometry[];
-};
-
-export type VectorHeightInfo = {
-  /**
-   *  if the object is extruded
-   */
-  extruded: boolean;
-  /**
-   * storey heights above ground, list has the same length as storeysAboveGround
-   */
-  storeyHeightsAboveGround: number[];
-  /**
-   * storey heights below ground, list has the same length as storeysBelowGround
-   */
-  storeyHeightsBelowGround: number[];
-  /**
-   * the level above or below mean sea level (minZ value or ground_level or 0)
-   */
-  groundLevel: number;
-  /**
-   * a negative height to <i>push</i> the geometry visually into the ground
-   */
-  skirt: number;
-  perPositionHeight: boolean;
-  heightReference: HeightReference;
-  heightAboveGroundAdjustment: number;
-};
-
 export type VectorImplementationOptions = FeatureLayerImplementationOptions & {
   source: VectorSource;
   maxResolution?: number;

package/src/layer/vectorProperties.ts

@@ -77,7 +77,11 @@ export function vectorPropertiesOfType<T extends PrimitiveOptionsType>(
 export type AltitudeModeType =
   | 'absolute'
   | 'relativeToGround'
-  | 'clampToGround';
+  | 'relativeToTerrain'
+  | 'relativeTo3DTiles'
+  | 'clampToGround'
+  | 'clampToTerrain'
+  | 'clampTo3DTiles';
 
 export type ClassificationTypeType = 'both' | 'terrain' | 'cesium3DTile';
 
@@ -197,8 +201,12 @@ export const vcsMetaVersion = '2.1';
 
 export const AltitudeModeCesium: Record<AltitudeModeType, HeightReference> = {
   clampToGround: HeightReference.CLAMP_TO_GROUND,
+  clampTo3DTiles: HeightReference.CLAMP_TO_3D_TILE,
+  clampToTerrain: HeightReference.CLAMP_TO_TERRAIN,
   absolute: HeightReference.NONE,
   relativeToGround: HeightReference.RELATIVE_TO_GROUND,
+  relativeTo3DTiles: HeightReference.RELATIVE_TO_3D_TILE,
+  relativeToTerrain: HeightReference.RELATIVE_TO_TERRAIN,
 };
 
 export const ClassificationTypeCesium: Record<
@@ -318,7 +326,7 @@ class VectorProperties {
       classificationType: undefined,
       scaleByDistance: undefined,
       eyeOffset: undefined,
-      heightAboveGround: 0,
+      heightAboveGround: undefined,
       skirt: 0,
       groundLevel: undefined,
       extrudedHeight: 0,
@@ -350,7 +358,7 @@ class VectorProperties {
 
   private _eyeOffset: Cartesian3 | undefined;
 
-  private _heightAboveGround: number;
+  private _heightAboveGround: number | undefined;
 
   private _skirt: number;
 
@@ -608,13 +616,13 @@ class VectorProperties {
     return parseCartesian3(featureValue, this.eyeOffset);
   }
 
-  get heightAboveGround(): number {
+  get heightAboveGround(): number | undefined {
     return this._heightAboveGround;
   }
 
-  set heightAboveGround(value: number) {
+  set heightAboveGround(value: number | undefined) {
     if (value !== this._heightAboveGround) {
-      check(value, Number);
+      check(value, maybe(Number));
       this._heightAboveGround = value;
       this.propertyChanged.raiseEvent(['heightAboveGround']);
     }
@@ -968,10 +976,11 @@ class VectorProperties {
 
   private _getBaseOptions(feature: Feature): VectorPropertiesBaseOptions {
     return {
+      // 0 is not a valid scale value and will crash cesium
       scale: [
-        this.getModelScaleX(feature),
-        this.getModelScaleY(feature),
-        this.getModelScaleZ(feature),
+        this.getModelScaleX(feature) || 1,
+        this.getModelScaleY(feature) || 1,
+        this.getModelScaleZ(feature) || 1,
       ],
       heading: this.getModelHeading(feature),
       pitch: this.getModelPitch(feature),
@@ -1013,6 +1022,34 @@ class VectorProperties {
     };
   }
 
+  /**
+   * Determines if a feature (in general with a point geometry) should be rendered as a geometry (billboard & label etc) or a model or a primitive
+   * @param feature
+   */
+  renderAs(feature: Feature): 'geometry' | 'model' | 'primitive' {
+    if (feature.get('olcs_modelUrl')) {
+      return 'model';
+    }
+
+    const primitiveOptions = feature.get('olcs_primitiveOptions') as
+      | VectorPropertiesPrimitiveOptions
+      | undefined;
+
+    if (primitiveOptions?.geometryOptions) {
+      return 'primitive';
+    }
+
+    if (this.modelUrl) {
+      return 'model';
+    }
+
+    if (this.primitiveOptions?.geometryOptions) {
+      return 'primitive';
+    }
+
+    return 'geometry';
+  }
+
   /**
    * resets values, either given, or default Value raises propertyChanged event once;
    * @param  vcsMeta

package/src/map/baseOLMap.ts

@@ -87,7 +87,7 @@ class BaseOLMap extends VcsMap<OLLayer> {
       olEvent.preventDefault();
     }
     olEvent.originalEvent.preventDefault();
-    const position = [olEvent.coordinate[0], olEvent.coordinate[1], 0];
+    const position = [olEvent.coordinate[0], olEvent.coordinate[1]];
     this.pointerInteractionEvent.raiseEvent({
       map: this,
       position,

package/src/map/obliqueMap.ts

@@ -32,6 +32,7 @@ export type ObliqueOptions = VcsMapOptions & {
   changeOnMoveEnd?: boolean;
   switchThreshold?: number;
   switchOnEdge?: boolean;
+  maintainViewpointOnCollectionChange?: boolean;
 };
 
 const defaultHeadings: Record<ViewDirection, number> = {
@@ -90,6 +91,10 @@ class ObliqueMap extends BaseOLMap {
    */
   collectionChanged: VcsEvent<ObliqueCollection>;
 
+  failedToSetCollection = new VcsEvent<ObliqueCollection>();
+
+  maintainViewpointOnCollectionChange: boolean;
+
   private _activeCollectionDestroyedListener: () => void;
 
   private _obliqueProvider: ObliqueProvider | null = null;
@@ -102,6 +107,7 @@ class ObliqueMap extends BaseOLMap {
       changeOnMoveEnd: false,
       switchThreshold: 0,
       switchOnEdge: true,
+      maintainViewpointOnCollectionChange: false,
     };
   }
 
@@ -129,6 +135,11 @@ class ObliqueMap extends BaseOLMap {
 
     this.collectionChanged = new VcsEvent();
 
+    this.maintainViewpointOnCollectionChange = parseBoolean(
+      options.maintainViewpointOnCollectionChange,
+      defaultOptions.maintainViewpointOnCollectionChange,
+    );
+
     this._activeCollectionDestroyedListener = (): void => {};
   }
 
@@ -293,6 +304,7 @@ class ObliqueMap extends BaseOLMap {
     if (this._loadingCollection !== obliqueCollection) {
       return;
     }
+
     await this._setCollection(obliqueCollection, viewpoint);
   }
 
@@ -304,18 +316,37 @@ class ObliqueMap extends BaseOLMap {
     viewpoint?: Viewpoint,
   ): Promise<void> {
     this._loadingCollection = obliqueCollection;
-    this._activeCollectionDestroyedListener();
-    this._activeCollectionDestroyedListener =
-      obliqueCollection.destroyed.addEventListener(() => {
-        // eslint-disable-next-line no-void
-        void this._setCollection(defaultCollection);
-      });
     await obliqueCollection.load();
     const vp = viewpoint || (await this.getViewpoint());
     if (this._loadingCollection !== obliqueCollection) {
       return;
     }
+
+    if (
+      viewpoint &&
+      this.maintainViewpointOnCollectionChange &&
+      this.collection
+    ) {
+      const viewDirection = getViewDirectionFromViewpoint(viewpoint);
+      const mercatorCoordinates = getMercatorViewpointCenter(viewpoint);
+      const canShow = await obliqueCollection.hasImageAtCoordinate(
+        mercatorCoordinates,
+        viewDirection,
+      );
+      if (!canShow) {
+        this.failedToSetCollection.raiseEvent(obliqueCollection);
+        return;
+      }
+    }
+
     this._obliqueProvider?.setCollection(obliqueCollection);
+    this._activeCollectionDestroyedListener();
+    this._activeCollectionDestroyedListener =
+      obliqueCollection.destroyed.addEventListener(() => {
+        // eslint-disable-next-line no-void
+        void this._setCollection(defaultCollection);
+      });
+
     this.collectionChanged.raiseEvent(obliqueCollection);
     if (vp) {
       await this.gotoViewpoint(vp);
@@ -470,6 +501,14 @@ class ObliqueMap extends BaseOLMap {
       config.switchOnEdge = this.switchEnabled;
     }
 
+    if (
+      this.maintainViewpointOnCollectionChange !==
+      defaultOptions.maintainViewpointOnCollectionChange
+    ) {
+      config.maintainViewpointOnCollectionChange =
+        this.maintainViewpointOnCollectionChange;
+    }
+
     return config;
   }
 
@@ -478,6 +517,7 @@ class ObliqueMap extends BaseOLMap {
       this._obliqueProvider.destroy();
     }
     this.collectionChanged.destroy();
+    this.failedToSetCollection.destroy();
     this._activeCollectionDestroyedListener();
     super.destroy();
   }

package/src/map/vcsMap.ts

@@ -1,4 +1,5 @@
 import { getLogger as getLoggerByName, Logger } from '@vcsuite/logger';
+import { parseBoolean } from '@vcsuite/parsers';
 import { v4 as uuidv4 } from 'uuid';
 import type { MapEvent as OLMapEvent } from 'ol';
 import type { Layer as OLLayer } from 'ol/layer.js';
@@ -23,6 +24,10 @@ function getLogger(): Logger {
 }
 
 export type VcsMapOptions = VcsObjectOptions & {
+  /**
+   * instead of using a fallback map, this map will fail to activate if another map is active and the current viewpoint cannot be shown
+   */
+  fallbackToCurrentMap?: boolean;
   /**
    * the name of the fallback map to use, e.g. in case there is no oblique image at the activation viewpoint
    */
@@ -58,6 +63,7 @@ class VcsMap<
   static getDefaultOptions(): VcsMapOptions {
     return {
       fallbackMap: undefined,
+      fallbackToCurrentMap: false,
     };
   }
 
@@ -93,9 +99,13 @@ class VcsMap<
   /**
    * The name of a map to fall back on, if this map cant show a viewpoint
    */
-
   fallbackMap: string | null;
 
+  /**
+   * instead of using a fallback map, this map will fail to activate if another map is active and the current viewpoint cannot be shown
+   */
+  fallbackToCurrentMap: boolean;
+
   private _visualizations: Map<string, Set<V>>;
 
   private _state: MapState;
@@ -122,7 +132,7 @@ class VcsMap<
    */
   constructor(options: VcsMapOptions) {
     super(options);
-
+    const defaultOptions = VcsMap.getDefaultOptions();
     this.mapElement = document.createElement('div');
     this.mapElement.setAttribute('id', uuidv4());
     this.mapElement.classList.add('mapElement');
@@ -147,6 +157,11 @@ class VcsMap<
 
     this.fallbackMap = options.fallbackMap || null;
 
+    this.fallbackToCurrentMap = parseBoolean(
+      options.fallbackToCurrentMap,
+      defaultOptions.fallbackToCurrentMap,
+    );
+
     this._visualizations = new Map();
 
     this._state = MapState.INACTIVE;
@@ -516,6 +531,9 @@ class VcsMap<
     if (this.fallbackMap) {
       config.fallbackMap = this.fallbackMap;
     }
+    if (this.fallbackToCurrentMap) {
+      config.fallbackToCurrentMap = this.fallbackToCurrentMap;
+    }
     return config;
   }
 

package/src/oblique/helpers.ts

@@ -13,7 +13,10 @@ import { transform } from 'ol/proj.js';
 import { Cartesian2, type CesiumTerrainProvider } from '@vcmap-cesium/engine';
 import { ObliqueViewDirection } from './obliqueViewDirection.js';
 import { getHeightFromTerrainProvider } from '../layer/terrainHelpers.js';
-import { cartesian2DDistance } from '../util/math.js';
+import {
+  cartesian2DDistance,
+  cartesian2DDistanceSquared,
+} from '../util/math.js';
 import Projection, {
   mercatorProjection,
   wgs84Projection,
@@ -52,11 +55,14 @@ export function sortRealWordEdgeCoordinates(
 
   let sorted = extentPoints.map((extentPoint) => {
     let closest = 0;
-    let distance = Infinity;
+    let distanceSquared = Infinity;
     cornerPoints.forEach((cornerPoint, cornerIndex) => {
-      const currentDistance = cartesian2DDistance(extentPoint, cornerPoint);
-      if (currentDistance < distance) {
-        distance = currentDistance;
+      const currentDistanceSquared = cartesian2DDistanceSquared(
+        extentPoint,
+        cornerPoint,
+      );
+      if (currentDistanceSquared < distanceSquared) {
+        distanceSquared = currentDistanceSquared;
         closest = cornerIndex;
       }
     });

package/src/oblique/obliqueDataSet.ts

@@ -3,7 +3,7 @@ import { createXYZ } from 'ol/tilegrid.js';
 import type { Coordinate } from 'ol/coordinate.js';
 import type { TileCoord } from 'ol/tilecoord.js';
 import type { Extent } from 'ol/extent.js';
-import { cartesian2DDistance } from '../util/math.js';
+import { cartesian2DDistanceSquared } from '../util/math.js';
 import {
   parseImageData,
   parseImageMeta,
@@ -235,12 +235,12 @@ class ObliqueDataSet {
     let minTile = null;
     [...this._tiles.keys()].forEach((tile) => {
       const tileCoord = tile.split('/').map(Number);
-      const dist = cartesian2DDistance(
+      const squaredDist = cartesian2DDistanceSquared(
         [actualTile[1], actualTile[2]],
         [tileCoord[1], tileCoord[2]],
       );
-      if (dist < minDistance) {
-        minDistance = dist;
+      if (squaredDist < minDistance) {
+        minDistance = squaredDist;
         minTile = tileCoord;
       }
     });

package/src/ol/geom/geometryCollection.js

@@ -5,7 +5,7 @@ import { check } from '@vcsuite/check';
  * @returns {Array<import("ol/coordinate").Coordinate|Array<import("ol/coordinate").Coordinate>|Array<Array<import("ol/coordinate").Coordinate>>|Array<Array<Array<import("ol/coordinate").Coordinate>>>>}
  */
 GeometryCollection.prototype.getCoordinates = function getCoordinates() {
-  return this.getGeometries().map((g) => g.getCoordinates());
+  return this.getGeometriesArray().map((g) => g.getCoordinates());
 };
 
 /**
@@ -31,9 +31,28 @@ GeometryCollection.prototype.setCoordinates = function setCoordinates(
  * @returns {import("ol/geom/Geometry").GeometryLayout}
  */
 GeometryCollection.prototype.getLayout = function getLayout() {
-  const firstGeom = this.getGeometries()[0];
+  const firstGeom = this.getGeometriesArray()[0];
   if (firstGeom) {
     return firstGeom.getLayout();
   }
   return 'XYZ';
 };
+
+/**
+ * @returns {number}
+ */
+GeometryCollection.prototype.getStride = function getStride() {
+  const firstGeom = this.getGeometriesArray()[0];
+  if (firstGeom) {
+    return firstGeom.getStride();
+  }
+  return 2;
+};
+
+/**
+ * @returns {number[]}
+ */
+GeometryCollection.prototype.getFlatCoordinates =
+  function getFlatCoordinates() {
+    return this.getGeometriesArray().flatMap((g) => g.getFlatCoordinates());
+  };

package/src/ol/ol.d.ts

@@ -41,12 +41,17 @@ import {
   fvLastUpdated,
   globalHiderLastUpdated,
 } from '../layer/vectorHelpers.js';
+import { validityPlaceholder } from '../util/editor/interactions/createPolygonInteraction.js';
 
 declare module 'ol/geom.js' {
   interface Geometry {
     getCoordinates(): any;
-    setCoordinates(coordinates: any, layout?: any): void;
+    setCoordinates(
+      coordinates: any,
+      layout?: import('ol/geom/Geometry.js').GeometryLayout,
+    ): void;
     getFlatCoordinates(): number[];
+    getStride(): number;
     getLayout(): import('ol/geom/Geometry.js').GeometryLayout;
     [alreadyTransformedToMercator]?: boolean;
     [actuallyIsCircle]?: boolean;
@@ -67,15 +72,23 @@ declare module 'ol/geom.js' {
         | Array<Array<import('ol/coordinate.js').Coordinate>>
         | Array<Array<Array<import('ol/coordinate.js').Coordinate>>>
       >,
+      layout?: import('ol/geom/Geometry.js').GeometryLayout,
     ): void;
     getLayout(): import('ol/geom/Geometry.js').GeometryLayout;
   }
 
   interface Circle {
     getCoordinates(): import('ol/coordinate.js').Coordinate[];
-    setCoordinates(coordinates: import('ol/coordinate.js').Coordinate[]): void;
+    setCoordinates(
+      coordinates: import('ol/coordinate.js').Coordinate[],
+      layout?: import('ol/geom/Geometry.js').GeometryLayout,
+    ): void;
     rotate(angle: number, anchor: import('ol/coordinate.js').Coordinate): void;
   }
+
+  interface Polygon {
+    [validityPlaceholder]?: boolean;
+  }
 }
 
 declare module 'ol/index.js' {

package/src/style/arcStyle.ts

@@ -178,6 +178,7 @@ function getArcCoordinates(
   offset: number,
 ): Coordinate[] {
   const midPoint = getMidPoint(p1, p2);
+  midPoint[2] = midPoint[2] ?? 0;
   midPoint[2] += arcHeight / 2;
   const fullDistance = cartesian2DDistance(p1, p2);