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

package/src/util/featureconverter/vectorHeightInfo.ts

@@ -0,0 +1,393 @@
+import { is } from '@vcsuite/check';
+import { Geometry, SimpleGeometry } from 'ol/geom.js';
+import type { Coordinate } from 'ol/coordinate.js';
+import { Cartesian3, HeightReference } from '@vcmap-cesium/engine';
+import { GeometryLayout } from 'ol/geom/Geometry.js';
+import type { Feature } from 'ol';
+import type VectorProperties from '../../layer/vectorProperties.js';
+import { is2DLayout } from '../geometryHelpers.js';
+import { getStoreyHeights, validateStoreys } from './storeyHelpers.js';
+import Projection from '../projection.js';
+
+export type ExtrusionHeightInfo = {
+  /**
+   *  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[];
+  /**
+   * a negative height to <i>push</i> the geometry visually into the ground
+   */
+  skirt: number;
+};
+export type ClampedHeightReference =
+  | HeightReference.CLAMP_TO_GROUND
+  | HeightReference.CLAMP_TO_TERRAIN
+  | HeightReference.CLAMP_TO_3D_TILE;
+export type RelativeHeightReference =
+  | HeightReference.RELATIVE_TO_GROUND
+  | HeightReference.RELATIVE_TO_TERRAIN
+  | HeightReference.RELATIVE_TO_3D_TILE;
+export type VectorHeightInfo<
+  T extends HeightReference = HeightReference,
+  L extends GeometryLayout = GeometryLayout,
+> = T extends ClampedHeightReference
+  ? {
+      heightReference: T;
+      layout: L;
+    }
+  : T extends RelativeHeightReference
+  ? {
+      heightReference: T;
+      layout: L;
+      clampOrigin?: [number, number];
+      heightAboveGround?: number;
+      /**
+       * the level above or below mean sea level
+       */
+      groundLevel?: number;
+      /**
+       * true if not all z values are identical, e.g no height above ground was provided and no or only one storey was provided
+       */
+      perPositionHeight: boolean;
+    } & ExtrusionHeightInfo
+  : T extends HeightReference.NONE
+  ? {
+      heightReference: T;
+      layout: L;
+      /**
+       * the level above or below mean sea level (minZ value or ground_level or 0)
+       */
+      groundLevelOrMinHeight: number;
+      /**
+       * true if not all z values are identical, e.g no ground level was provided and no or only one storey was provided
+       */
+      perPositionHeight: boolean;
+    } & ExtrusionHeightInfo
+  : never;
+
+export function isClampedHeightReference(
+  heightReference: HeightReference,
+): heightReference is ClampedHeightReference {
+  return (
+    heightReference === HeightReference.CLAMP_TO_GROUND ||
+    heightReference === HeightReference.CLAMP_TO_TERRAIN ||
+    heightReference === HeightReference.CLAMP_TO_3D_TILE
+  );
+}
+
+export function isRelativeHeightReference(
+  heightReference: HeightReference,
+): heightReference is RelativeHeightReference {
+  return (
+    heightReference === HeightReference.RELATIVE_TO_GROUND ||
+    heightReference === HeightReference.RELATIVE_TO_TERRAIN ||
+    heightReference === HeightReference.RELATIVE_TO_3D_TILE
+  );
+}
+
+export function isAbsoluteHeightReference(
+  heightReference: HeightReference,
+): heightReference is HeightReference.NONE {
+  return heightReference === HeightReference.NONE;
+}
+
+export function getRelativeEquivalent(
+  clampedHeightReference: ClampedHeightReference,
+): RelativeHeightReference {
+  if (clampedHeightReference === HeightReference.CLAMP_TO_GROUND) {
+    return HeightReference.RELATIVE_TO_GROUND;
+  }
+  if (clampedHeightReference === HeightReference.CLAMP_TO_TERRAIN) {
+    return HeightReference.RELATIVE_TO_TERRAIN;
+  }
+  return HeightReference.RELATIVE_TO_3D_TILE;
+}
+
+export function getExtrusionHeightInfo(
+  feature: Feature,
+  vectorProperties: VectorProperties,
+): ExtrusionHeightInfo {
+  const extrudedHeight = vectorProperties.getExtrudedHeight(feature);
+
+  let storeysAboveGround = vectorProperties.getStoreysAboveGround(feature);
+  let storeysBelowGround = vectorProperties.getStoreysBelowGround(feature);
+  let storeyHeightsAboveGround =
+    vectorProperties.getStoreyHeightsAboveGround(feature);
+  let storeyHeightsBelowGround =
+    vectorProperties.getStoreyHeightsBelowGround(feature);
+  if (extrudedHeight) {
+    // current Case only extrudedHeight
+    if (extrudedHeight > 0) {
+      storeyHeightsAboveGround = getStoreyHeights(
+        extrudedHeight,
+        storeyHeightsAboveGround,
+        storeysAboveGround,
+      );
+      storeysAboveGround = storeyHeightsAboveGround.length;
+      storeyHeightsBelowGround = [];
+      storeysBelowGround = 0;
+    } else if (extrudedHeight < 0) {
+      storeyHeightsBelowGround = getStoreyHeights(
+        extrudedHeight,
+        storeyHeightsBelowGround,
+        storeysBelowGround,
+      );
+      storeysBelowGround = storeyHeightsBelowGround.length;
+      storeyHeightsAboveGround = [];
+      storeysAboveGround = 0;
+    }
+  }
+
+  validateStoreys(storeysAboveGround, storeyHeightsAboveGround);
+  validateStoreys(storeysBelowGround, storeyHeightsBelowGround);
+
+  const skirt = vectorProperties.getSkirt(feature);
+  const extruded = !!(
+    storeyHeightsAboveGround.length ||
+    storeyHeightsBelowGround.length ||
+    skirt
+  );
+
+  return {
+    extruded,
+    storeyHeightsAboveGround,
+    storeyHeightsBelowGround,
+    skirt,
+  };
+}
+
+/**
+ * @param geometry - feature must return simple geometry
+ * @retruns the center of mass
+ */
+export function getClampOrigin(geometry: SimpleGeometry): [number, number] {
+  const stride = geometry.getStride();
+  const coordinates = geometry.getFlatCoordinates();
+  let x = 0;
+  let y = 0;
+  for (let i = 0; i < coordinates.length; i += stride) {
+    // calculates center of mass, maybe add
+    x += coordinates[i];
+    y += coordinates[i + 1];
+  }
+
+  const numberOfPoints = coordinates.length / stride;
+
+  return [x / numberOfPoints, y / numberOfPoints];
+}
+
+/**
+ * the minimum height of a geometry with a 3D layout
+ * @param geometry - with an XYZ layout
+ * @returns the minimum height
+ */
+export function getMinHeight(geometry: Geometry): number {
+  if (!is(geometry, SimpleGeometry) || is2DLayout(geometry.getLayout())) {
+    throw new Error('expected geometry to be a simple YXZ geometry');
+  }
+
+  const stride = geometry.getStride();
+  const coordinates = geometry.getFlatCoordinates();
+
+  let minZ = Infinity;
+  for (let i = 0; i < coordinates.length; i += stride) {
+    const Z = coordinates[i + 2];
+    minZ = Z < minZ ? Z : minZ;
+  }
+
+  return minZ;
+}
+
+export function getHeightInfo(
+  feature: Feature,
+  geometry: SimpleGeometry,
+  vectorProperties: VectorProperties,
+): VectorHeightInfo {
+  const extrusionHeightInfo = getExtrusionHeightInfo(feature, vectorProperties);
+
+  let heightReference = vectorProperties.getAltitudeMode(feature);
+  let heightAboveGround: number | undefined;
+
+  const layout = geometry.getLayout();
+  const groundLevel = vectorProperties.getGroundLevel(feature);
+
+  // we cannot render a two D coordinate absolutely without having a Z value (ground level)
+  // switch altitude mode to clamp
+  if (
+    is2DLayout(layout) &&
+    isAbsoluteHeightReference(heightReference) &&
+    groundLevel == null
+  ) {
+    heightReference = HeightReference.CLAMP_TO_GROUND;
+  }
+
+  if (isClampedHeightReference(heightReference)) {
+    const geometryType = geometry.getType();
+    let pointAsPrimitive = false;
+    if (geometryType === 'Point' || geometryType === 'MultiPoint') {
+      pointAsPrimitive = vectorProperties.renderAs(feature) !== 'geometry';
+    }
+
+    // clamped extrusions or primitives get rendered relative to ground with a height above ground of 0;
+    if (extrusionHeightInfo.extruded || pointAsPrimitive) {
+      heightReference = getRelativeEquivalent(heightReference);
+      heightAboveGround = 0;
+    } else {
+      return {
+        heightReference,
+        layout,
+      };
+    }
+  }
+
+  if (isRelativeHeightReference(heightReference)) {
+    heightAboveGround =
+      vectorProperties.getHeightAboveGround(feature) ??
+      heightAboveGround ??
+      (is2DLayout(layout) ? 0 : undefined);
+
+    // we only need a clamp origin, if we dont already have a ground level
+    const clampOrigin =
+      groundLevel != null ? undefined : getClampOrigin(geometry);
+
+    // true if not all z values are identical. in case of relative geometries, we set Z to height above ground, not ground level
+    const perPositionHeight =
+      !is2DLayout(layout) &&
+      heightAboveGround == null &&
+      (!extrusionHeightInfo.extruded ||
+        (extrusionHeightInfo.extruded &&
+          extrusionHeightInfo.storeyHeightsAboveGround.length +
+            extrusionHeightInfo.storeyHeightsBelowGround.length ===
+            1));
+
+    return {
+      ...extrusionHeightInfo,
+      heightReference,
+      layout,
+      heightAboveGround,
+      clampOrigin,
+      groundLevel,
+      perPositionHeight,
+    };
+  }
+
+  // true if not all z values are identical. if ground level is provided, all z values are equal to ground level.
+  const perPositionHeight =
+    !is2DLayout(layout) &&
+    groundLevel == null &&
+    (!extrusionHeightInfo.extruded ||
+      (extrusionHeightInfo.extruded &&
+        extrusionHeightInfo.storeyHeightsAboveGround.length +
+          extrusionHeightInfo.storeyHeightsBelowGround.length ===
+          1));
+
+  return {
+    ...extrusionHeightInfo,
+    groundLevelOrMinHeight: groundLevel ?? getMinHeight(geometry),
+    perPositionHeight,
+    heightReference,
+    layout,
+  };
+}
+
+/**
+ * Returns the geometry height (as used in the cesium geometry options) depending on the height info. 0 for clamped, groundLevelOrMinHeight for absolute & heightAboveGround + groundLevel (if present) for relative
+ * If you pass "with extrusion" the height will be returned including the extrusion, otherwise you get the height of the actual geometry
+ */
+export function getGeometryHeight(
+  geometry: SimpleGeometry,
+  heightInfo: VectorHeightInfo,
+): number {
+  let height = 0;
+  if (heightInfo.heightReference === HeightReference.NONE) {
+    height = heightInfo.groundLevelOrMinHeight;
+  } else if (isRelativeHeightReference(heightInfo.heightReference)) {
+    const relativeHeightInfo =
+      heightInfo as VectorHeightInfo<RelativeHeightReference>;
+    if (relativeHeightInfo.heightAboveGround != null) {
+      height = relativeHeightInfo.heightAboveGround;
+    } else {
+      // height info ensures this can only be a 3D layout
+      height = getMinHeight(geometry);
+    }
+
+    if (relativeHeightInfo.groundLevel) {
+      height += relativeHeightInfo.groundLevel;
+    }
+  }
+
+  return height;
+}
+
+/**
+ * @param {VectorHeightInfo} heightInfo
+ * @returns a callback function accepting a mercator coordinate. it will return a wgs84coordinate with its Z value adjusted according to the height info
+ */
+export function mercatorToWgs84TransformerForHeightInfo(
+  heightInfo: VectorHeightInfo,
+): (coord: Coordinate) => Coordinate {
+  if (isClampedHeightReference(heightInfo.heightReference)) {
+    const layoutIs2D = is2DLayout(heightInfo.layout);
+    return (coord: Coordinate) => {
+      const wgs84Coords = Projection.mercatorToWgs84(coord);
+      wgs84Coords[2] = layoutIs2D ? 0 : wgs84Coords[2];
+      return wgs84Coords;
+    };
+  } else if (isRelativeHeightReference(heightInfo.heightReference)) {
+    const { heightAboveGround, groundLevel } =
+      heightInfo as VectorHeightInfo<RelativeHeightReference>;
+
+    return (coord: Coordinate) => {
+      // disregard layout, since height info guarantees either height above ground OR 3D layout
+      const wgs84Coords = Projection.mercatorToWgs84(coord);
+      if (heightAboveGround != null) {
+        wgs84Coords[2] = heightAboveGround;
+      }
+      if (groundLevel) {
+        wgs84Coords[2] += groundLevel;
+      }
+
+      return wgs84Coords;
+    };
+  }
+
+  const { groundLevelOrMinHeight, perPositionHeight } =
+    heightInfo as VectorHeightInfo<HeightReference.NONE>;
+
+  return (coord: Coordinate) => {
+    // disregard layout, since height info guarantees ground level OR 3D layout
+    const wgs84Coords = Projection.mercatorToWgs84(coord);
+    if (!perPositionHeight && groundLevelOrMinHeight) {
+      wgs84Coords[2] = groundLevelOrMinHeight;
+    }
+
+    return wgs84Coords;
+  };
+}
+
+/**
+ * @param {VectorHeightInfo} heightInfo
+ * @returns a callback function accepting a mercator coordinate. it will return a Cartesian3 with its Z value adjusted according to the height info
+ */
+export function mercatorToCartesianTransformerForHeightInfo(
+  heightInfo: VectorHeightInfo,
+): (coord: Coordinate) => Cartesian3 {
+  const toWgs84 = mercatorToWgs84TransformerForHeightInfo(heightInfo);
+
+  return (coord) => {
+    const wgs84Coords = toWgs84(coord);
+    return Cartesian3.fromDegrees(
+      wgs84Coords[0],
+      wgs84Coords[1],
+      wgs84Coords[2],
+    );
+  };
+}

