@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/util/featureconverter/featureconverterHelper.js

@@ -1,591 +0,0 @@
-import { getBottomLeft } from 'ol/extent.js';
-import {
-  Cartesian3,
-  HeightReference,
-  ColorGeometryInstanceAttribute,
-  GeometryInstance,
-  Material,
-  SceneTransforms,
-  MaterialAppearance,
-  ClassificationType,
-  PerInstanceColorAppearance,
-  GroundPrimitive,
-  GroundPolylinePrimitive,
-  ClassificationPrimitive,
-  ShadowMode,
-  Primitive,
-  Color,
-  PolylineMaterialAppearance,
-} from '@vcmap/cesium';
-import { parseInteger, parseNumber } from '@vcsuite/parsers';
-import { getCesiumColor } from '../../style/styleHelpers.js';
-
-/**
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("ol/style/Fill").default} fill
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @returns {import("@vcmap/cesium").MaterialAppearance}
- */
-export function getMaterialAppearance(scene, fill, feature) {
-  const options = {
-    flat: true,
-    renderState: {
-      depthTest: {
-        enabled: true,
-      },
-    },
-  };
-  const fillColor = fill.getColor();
-  if (fillColor instanceof CanvasPattern) {
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    ctx.fillStyle = fillColor;
-    ctx.fillRect(0, 0, 300, 300);
-    options.material = Material.fromType('Wallpaper', {
-      image: canvas,
-      anchor: SceneTransforms.wgs84ToDrawingBufferCoordinates(
-        scene,
-        Cartesian3.fromDegreesArray(getBottomLeft(feature.getGeometry().getExtent()))[0],
-      ),
-    });
-  } else {
-    const color = getCesiumColor(fillColor, [0, 0, 0, 1]);
-    options.material = Material.fromType('Color', {
-      color,
-    });
-    options.translucent = color.alpha !== 1;
-  }
-  return new MaterialAppearance(options);
-}
-
-/**
- *
- * @param {Object} options
- * @param {Array<import("@vcmap/cesium").Geometry>} geometries
- * @param {import("@vcmap/cesium").Color} color
- * @param {import("@vcmap/cesium").ClassificationType} classificationType
- * @returns {import("@vcmap/cesium").ClassificationPrimitive}
- */
-export function createClassificationPrimitive(options, geometries, color, classificationType) {
-  const instances = geometries.map(geometry => new GeometryInstance({
-    geometry,
-    attributes: {
-      color: ColorGeometryInstanceAttribute.fromColor(color),
-    },
-  }));
-
-  const appearance = new PerInstanceColorAppearance({
-    flat: false,
-    renderState: {
-      depthTest: {
-        enabled: true,
-      },
-      lineWidth: 1,
-    },
-    translucent: color.alpha !== 1,
-  });
-
-  const classificationPrimitiveOptions = {
-    ...options,
-    geometryInstances: instances,
-    appearance,
-    shadows: ShadowMode.ENABLED,
-    classificationType,
-  };
-  return new ClassificationPrimitive(classificationPrimitiveOptions);
-}
-
-/**
- *
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {boolean} allowPicking
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {Array<import("@vcmap/cesium").Geometry>} geometries
- * @param {import("ol/style/Style").default} style
- * @param {boolean} groundPrimitive
- * @returns {import("@vcmap/cesium").Primitive|import("@vcmap/cesium").GroundPrimitive|import("@vcmap/cesium").ClassificationPrimitive|null}
- */
-export function createPrimitive(scene, vectorProperties, allowPicking, feature, geometries, style, groundPrimitive) {
-  const classificationType = vectorProperties.getClassificationType(feature);
-  const options = {
-    shadows: ShadowMode.ENABLED,
-    allowPicking,
-  };
-  let primitive;
-  if (classificationType !== undefined && !groundPrimitive) {
-    if (!ClassificationPrimitive.isSupported(scene)) {
-      return null;
-    }
-    const color = getCesiumColor(style.getFill().getColor(), [0, 0, 0, 1]);
-    primitive = createClassificationPrimitive(options, geometries, color, classificationType);
-  } else {
-    const instances = geometries.map(geometry => new GeometryInstance({
-      geometry,
-    }));
-    options.geometryInstances = instances;
-    const appearance = getMaterialAppearance(scene, style.getFill(), feature);
-    options.appearance = appearance;
-    if (groundPrimitive) {
-      if (!GroundPrimitive.isSupported(scene)) {
-        return null;
-      }
-      options.classificationType = classificationType || ClassificationType.TERRAIN;
-      primitive = new GroundPrimitive(options);
-    } else {
-      primitive = new Primitive(options);
-    }
-  }
-  return primitive;
-}
-
-/**
- *
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {boolean} allowPicking
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {Array<import("@vcmap/cesium").Geometry>} geometries
- * @param {import("ol/style/Style").default} style
- * @returns {import("@vcmap/cesium").Primitive}
- */
-export function createOutlinePrimitive(scene, vectorProperties, allowPicking, feature, geometries, style) {
-  const color = getCesiumColor(style.getStroke().getColor(), [0, 0, 0, 1]);
-  const instances = geometries.map(geometry => new GeometryInstance({
-    geometry,
-    attributes: {
-      color: ColorGeometryInstanceAttribute.fromColor(color),
-    },
-  }));
-  const appearance = new PerInstanceColorAppearance({
-    flat: true,
-    renderState: {
-      depthTest: {
-        enabled: true,
-      },
-      lineWidth: 1,
-    },
-    translucent: color.alpha !== 1,
-  });
-  const options = {
-    geometryInstances: instances,
-    appearance,
-    shadows: ShadowMode.ENABLED,
-    allowPicking,
-  };
-  const primitive = new Primitive(options);
-  return primitive;
-}
-
-/**
- *
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {boolean} allowPicking
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {Array<import("@vcmap/cesium").PolylineGeometry|import("@vcmap/cesium").GroundPolylineGeometry>} geometries
- * @param {import("ol/style/Style").default} style
- * @param {boolean} groundPrimitive
- * @returns {import("@vcmap/cesium").Primitive|import("@vcmap/cesium").GroundPolylinePrimitive|null}
- */
-export function createLinePrimitive(
-  scene, vectorProperties, allowPicking, feature, geometries, style, groundPrimitive,
-) {
-  const classificationType = vectorProperties.getClassificationType(feature);
-  const instances = geometries.map(geometry => new GeometryInstance({
-    geometry,
-  }));
-
-  const color = getCesiumColor(style.getStroke().getColor(), [0, 0, 0, 1]);
-  let material;
-  if (style.getStroke().getLineDash()) {
-    material = Material.fromType('Stripe', {
-      horizontal: false,
-      repeat: 500,
-      evenColor: color,
-      oddColor: new Color(0, 0, 0, 0), // transparent
-    });
-  } else {
-    material = Material.fromType('Color', { color });
-  }
-
-  const appearance = new PolylineMaterialAppearance({
-    renderState: {
-      depthTest: {
-        enabled: true,
-      },
-      lineWidth: 1,
-    },
-    translucent: color.alpha !== 1,
-    material,
-  });
-
-  const options = {
-    geometryInstances: instances,
-    appearance,
-    shadows: ShadowMode.ENABLED,
-    allowPicking,
-  };
-  let primitive;
-  if (groundPrimitive) {
-    if (!GroundPolylinePrimitive.isSupported(scene)) {
-      return null;
-    }
-    options.classificationType = classificationType || ClassificationType.TERRAIN;
-    primitive = new GroundPolylinePrimitive(options);
-  } else {
-    primitive = new Primitive(options);
-  }
-  return primitive;
-}
-
-/**
- * returns groundlevel or extracts the minimum height from the coordinates, returns 0 if no z coordinates are set
- * @param {number|null|undefined} groundLevel
- * @param {Array<import("ol/coordinate").Coordinate>=} coordinates
- * @returns {number}
- */
-export function getMinHeightOrGroundLevel(groundLevel, coordinates) {
-  if (groundLevel != null && Number.isFinite(Number(groundLevel))) {
-    return groundLevel;
-  }
-  if (coordinates) {
-    let minimumHeight = Infinity;
-    for (let i = 0; i < coordinates.length; i++) {
-      minimumHeight = coordinates[i][2] < minimumHeight ? coordinates[i][2] : minimumHeight;
-    }
-    if (Number.isFinite(minimumHeight)) {
-      return minimumHeight;
-    }
-  }
-  return 0;
-}
-
-
-/**
- * @param {number} extrudedHeight should be a number > 0
- * @param {Array<number>} storeyHeights
- * @param {number} storeyNumber
- * @returns {Array<number>}
- */
-export function getStoreyHeights(extrudedHeight, storeyHeights, storeyNumber) {
-  const positiveExtrudedHeight = Math.abs(extrudedHeight);
-  const fittedStoreyHeights = [];
-  if (storeyHeights.length) {
-    let height = 0;
-    for (let i = 0; i < storeyHeights.length; i++) {
-      height += storeyHeights[i];
-      if (height < positiveExtrudedHeight) {
-        fittedStoreyHeights.push(storeyHeights[i]);
-      } else {
-        fittedStoreyHeights.push(storeyHeights[i] - (height - positiveExtrudedHeight));
-        return fittedStoreyHeights;
-      }
-    }
-    const lastStoreyHeight = storeyHeights[storeyHeights.length - 1];
-    while (height < positiveExtrudedHeight) {
-      height += lastStoreyHeight;
-      if (height < positiveExtrudedHeight) {
-        fittedStoreyHeights.push(lastStoreyHeight);
-      } else {
-        fittedStoreyHeights.push(lastStoreyHeight - (height - positiveExtrudedHeight));
-        return fittedStoreyHeights;
-      }
-    }
-  } else if (storeyNumber) {
-    return new Array(storeyNumber).fill(positiveExtrudedHeight / storeyNumber);
-  }
-  // case no predefined storeyHeights
-  return [positiveExtrudedHeight];
-}
-
-
-/**
- * @param {number} storeys
- * @param {Array<number>} storeyHeights
- */
-export function validateStoreys(storeys, storeyHeights) {
-  if (storeys && storeyHeights.length) {
-    const missingStoreyHeights = storeys - storeyHeights.length;
-    if (missingStoreyHeights > 0) {
-      storeyHeights.push(
-        ...new Array(missingStoreyHeights).fill(storeyHeights[storeyHeights.length - 1]),
-      );
-    } else if (missingStoreyHeights < 0) {
-      storeyHeights.splice(storeyHeights.length + missingStoreyHeights);
-    }
-    if (storeys > 100) {
-      storeyHeights.splice(100);
-    }
-  } else {
-    storeyHeights.splice(0);
-  }
-}
-
-/**
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {import("@vcmap/cesium").HeightReference} heightReference
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @returns {number}
- */
-export function getHeightAboveGround(feature, heightReference, vectorProperties) {
-  if (heightReference === HeightReference.RELATIVE_TO_GROUND) {
-    return vectorProperties.getHeightAboveGround(feature);
-  }
-  return 0;
-}
-
-/**
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {Array<import("ol/coordinate").Coordinate>} coordinates
- * @returns {VectorHeightInfo}
- */
-export function getHeightInfo(feature, vectorProperties, coordinates) {
-  const extrudedHeight = vectorProperties.getExtrudedHeight(feature);
-  const storeyNumber = Math.abs(parseInteger(feature.get('olcs_storeyNumber'), 0)); // legacy
-  const storeyHeight = Math.abs(parseNumber(feature.get('olcs_storeyHeight'), 0)); // legacy
-  let storeysAboveGround = 0;
-  let storeysBelowGround = 0;
-  let storeyHeightsAboveGround = [];
-  let storeyHeightsBelowGround = [];
-
-  // legacy CASE
-  if (storeyHeight || storeyNumber) {
-    if (extrudedHeight && extrudedHeight > 0 && storeyHeight) {
-      storeysAboveGround = Math.ceil(extrudedHeight / storeyHeight);
-      storeyHeightsAboveGround = new Array(storeysAboveGround - 1).fill(storeyHeight);
-      storeyHeightsAboveGround.push(extrudedHeight - (storeysAboveGround - 1) * storeyHeight);
-    } else if (extrudedHeight && extrudedHeight < 0 && storeyHeight) {
-      storeysBelowGround = Math.ceil(Math.abs(extrudedHeight / storeyHeight));
-      storeyHeightsBelowGround = new Array(storeysBelowGround - 1).fill(storeyHeight);
-      storeyHeightsBelowGround.push(Math.abs(extrudedHeight) - (storeysBelowGround - 1) * storeyHeight);
-    } else if (extrudedHeight && extrudedHeight > 0 && storeyNumber) {
-      storeysAboveGround = storeyNumber;
-      const currentStoreyHeight = Math.abs(extrudedHeight / storeyNumber);
-      storeyHeightsAboveGround = new Array(storeyNumber).fill(currentStoreyHeight);
-    } else if (extrudedHeight && extrudedHeight < 0 && storeyNumber) {
-      storeysBelowGround = storeyNumber;
-      const currentStoreyHeight = Math.abs(extrudedHeight / storeyNumber);
-      storeyHeightsBelowGround = new Array(storeyNumber).fill(currentStoreyHeight);
-    } else if (storeyNumber && storeyHeight) {
-      storeysAboveGround = storeyNumber;
-      storeyHeightsAboveGround = new Array(storeyNumber).fill(storeyHeight);
-    } else if (storeyNumber && vectorProperties.storeyHeight) {
-      storeysAboveGround = storeyNumber;
-      storeyHeightsAboveGround = new Array(storeyNumber).fill(vectorProperties.storeyHeight);
-    }
-  }
-
-  // no legacy case // can also be an invalid legacy case
-  if (!(storeysAboveGround && storeyHeightsAboveGround.length) &&
-    !(storeysBelowGround && storeyHeightsBelowGround.length)) {
-    storeysAboveGround = vectorProperties.getStoreysAboveGround(feature);
-    storeysBelowGround = vectorProperties.getStoreysBelowGround(feature);
-    storeyHeightsAboveGround = vectorProperties.getStoreyHeightsAboveGround(feature);
-    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 olcsGroundLevel = vectorProperties.getGroundLevel(feature);
-
-  const heightReference = vectorProperties.getAltitudeMode(feature);
-  const heightAboveGroundAdjustment = getHeightAboveGround(feature, heightReference, vectorProperties);
-
-  const groundLevel = getMinHeightOrGroundLevel(olcsGroundLevel, coordinates) + heightAboveGroundAdjustment;
-  const hasZCoordinate = !!coordinates.find(value => value[2]);
-
-  const extruded = !!(storeyHeightsAboveGround.length || storeyHeightsBelowGround.length || skirt);
-  const perPositionHeight = hasZCoordinate && (
-    !extruded ||
-    (extruded && ((storeyHeightsAboveGround.length + storeyHeightsBelowGround.length) === 1))
-  );
-
-  return {
-    extruded,
-    storeyHeightsAboveGround,
-    storeyHeightsBelowGround,
-    skirt,
-    groundLevel,
-    perPositionHeight,
-    heightReference,
-    heightAboveGroundAdjustment,
-  };
-}
-
-/**
- * @param {Array<number>} storeyHeights
- * @param {number} initialHeight
- * @param {boolean} [down=false]
- * @param {Array<{currentHeight:number, extrudedHeight:number}>=} result
- * @returns {Array<{currentHeight:number, extrudedHeight:number}>}
- */
-export function getStoreyOptions(storeyHeights, initialHeight, down, result) {
-  const direction = down ? -1 : 1;
-  let currentHeight = initialHeight;
-  const storeys = storeyHeights.length;
-  const options = new Array(storeys);
-  for (let i = 0; i < storeys; i++) {
-    const extrudedHeight = currentHeight + direction * storeyHeights[i];
-    options[i] = {
-      currentHeight,
-      extrudedHeight,
-    };
-    currentHeight = extrudedHeight;
-  }
-
-  if (result) {
-    result.push(...options);
-    return result;
-  }
-  return options;
-}
-
-/**
- *
- * @param {import("ol").Feature<import("ol/geom/Geometry").default>} feature
- * @param {import("ol/style/Style").default} style
- * @param {Array<import("ol/geom/SimpleGeometry").default>} geometries
- * @param {import("@vcmap/core").VectorProperties} vectorProperties
- * @param {import("@vcmap/cesium").Scene} scene
- * @param {VectorGeometryFactoryType} geometryFactory
- * @param {import("@vcmap/core").VectorContext|import("@vcmap/core").ClusterContext} context
- */
-export function addPrimitivesToContext(
-  feature, style, geometries, vectorProperties, scene, geometryFactory, context,
-) {
-  // no geometries, so early escape
-  if (!geometries.length) {
-    return;
-  }
-
-  const fillGeometries = [];
-  const outlineGeometries = [];
-  const lineGeometries = [];
-
-  const heightInfo = getHeightInfo(feature, vectorProperties, geometryFactory.getCoordinates(geometries));
-
-  const hasFill = !!style.getFill();
-  const hasStroke = !!style.getStroke();
-
-  let groundPrimitive = false;
-
-
-  geometries.forEach((geometry) => {
-    const geometryOptions = geometryFactory.getGeometryOptions(geometry, heightInfo.heightAboveGroundAdjustment);
-    const storeyOptions = getStoreyOptions(heightInfo.storeyHeightsAboveGround, heightInfo.groundLevel);
-    getStoreyOptions(heightInfo.storeyHeightsBelowGround, heightInfo.groundLevel, true, storeyOptions);
-
-    if (hasFill) {
-      storeyOptions.forEach((options) => {
-        fillGeometries.push(
-          ...geometryFactory.createSolidGeometries(
-            geometryOptions,
-            options.currentHeight,
-            heightInfo.perPositionHeight,
-            options.extrudedHeight,
-          ),
-        );
-      });
-    }
-    if (hasStroke) {
-      storeyOptions.forEach((options) => {
-        outlineGeometries.push(
-          ...geometryFactory.createOutlineGeometries(
-            geometryOptions,
-            options.currentHeight,
-            heightInfo.perPositionHeight,
-            options.extrudedHeight,
-          ),
-        );
-      });
-    }
-    if (heightInfo.skirt) {
-      const currentHeight = heightInfo.groundLevel - heightInfo.storeyHeightsBelowGround.reduce((a, b) => a + b, 0);
-      const extrudedHeight = currentHeight - heightInfo.skirt;
-      const skirtPositionHeight = heightInfo.storeyHeightsBelowGround.length ? false : heightInfo.perPositionHeight;
-      if (hasFill) {
-        fillGeometries.push(
-          ...geometryFactory.createSolidGeometries(
-            geometryOptions,
-            currentHeight,
-            skirtPositionHeight,
-            extrudedHeight,
-          ),
-        );
-      }
-      if (hasStroke) {
-        outlineGeometries.push(
-          ...geometryFactory.createOutlineGeometries(
-            geometryOptions,
-            currentHeight,
-            skirtPositionHeight,
-            extrudedHeight,
-          ),
-        );
-      }
-    }
-
-    if (!heightInfo.extruded) {
-      if (heightInfo.heightReference === HeightReference.CLAMP_TO_GROUND) {
-        groundPrimitive = true;
-      }
-      if (hasFill) {
-        fillGeometries.push(...geometryFactory.createFillGeometries(
-          geometryOptions, heightInfo.groundLevel, heightInfo.perPositionHeight,
-        ));
-      }
-      if (hasStroke) {
-        if (heightInfo.heightReference === HeightReference.CLAMP_TO_GROUND) {
-          lineGeometries.push(...geometryFactory.createGroundLineGeometries(geometryOptions, style));
-        } else {
-          lineGeometries.push(...geometryFactory.createLineGeometries(geometryOptions, style));
-        }
-      }
-    }
-  });
-
-  const allowPicking = vectorProperties.getAllowPicking(feature);
-  const primitives = [];
-  if (lineGeometries.length) {
-    const linePrimitive =
-      createLinePrimitive(scene, vectorProperties, allowPicking, feature, lineGeometries, style, groundPrimitive);
-    if (linePrimitive) {
-      primitives.push(linePrimitive);
-    }
-  }
-
-  if (fillGeometries.length) {
-    const fillPrimitive =
-      createPrimitive(scene, vectorProperties, allowPicking, feature, fillGeometries, style, groundPrimitive);
-    if (fillPrimitive) {
-      primitives.push(fillPrimitive);
-    }
-  }
-
-  if (outlineGeometries.length) {
-    const outlinePrimitive =
-      createOutlinePrimitive(scene, vectorProperties, allowPicking, feature, outlineGeometries, style);
-    if (outlinePrimitive) {
-      primitives.push(outlinePrimitive);
-    }
-  }
-
-  context.addPrimitives(primitives, feature, allowPicking);
-}