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

package/src/layer/cesium/clusterContext.ts

@@ -4,6 +4,7 @@ import {
   Entity,
   SplitDirection,
   Scene,
+  ConstantProperty,
 } from '@vcmap-cesium/engine';
 import { StyleLike } from 'ol/style/Style.js';
 import type { Feature } from 'ol/index.js';
@@ -17,12 +18,18 @@ import convert, { ConvertedItem } from '../../util/featureconverter/convert.js';
 class ClusterContext implements CesiumVectorContext {
   entities: EntityCollection;
 
+  splitDirection: SplitDirection;
+
+  private _splitDirectionProperty: ConstantProperty;
+
   private _featureItems = new Map<Feature, (() => void)[]>();
 
   private _convertingFeatures: Map<Feature, () => void> = new Map();
 
-  constructor(dataSource: CustomDataSource) {
+  constructor(dataSource: CustomDataSource, splitDirection: SplitDirection) {
     this.entities = dataSource.entities;
+    this.splitDirection = splitDirection;
+    this._splitDirectionProperty = new ConstantProperty(splitDirection);
   }
 
   private _addConvertedItems(
@@ -36,7 +43,10 @@ class ClusterContext implements CesiumVectorContext {
         let removeItem: (() => void) | undefined;
         if (item.type === 'billboard') {
           instance = this.entities.add({
-            billboard: item.item,
+            billboard: {
+              ...item.item,
+              splitDirection: this._splitDirectionProperty,
+            },
             position: item.item.position,
           });
         } else if (item.type === 'label') {
@@ -108,7 +118,10 @@ class ClusterContext implements CesiumVectorContext {
   }
 
   // eslint-disable-next-line class-methods-use-this,no-unused-vars
-  updateSplitDirection(_splitDirection: SplitDirection): void {}
+  updateSplitDirection(splitDirection: SplitDirection): void {
+    this.splitDirection = splitDirection;
+    this._splitDirectionProperty.setValue(this.splitDirection);
+  }
 
   clear(): void {
     this.entities.removeAll();

package/src/layer/cesium/vectorContext.ts

@@ -1,5 +1,5 @@
 import {
-  type Billboard,
+  Billboard,
   BillboardCollection,
   Cartesian3,
   type Entity,
@@ -34,13 +34,12 @@ export function setReferenceForPicking(
 /**
  * Sets splitDirection on primitives. Currently only Model primitives support splitting.
  */
-export function setSplitDirectionOnPrimitives(
-  splitDirection: SplitDirection,
-  primitives: PrimitiveCollection,
-): void {
+export function setSplitDirectionOnPrimitives<
+  T extends PrimitiveCollection | BillboardCollection,
+>(splitDirection: SplitDirection, primitives: T): void {
   for (let i = 0; i < primitives.length; i++) {
-    const p = primitives.get(i) as Primitive | Model;
-    if (p instanceof Model) {
+    const p = primitives.get(i) as Primitive | Model | Billboard;
+    if (p instanceof Model || p instanceof Billboard) {
       p.splitDirection = splitDirection;
     }
   }
@@ -84,7 +83,7 @@ export function setupScalingPrimitiveCollection(
           primitive.modelMatrix = Matrix4.setScale(
             modelMatrix,
             new Cartesian3(res, res, res),
-            new Matrix4(),
+            primitive.modelMatrix,
           );
           primitive[scaleSymbol] = res;
         }
@@ -202,8 +201,11 @@ export default class VectorContext implements CesiumVectorContext {
             setReferenceForPicking(feature, instance);
           }
 
-          if (this.splitDirection && instance instanceof Model) {
-            // Cesium currently only supports splitDirection on Model primitives // XXX this is no longer TRUE
+          if (
+            this.splitDirection &&
+            (instance instanceof Model || instance instanceof Billboard)
+          ) {
+            // Cesium currently only supports splitDirection on Model & Billboard Primitives
             instance.splitDirection = this.splitDirection;
           }
         }
@@ -262,6 +264,7 @@ export default class VectorContext implements CesiumVectorContext {
     this.splitDirection = splitDirection;
     setSplitDirectionOnPrimitives(splitDirection, this.primitives);
     setSplitDirectionOnPrimitives(splitDirection, this.scaledPrimitives);
+    setSplitDirectionOnPrimitives(splitDirection, this.billboards);
   }
 
   clear(): void {

package/src/layer/oblique/obliqueHelpers.ts

@@ -19,7 +19,7 @@ import {
 } from '../vectorSymbols.js';
 import {
   convertGeometryToPolygon,
-  getFlatCoordinatesFromGeometry,
+  getFlatCoordinateReferences,
 } from '../../util/geometryHelpers.js';
 import { transformFromImage } from '../../oblique/helpers.js';
 import type ObliqueImage from '../../oblique/obliqueImage.js';
@@ -97,7 +97,7 @@ export async function mercatorGeometryToImageGeometry(
       ? fromCircle(inputSourceGeometry)
       : inputSourceGeometry;
   const coordinates = sourceGeometry.getCoordinates() as any[];
-  const flattenCoordinates = getFlatCoordinatesFromGeometry(
+  const flattenCoordinates = getFlatCoordinateReferences(
     sourceGeometry,
     coordinates,
   );
@@ -151,7 +151,7 @@ export function imageGeometryToMercatorGeometry(
   image: ObliqueImage,
 ): Promise<Geometry> {
   const coordinates = sourceGeometry.getCoordinates() as any[];
-  const flattenCoordinates = getFlatCoordinatesFromGeometry(
+  const flattenCoordinates = getFlatCoordinateReferences(
     sourceGeometry,
     coordinates,
   );

package/src/layer/vectorProperties.ts

@@ -897,10 +897,10 @@ class VectorProperties {
   }
 
   /**
-   * Get the features or the properties modelOptions. Returns an empty Object if both are undefined
+   * Get the features or the properties modelOptions.
    * @param  feature
    */
-  getModelOptions(feature: Feature): Record<string, unknown> {
+  getModelOptions(feature: Feature): Record<string, unknown> | undefined {
     const featureValue = feature.get('olcs_modelOptions') as
       | Record<string, unknown>
       | undefined;
@@ -910,7 +910,7 @@ class VectorProperties {
     if (this.modelOptions) {
       return this.modelOptions;
     }
-    return {};
+    return undefined;
   }
 
   get modelAutoScale(): boolean {
@@ -1315,7 +1315,7 @@ class VectorProperties {
   }
 
   getValues(): VectorPropertiesOptions {
-    const values = {
+    return {
       altitudeMode: getAltitudeModeOptions(this.altitudeMode),
       allowPicking: this.allowPicking,
       classificationType: getClassificationTypeOptions(this.classificationType),
@@ -1336,9 +1336,11 @@ class VectorProperties {
       modelHeading: this.modelHeading,
       modelPitch: this.modelPitch,
       modelRoll: this.modelRoll,
+      modelAutoScale: this.modelAutoScale,
+      modelOptions: this.modelOptions,
       baseUrl: this.baseUrl,
+      primitiveOptions: this.primitiveOptions,
     };
-    return values;
   }
 
   /**

package/src/ol/geom/geometryCollection.js

@@ -54,5 +54,7 @@ GeometryCollection.prototype.getStride = function getStride() {
  */
 GeometryCollection.prototype.getFlatCoordinates =
   function getFlatCoordinates() {
-    return this.getGeometriesArray().flatMap((g) => g.getFlatCoordinates());
+    return this.getGeometriesArrayRecursive().flatMap((g) =>
+      g.getFlatCoordinates(),
+    );
   };

package/src/util/clipping/clippingPlaneHelper.ts

@@ -13,7 +13,6 @@ import {
   type Camera,
 } from '@vcmap-cesium/engine';
 import type { Coordinate } from 'ol/coordinate.js';
-import type { Geometry } from 'ol/geom.js';
 import Feature from 'ol/Feature.js';
 import LineString from 'ol/geom/LineString.js';
 import { offset } from 'ol/sphere.js';
@@ -27,7 +26,7 @@ import Extent3D from '../featureconverter/extent3D.js';
 import {
   enforceEndingVertex,
   enforceRightHand,
-  getFlatCoordinatesFromGeometry,
+  getFlatCoordinateReferences,
 } from '../geometryHelpers.js';
 import { mercatorToCartesian } from '../math.js';
 
@@ -162,7 +161,7 @@ export function createClippingPlaneCollection(
   check(transformMatrix, optional(Matrix4));
 
   const clippingPlanes = [];
-  const geometry = feature.getGeometry() as Geometry;
+  const geometry = feature.getGeometry()!;
   const geometryType = geometry.getType();
 
   if (geometryType === 'Point') {
@@ -174,7 +173,7 @@ export function createClippingPlaneCollection(
       ),
     );
   } else {
-    const coords = getFlatCoordinatesFromGeometry(geometry);
+    const coords = getFlatCoordinateReferences(geometry);
     if (
       coords.length < 2 ||
       (coords[0][0] === coords[1][0] && coords[0][1] === coords[1][1])

package/src/util/editor/editorHelpers.ts

@@ -18,7 +18,7 @@ import {
 } from '@vcmap-cesium/engine';
 
 import { mercatorToCartesian } from '../math.js';
-import { getFlatCoordinatesFromGeometry } from '../geometryHelpers.js';
+import { getFlatCoordinateReferences } from '../geometryHelpers.js';
 import CesiumMap from '../../map/cesiumMap.js';
 import { vertexIndexSymbol, vertexSymbol } from './editorSymbols.js';
 import {
@@ -365,7 +365,7 @@ export async function drapeGeometryOnTerrain(
 ): Promise<void> {
   if (map instanceof CesiumMap) {
     const coordinates = geometry.getCoordinates() as any[];
-    const flats = getFlatCoordinatesFromGeometry(geometry, coordinates);
+    const flats = getFlatCoordinateReferences(geometry, coordinates);
     await map.getHeightFromTerrain(flats);
     geometry.setCoordinates(coordinates, 'XYZ');
   }
@@ -382,7 +382,7 @@ export async function placeGeometryOnTerrain(
 ): Promise<void> {
   if (map instanceof CesiumMap) {
     const coordinates = geometry.getCoordinates() as any[];
-    const flats = getFlatCoordinatesFromGeometry(geometry, coordinates);
+    const flats = getFlatCoordinateReferences(geometry, coordinates);
     await map.getHeightFromTerrain(flats);
     let minHeight = Infinity;
     flats.forEach((coord) => {

package/src/util/featureconverter/convert.ts

@@ -109,7 +109,9 @@ export function getStylesArray(
   return styles;
 }
 
-function getSingleGeometriesFromGeometry(geometry: Geometry): SingleGeometry[] {
+export function getSingleGeometriesFromGeometry(
+  geometry: Geometry,
+): SingleGeometry[] {
   if (
     geometry instanceof Point ||
     geometry instanceof Polygon ||

package/src/util/featureconverter/pointHelpers.ts

@@ -44,6 +44,7 @@ import {
   RelativeHeightReference,
   VectorHeightInfo,
 } from './vectorHeightInfo.js';
+import { scaleSymbol } from '../../layer/cesium/vectorContext.js';
 
 function makeOffsetAutoScalePrimitive(
   primitive: Primitive | Model,
@@ -114,12 +115,16 @@ function makeClampedPrimitive(
       undefined,
       scratchUpdateHeightCartesian,
     );
-
-    const geometryModelMatrix = Matrix4.fromScale(scale);
+    let usedScale = scale;
+    const autoScale = primitive[scaleSymbol];
+    if (autoScale != null) {
+      usedScale = new Cartesian3(autoScale, autoScale, autoScale);
+    }
+    const geometryModelMatrix = Matrix4.fromScale(usedScale);
     if (offset) {
       Matrix4.setTranslation(
         geometryModelMatrix,
-        Cartesian3.multiplyComponents(offset, scale, new Cartesian3()),
+        Cartesian3.multiplyComponents(offset, usedScale, new Cartesian3()),
         geometryModelMatrix,
       );
     }
@@ -131,7 +136,7 @@ function makeClampedPrimitive(
     primitive.modelMatrix = Matrix4.multiply(
       transform,
       geometryModelMatrix,
-      new Matrix4(),
+      primitive.modelMatrix,
     );
   };
 

package/src/util/geometryHelpers.ts

@@ -19,8 +19,18 @@ import {
   Polygon,
   SimpleGeometry,
 } from 'ol/geom.js';
+import { Feature } from 'ol';
 import Projection from './projection.js';
 import { mercatorToCartographic } from './math.js';
+import VectorProperties from '../layer/vectorProperties.js';
+import {
+  getHeightInfo,
+  isClampedHeightReference,
+  isRelativeHeightReference,
+  RelativeHeightReference,
+  VectorHeightInfo,
+} from './featureconverter/vectorHeightInfo.js';
+import { getSingleGeometriesFromGeometry } from './featureconverter/convert.js';
 
 export function getFlatCoordinatesFromSimpleGeometry(
   geometry: SimpleGeometry,
@@ -44,7 +54,7 @@ export function getFlatCoordinatesFromSimpleGeometry(
   return [];
 }
 
-export function getFlatCoordinatesFromGeometry(
+export function getFlatCoordinateReferences(
   geometry: Geometry,
   inputCoordinates?: any[],
 ): Coordinate[] {
@@ -78,9 +88,7 @@ export function getFlatCoordinatesFromGeometry(
   } else if (geometry instanceof GeometryCollection) {
     flattenCoordinates = geometry
       .getGeometries()
-      .map((g, i) =>
-        getFlatCoordinatesFromGeometry(g, coordinates?.[i] as any[]),
-      )
+      .map((g, i) => getFlatCoordinateReferences(g, coordinates?.[i] as any[]))
       .reduce((current, next) => current.concat(next));
   }
   return flattenCoordinates as Coordinate[];
@@ -195,7 +203,7 @@ export function from3Dto2DLayout(geometry: Geometry): void {
     return;
   }
   const coordinates = geometry.getCoordinates() as any[];
-  const flatCoordinates = getFlatCoordinatesFromGeometry(geometry, coordinates);
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
   flatCoordinates.forEach((coordinate) => {
     if (layout === 'XYZM') {
       coordinate[2] = coordinate.pop()!;
@@ -207,13 +215,13 @@ export function from3Dto2DLayout(geometry: Geometry): void {
 }
 
 /**
- * Wil transform a 2D geometry (layout XY XYM) in place to 3D (XYZ XYZM) using the provided scene & height reference.
- * will no apply anything, if the layout is already 3D
+ * Places a geometry on to the ground (or terrain). The geometry is changed in place. This function
+ * will set the layout to a respective 3D layout.
  * @param geometry
  * @param scene
- * @param heightReference
+ * @param heightReference - clamp to ground will use `scene.getHeightMostDetailed`, terrain will use `sampleTerrainMostDetailed` using the scenes terrain provider
  */
-export async function from2Dto3DLayout(
+export async function placeGeometryOnGround(
   geometry: Geometry,
   scene: Scene,
   heightReference:
@@ -221,17 +229,15 @@ export async function from2Dto3DLayout(
     | HeightReference.CLAMP_TO_TERRAIN,
 ): Promise<void> {
   const layout = geometry.getLayout();
-  if (!is2DLayout(layout)) {
-    return;
-  }
   const coordinates = geometry.getCoordinates() as any[];
-  const flatCoordinates = getFlatCoordinatesFromGeometry(geometry, coordinates);
+  const flatCoordinates = getFlatCoordinateReferences(geometry, coordinates);
   const cartographics = flatCoordinates.map((c) => mercatorToCartographic(c));
   if (heightReference === HeightReference.CLAMP_TO_GROUND) {
     await scene.sampleHeightMostDetailed(cartographics);
   } else {
     await sampleTerrainMostDetailed(scene.terrainProvider, cartographics);
   }
+
   cartographics.forEach((c, index) => {
     if (layout === 'XYM') {
       flatCoordinates[index][3] = flatCoordinates[index][2];
@@ -240,5 +246,130 @@ export async function from2Dto3DLayout(
       flatCoordinates[index][2] = c.height;
     }
   });
-  geometry.setCoordinates(coordinates, layout === 'XYM' ? 'XYZM' : 'XYZ');
+
+  geometry.setCoordinates(
+    coordinates,
+    layout === 'XYM' || layout === 'XYZM' ? 'XYZM' : 'XYZ',
+  );
+}
+
+/**
+ * Wil transform a 2D geometry (layout XY XYM) in place to 3D (XYZ XYZM) using the provided scene & height reference.
+ * will no apply anything, if the layout is already 3D
+ * @param geometry
+ * @param scene
+ * @param heightReference
+ */
+export async function from2Dto3DLayout(
+  geometry: Geometry,
+  scene: Scene,
+  heightReference:
+    | HeightReference.CLAMP_TO_GROUND
+    | HeightReference.CLAMP_TO_TERRAIN,
+): Promise<void> {
+  if (is2DLayout(geometry.getLayout())) {
+    await placeGeometryOnGround(geometry, scene, heightReference);
+  }
+}
+
+export async function createAbsoluteFeatures(
+  features: Feature[],
+  vectorProperties: VectorProperties,
+  scene: Scene,
+): Promise<Feature[]> {
+  const clones = features.map((feature) => feature.clone());
+  const absoluteClones = await Promise.all(
+    clones.map(async (feature) => {
+      const geometry = feature.getGeometry();
+      if (!geometry) {
+        return null;
+      }
+
+      const altitudeMode = vectorProperties.getAltitudeMode(feature);
+      if (altitudeMode === HeightReference.NONE) {
+        if (is2DLayout(geometry.getLayout())) {
+          await from2Dto3DLayout(
+            geometry,
+            scene,
+            HeightReference.CLAMP_TO_GROUND,
+          );
+        }
+      } else if (isClampedHeightReference(altitudeMode)) {
+        await placeGeometryOnGround(
+          geometry,
+          scene,
+          altitudeMode !== HeightReference.CLAMP_TO_TERRAIN
+            ? HeightReference.CLAMP_TO_GROUND
+            : HeightReference.CLAMP_TO_TERRAIN,
+        );
+      } else if (isRelativeHeightReference(altitudeMode)) {
+        const singleGeometries = getSingleGeometriesFromGeometry(geometry);
+        await Promise.all(
+          singleGeometries.map(async (singleGeometry) => {
+            const heightInfo = getHeightInfo(
+              feature,
+              singleGeometry,
+              vectorProperties,
+            ) as VectorHeightInfo<RelativeHeightReference>;
+
+            let { groundLevel } = heightInfo;
+            if (heightInfo.clampOrigin) {
+              const cartographics = [
+                mercatorToCartographic(heightInfo.clampOrigin),
+              ];
+              if (
+                heightInfo.heightReference ===
+                HeightReference.RELATIVE_TO_TERRAIN
+              ) {
+                await sampleTerrainMostDetailed(
+                  scene.terrainProvider,
+                  cartographics,
+                );
+              } else {
+                await scene.sampleHeightMostDetailed(cartographics);
+              }
+              groundLevel = cartographics[0].height;
+            }
+
+            const coordinates = singleGeometry.getCoordinates() as any[];
+            const flatCoordinates = getFlatCoordinateReferences(
+              singleGeometry,
+              coordinates,
+            );
+            const { heightAboveGround } = heightInfo;
+            const setCoordinate =
+              heightAboveGround == null
+                ? (c: Coordinate): void => {
+                    c[2] += groundLevel as number;
+                  }
+                : (c: Coordinate): void => {
+                    c[2] = (groundLevel as number) + heightAboveGround;
+                  };
+            flatCoordinates.forEach(setCoordinate);
+            singleGeometry.setCoordinates(coordinates, 'XYZ');
+          }),
+        );
+
+        if (geometry instanceof MultiPoint) {
+          geometry.setCoordinates(
+            singleGeometries.map((g) => g.getCoordinates() as Coordinate),
+          );
+        } else if (geometry instanceof MultiPolygon) {
+          geometry.setCoordinates(
+            singleGeometries.map((g) => g.getCoordinates() as Coordinate[][]),
+          );
+        } else if (geometry instanceof MultiLineString) {
+          geometry.setCoordinates(
+            singleGeometries.map((g) => g.getCoordinates() as Coordinate[]),
+          );
+        } else if (geometry instanceof GeometryCollection) {
+          geometry.setGeometries(singleGeometries);
+        }
+      }
+
+      return feature;
+    }),
+  );
+
+  return absoluteClones.filter((f): f is Feature => !!f);
 }