package/src/util/geometryHelpers.ts

@@ -1,19 +1,26 @@
+import {
+  HeightReference,
+  sampleTerrainMostDetailed,
+  Scene,
+} from '@vcmap-cesium/engine';
 import { offset as offsetSphere } from 'ol/sphere.js';
 import type { Coordinate } from 'ol/coordinate.js';
 import { fromCircle } from 'ol/geom/Polygon.js';
+import { GeometryLayout } from 'ol/geom/Geometry.js';
 import {
-  SimpleGeometry,
+  Circle,
   type Geometry,
   GeometryCollection,
-  MultiPolygon,
+  LineString,
   MultiLineString,
   MultiPoint,
+  MultiPolygon,
   Point,
-  Circle,
   Polygon,
-  LineString,
+  SimpleGeometry,
 } from 'ol/geom.js';
 import Projection from './projection.js';
+import { mercatorToCartographic } from './math.js';
 
 export function getFlatCoordinatesFromSimpleGeometry(
   geometry: SimpleGeometry,
@@ -94,7 +101,7 @@ export function circleFromCenterRadius(
   const dx2 = dx * dx;
   const dy2 = dy * dy;
   const radiusProjected = Math.sqrt(dx2 + dy2);
-  return new Circle(center, radiusProjected, 'XYZ');
+  return new Circle(center, radiusProjected);
 }
 
 export function convertGeometryToPolygon(geometry: Geometry): Geometry {
@@ -168,3 +175,70 @@ export function enforceRightHand(ring: Coordinate[]): Coordinate[] {
 
   return ring;
 }
+
+/**
+ * determines if a layout has only 2D coordinate values (XY or XYM)
+ * @param layout
+ */
+export function is2DLayout(layout: GeometryLayout): boolean {
+  return layout === 'XY' || layout === 'XYM';
+}
+
+/**
+ * Will convert a 3D layout (XYZ or XYZM) to XY (or XYM). This changes the geometry in place. will not apply any changes,
+ * if the layout is already a 2D layout
+ * @param geometry
+ */
+export function from3Dto2DLayout(geometry: Geometry): void {
+  const layout = geometry.getLayout();
+  if (is2DLayout(layout)) {
+    return;
+  }
+  const coordinates = geometry.getCoordinates() as any[];
+  const flatCoordinates = getFlatCoordinatesFromGeometry(geometry, coordinates);
+  flatCoordinates.forEach((coordinate) => {
+    if (layout === 'XYZM') {
+      coordinate[2] = coordinate.pop()!;
+    } else {
+      coordinate.pop();
+    }
+  });
+  geometry.setCoordinates(coordinates, layout === 'XYZM' ? 'XYM' : 'XY');
+}
+
+/**
+ * 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> {
+  const layout = geometry.getLayout();
+  if (!is2DLayout(layout)) {
+    return;
+  }
+  const coordinates = geometry.getCoordinates() as any[];
+  const flatCoordinates = getFlatCoordinatesFromGeometry(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];
+      flatCoordinates[index][2] = c.height;
+    } else {
+      flatCoordinates[index][2] = c.height;
+    }
+  });
+  geometry.setCoordinates(coordinates, layout === 'XYM' ? 'XYZM' : 'XYZ');
+}

package/src/util/mapCollection.ts

@@ -317,6 +317,10 @@ class MapCollection extends Collection<VcsMap> {
         map,
         error: error as Error,
       });
+      if (!map.fallbackMap && map.fallbackToCurrentMap && this._activeMap) {
+        this.fallbackMapActivated.raiseEvent(map);
+        return Promise.resolve();
+      }
       if (fallbackMap) {
         this.fallbackMapActivated.raiseEvent(map);
         return this.setActiveMap(fallbackMap.name);
@@ -341,6 +345,10 @@ class MapCollection extends Collection<VcsMap> {
           this.fallbackMapActivated.raiseEvent(map);
           return this.setActiveMap(fallbackMap.name);
         }
+        if (map.fallbackToCurrentMap && this._activeMap) {
+          this.fallbackMapActivated.raiseEvent(map);
+          return Promise.resolve();
+        }
       }
       this._cachedViewpoint = null;
       if (this._activeMap) {

package/src/util/math.ts

@@ -40,8 +40,8 @@ export function coordinateAtDistance(
 
 /**
  * returns the initial bearing in degrees (0-360) between two coordinates
- * @param  coords1 [lon, lat] in degrees
- * @param  coords2 [lon, lat] in degrees
+ * @param  coords1 - [lon, lat] in degrees
+ * @param  coords2 - [lon, lat] in degrees
  * @returns ;
  */
 export function initialBearingBetweenCoords(
@@ -77,6 +77,15 @@ export function getCartesianBearing(p1: Coordinate, p2: Coordinate): number {
   return theta;
 }
 
+export function cartesian2DDistanceSquared(
+  point0: Coordinate,
+  point1: Coordinate,
+): number {
+  const distX = point0[0] - point1[0];
+  const distY = point0[1] - point1[1];
+  return distX ** 2 + distY ** 2;
+}
+
 /**
  * returns distance between two coordinates
  * @param  point0
@@ -86,9 +95,7 @@ export function cartesian2DDistance(
   point0: Coordinate,
   point1: Coordinate,
 ): number {
-  const distX = point0[0] - point1[0];
-  const distY = point0[1] - point1[1];
-  return Math.sqrt(distX ** 2 + distY ** 2);
+  return Math.sqrt(cartesian2DDistanceSquared(point0, point1));
 }
 
 export function cartesian3DDistance(p1: Coordinate, p2: Coordinate): number {
@@ -112,6 +119,18 @@ export function cartographicToWgs84(cartographic: Cartographic): number[] {
   ];
 }
 
+export function wgs84ToCartographic(
+  wgs84Coordinates: Coordinate,
+  result?: Cartographic,
+): Cartographic {
+  return Cartographic.fromDegrees(
+    wgs84Coordinates[0],
+    wgs84Coordinates[1],
+    wgs84Coordinates[2],
+    result,
+  );
+}
+
 export function mercatorToCartesian(
   mercatorCoordinates: Coordinate,
   result?: Cartesian3,
@@ -126,6 +145,14 @@ export function mercatorToCartesian(
   );
 }
 
+export function mercatorToCartographic(
+  mercatorCoordinates: Coordinate,
+  result?: Cartographic,
+): Cartographic {
+  const wgs84Coords = Projection.mercatorToWgs84(mercatorCoordinates);
+  return wgs84ToCartographic(wgs84Coords, result);
+}
+
 export function cartesianToMercator(cartesian: Cartesian3): Coordinate {
   const cartographic = Cartographic.fromCartesian(cartesian);
   const wgs84 = cartographicToWgs84(cartographic);
@@ -133,14 +160,12 @@ export function cartesianToMercator(cartesian: Cartesian3): Coordinate {
 }
 
 export function getMidPoint(p1: Coordinate, p2: Coordinate): Coordinate {
-  if (p1.length < 3 && p2.length < 3) {
-    return [p1[0] + (p2[0] - p1[0]) / 2, p1[1] + (p2[1] - p1[1]) / 2, 0];
+  const stride = p1.length;
+  const output = new Array<number>(stride);
+  for (let i = 0; i < stride; i++) {
+    output[i] = p1[i] + (p2[i] - p1[i]) / 2;
   }
-  return [
-    p1[0] + (p2[0] - p1[0]) / 2,
-    p1[1] + (p2[1] - p1[1]) / 2,
-    p1[2] + (p2[2] - p1[2]) / 2,
-  ];
+  return output;
 }
 
 /**
@@ -178,3 +203,25 @@ export function getCartesianPitch(p1: Coordinate, p2: Coordinate): number {
 
   return pitch;
 }
+
+function perpDot(a: number[], b: number[]): number {
+  return a[0] * b[1] - a[1] * b[0];
+}
+
+// loosely copied from http://www.sunshine2k.de/coding/javascript/lineintersection2d/LineIntersect2D.html
+export function cartesian2Intersection(
+  lineA: [Coordinate, Coordinate],
+  lineB: [Coordinate, Coordinate],
+): Coordinate | undefined {
+  const A = [lineA[1][0] - lineA[0][0], lineA[1][1] - lineA[0][1]];
+  const B = [lineB[1][0] - lineB[0][0], lineB[1][1] - lineB[0][1]];
+
+  if (CesiumMath.equalsEpsilon(perpDot(A, B), 0, CesiumMath.EPSILON8)) {
+    return undefined;
+  }
+
+  const U = [lineB[0][0] - lineA[0][0], lineB[0][1] - lineA[0][1]];
+  const s = perpDot(B, U) / perpDot(B, A);
+
+  return [lineA[0][0] + s * A[0], lineA[0][1] + s * A[1]];
+}

package/dist/src/util/featureconverter/featureconverterHelper.d.ts

@@ -1,35 +0,0 @@
-import type { Feature } from 'ol/index.js';
-import type { SimpleGeometry } from 'ol/geom.js';
-import type { Style, Fill } from 'ol/style.js';
-import type { Coordinate } from 'ol/coordinate.js';
-import { HeightReference, MaterialAppearance, ClassificationType, GroundPrimitive, GroundPolylinePrimitive, ClassificationPrimitive, Primitive, Color, type Scene, type PolylineGeometry, type GroundPolylineGeometry, type PolygonGeometry, type CircleGeometry, type WallGeometry } from '@vcmap-cesium/engine';
-import type VectorProperties from '../../layer/vectorProperties.js';
-import type { VectorGeometryFactoryType, VectorHeightInfo } from '../../layer/vectorLayer.js';
-import type { AsyncCesiumVectorContext } from '../../layer/cesium/vectorContext.js';
-export declare function getMaterialAppearance(scene: Scene, fill: Fill, feature: Feature): MaterialAppearance;
-export declare function createClassificationPrimitive(options: Partial<ConstructorParameters<typeof ClassificationPrimitive>[0]>, geometries: (PolygonGeometry | CircleGeometry | WallGeometry)[], color: Color, classificationType: ClassificationType): ClassificationPrimitive;
-export declare function createPrimitive(scene: Scene, vectorProperties: VectorProperties, allowPicking: boolean, feature: Feature, geometries: (PolygonGeometry | CircleGeometry | WallGeometry)[], style: Style, groundPrimitive: boolean): Primitive | GroundPrimitive | ClassificationPrimitive | null;
-export declare function createOutlinePrimitive(_scene: Scene, _vectorProperties: VectorProperties, allowPicking: boolean, feature: Feature, geometries: (PolygonGeometry | CircleGeometry | WallGeometry)[], style: Style): Primitive;
-export declare function createLinePrimitive(scene: Scene, vectorProperties: VectorProperties, allowPicking: boolean, feature: Feature, geometries: (PolylineGeometry | GroundPolylineGeometry)[], style: Style, groundPrimitive: boolean): Primitive | GroundPolylinePrimitive | null;
-/**
- * returns groundlevel or extracts the minimum height from the coordinates, returns 0 if no z coordinates are set
- * @param  groundLevel
- * @param  coordinates
- */
-export declare function getMinHeightOrGroundLevel(groundLevel: number | null | undefined, coordinates?: Coordinate[]): number;
-/**
- * @param  extrudedHeight should be a number > 0
- * @param  storeyHeights
- * @param  storeyNumber
- */
-export declare function getStoreyHeights(extrudedHeight: number, storeyHeights: number[], storeyNumber: number): number[];
-export declare function validateStoreys(storeys: number, storeyHeights: number[]): void;
-export declare function getHeightAboveGround(feature: Feature, heightReference: HeightReference, vectorProperties: VectorProperties): number;
-export declare function getHeightInfo(feature: Feature, vectorProperties: VectorProperties, coordinates: Coordinate[]): VectorHeightInfo;
-type StoreyOptions = {
-    currentHeight: number;
-    extrudedHeight: number;
-};
-export declare function getStoreyOptions(storeyHeights: number[], initialHeight: number, down?: boolean, result?: StoreyOptions[]): StoreyOptions[];
-export declare function addPrimitivesToContext(feature: Feature, style: Style, geometries: SimpleGeometry[], vectorProperties: VectorProperties, scene: Scene, geometryFactory: VectorGeometryFactoryType, context: AsyncCesiumVectorContext): void;
-export {};