@vcmap/core 5.0.0-rc.8 → 5.0.0

package/src/layer/tileProvider/urlTemplateTileProvider.js

@@ -1,106 +0,0 @@
-import { Math as CesiumMath, Rectangle } from '@vcmap/cesium';
-import { parseGeoJSON } from '../geojsonHelpers.js';
-import TileProvider from './tileProvider.js';
-import { getCurrentLocale } from '../../util/locale.js';
-import { requestJson } from '../../util/fetch.js';
-
-/**
- * @typedef {TileProviderOptions} URLTemplateTileProviderOptions
- * @property {string} url  url Template in the form `http://myFeatureSource/layer/getFeatures?minx={minx}&miny={miny}&maxx={maxx}&maxy={maxy}` or `http://myFeatureSource/layer/getFeatures?x={x}&y={y}&level={z}`
- * @api
- */
-
-/**
- * replaces {x}, {y}, {z} with the x, y, z tiling coordinates
- * replaces {minx}, {miny}, {maxx}, {maxy} with extent of the tile if tilingExtent is provided
- * replaces {locale} with the current locale
- *
- * @param {string} url
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {import("@vcmap/cesium").Rectangle=} tilingExtent
- * @returns {string}
- */
-export function getURL(url, x, y, z, tilingExtent) {
-  let replacedURL = url;
-  if (tilingExtent) {
-    const southwest = Rectangle.southwest(tilingExtent);
-    const northeast = Rectangle.northeast(tilingExtent);
-    const minx = CesiumMath.toDegrees(southwest.longitude);
-    const miny = CesiumMath.toDegrees(southwest.latitude);
-    const maxx = CesiumMath.toDegrees(northeast.longitude);
-    const maxy = CesiumMath.toDegrees(northeast.latitude);
-    replacedURL = replacedURL
-      .replace(/\{minx\}/, String(minx))
-      .replace(/\{miny\}/, String(miny))
-      .replace(/\{maxx\}/, String(maxx))
-      .replace(/\{maxy\}/, String(maxy));
-  }
-
-  replacedURL = replacedURL
-    .replace(/\{x\}/, String(x))
-    .replace(/\{y\}/, String(y))
-    .replace(/\{z\}/, String(z))
-    .replace(/\{locale\}/, getCurrentLocale());
-  return replacedURL;
-}
-
-/**
- * TileProvider loads GeojsonLayer from the provided URL. The URL has placeholders:
- * the extent in latitude/longitude via: {minx}, {miny}, {maxx}, {maxy}
- * tile Coordinates in x, y, z(level) via:  {x}, {y}, {z}
- * {locale} can be used to request locale aware content.
- *
- * @class
- * @extends {TileProvider}
- * @export
- * @api
- */
-class URLTemplateTileProvider extends TileProvider {
-  /**
-   * @readonly
-   * @returns {string}
-   */
-  static get className() { return 'URLTemplateTileProvider'; }
-
-  /**
-   * @returns {URLTemplateTileProviderOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...TileProvider.getDefaultOptions(),
-      url: undefined,
-    };
-  }
-
-  /**
-   * @param {URLTemplateTileProviderOptions} options
-   */
-  constructor(options) {
-    const defaultOptions = URLTemplateTileProvider.getDefaultOptions();
-    super(options);
-
-    /**
-     * @type {string}
-     */
-    this.url = options.url || defaultOptions.url;
-  }
-
-  /**
-   * @inheritDoc
-   * @param {number} x
-   * @param {number} y
-   * @param {number} z
-   * @returns {Promise<Array<import("ol").Feature<import("ol/geom/Geometry").default>>>}
-   */
-  async loader(x, y, z) {
-    const rectangle = this.tilingScheme.tileXYToRectangle(x, y, z);
-    const url = getURL(this.url, x, y, z, rectangle);
-    const data = await requestJson(url);
-    const { features } = parseGeoJSON(data, { dynamicStyle: true });
-    return features;
-  }
-}
-
-export default URLTemplateTileProvider;

package/src/layer/tmsLayer.js

@@ -1,121 +0,0 @@
-import RasterLayer from './rasterLayer.js';
-import OpenlayersMap from '../map/openlayersMap.js';
-import CesiumMap from '../map/cesiumMap.js';
-import TmsOpenlayersImpl from './openlayers/tmsOpenlayersImpl.js';
-import TmsCesiumImpl from './cesium/tmsCesiumImpl.js';
-import { VcsClassRegistry } from '../classRegistry.js';
-
-/**
- * @typedef {RasterLayerOptions} TMSOptions
- * @property {string} [format=jpeg]
- * @property {import("ol/size").Size} [tileSize=[256, 256]]
- * @api
- */
-
-/**
- * @typedef {RasterLayerImplementationOptions} TMSImplementationOptions
- * @property {string} format
- * @property {import("ol/size").Size} tileSize
- */
-
-/**
- * TmsLayer Layer
- * @class
- * @export
- * @extends {RasterLayer}
- * @api stable
- */
-class TMSLayer extends RasterLayer {
-  static get className() { return 'TMSLayer'; }
-
-  /**
-   * @returns {TMSOptions}
-   */
-  static getDefaultOptions() {
-    return {
-      ...RasterLayer.getDefaultOptions(),
-      tilingSchema: 'mercator',
-      format: 'jpeg',
-      tileSize: [256, 256],
-    };
-  }
-
-  /**
-   * @param {TMSOptions} options
-   */
-  constructor(options) {
-    const defaultOptions = TMSLayer.getDefaultOptions();
-    options.tilingSchema = options.tilingSchema || defaultOptions.tilingSchema;
-    super(options);
-
-    this._supportedMaps = [
-      OpenlayersMap.className,
-      CesiumMap.className,
-    ];
-
-    /** @type {?string} */
-    this.format = options.format || defaultOptions.format;
-
-    /** @type {import("ol/size").Size} */
-    this.tileSize = Array.isArray(options.tileSize) ? options.tileSize.slice() : defaultOptions.tileSize;
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {TMSImplementationOptions}
-   */
-  getImplementationOptions() {
-    return {
-      ...super.getImplementationOptions(),
-      format: this.format,
-      tileSize: this.tileSize,
-    };
-  }
-
-  /**
-   * @inheritDoc
-   * @param {import("@vcmap/core").VcsMap} map
-   * @returns {Array<TmsOpenlayersImpl|TmsCesiumImpl>}
-   */
-  createImplementationsForMap(map) {
-    if (map instanceof OpenlayersMap) {
-      return [new TmsOpenlayersImpl(map, this.getImplementationOptions())];
-    }
-
-    if (map instanceof CesiumMap) {
-      return [new TmsCesiumImpl(map, this.getImplementationOptions())];
-    }
-    return [];
-  }
-
-  /**
-   * @inheritDoc
-   * @returns {TMSOptions}
-   */
-  toJSON() {
-    const config = /** @type {TMSOptions} */ (super.toJSON());
-    const defaultOptions = TMSLayer.getDefaultOptions();
-
-    if (this.tilingSchema !== defaultOptions.tilingSchema) {
-      config.tilingSchema = this.tilingSchema;
-    } else {
-      delete config.tilingSchema;
-    }
-
-    if (this.format !== defaultOptions.format) {
-      config.format = this.format;
-    }
-
-    if (
-      this.tileSize[0] !== defaultOptions.tileSize[0] ||
-      this.tileSize[1] !== defaultOptions.tileSize[1]
-    ) {
-      config.tileSize = this.tileSize.slice();
-    }
-
-    return config;
-  }
-}
-
-VcsClassRegistry.registerClass(TMSLayer.className, TMSLayer);
-export default TMSLayer;

package/src/layer/vectorHelpers.js

@@ -1,206 +0,0 @@
-import { unByKey } from 'ol/Observable.js';
-import Feature from 'ol/Feature.js';
-import GeometryType from 'ol/geom/GeometryType.js';
-import { HeightReference } from '@vcmap/cesium';
-import { FeatureVisibilityAction } from './featureVisibility.js';
-import Projection from '../util/projection.js';
-import { getHeightInfo } from '../util/featureconverter/featureconverterHelper.js';
-import { getFlatCoordinatesFromGeometry } from '../util/geometryHelpers.js';
-import Extent3D from '../util/featureconverter/extent3D.js';
-
-/**
- * Added to ol.source.Vector to determine, when the source has last had an update to its features visibility.
- * @type {symbol}
- */
-export const fvLastUpdated = Symbol('FVlastUpdated');
-
-/**
- * Added to ol.source.Vector to determine, when the source has last had an update to its features global visibility.
- * @type {symbol}
- */
-export const globalHiderLastUpdated = Symbol('GlobalHiderLastUpdated');
-
-/**
- * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- */
-export function updateFeatureVisibility(featureVisibility, source) {
-  Object.keys(featureVisibility.highlightedObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !featureVisibility.hasHighlightFeature(id, feat)) {
-        featureVisibility.addHighlightFeature(id, feat);
-      }
-    });
-
-  Object.keys(featureVisibility.hiddenObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !featureVisibility.hasHiddenFeature(id, feat)) {
-        featureVisibility.addHiddenFeature(id, feat);
-      }
-    });
-  source[fvLastUpdated] = Date.now();
-}
-
-/**
- * @param {import("@vcmap/core").GlobalHider} globalHider
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- */
-export function updateGlobalHider(globalHider, source) {
-  Object.keys(globalHider.hiddenObjects)
-    .forEach((id) => {
-      const feat = source.getFeatureById(id);
-      if (feat && !globalHider.hasFeature(id, feat)) {
-        globalHider.addFeature(id, feat);
-      }
-    });
-  source[globalHiderLastUpdated] = Date.now();
-}
-
-/**
- * @param {import("@vcmap/core").FeatureVisibility} featureVisibility
- * @param {import("ol/source").Vector<import("ol/geom/Geometry").default>} source
- * @param {import("@vcmap/core").GlobalHider} globalHider
- * @returns {Array<Function>}
- */
-export function synchronizeFeatureVisibilityWithSource(featureVisibility, source, globalHider) {
-  const sourceListener = source.on('addfeature', ({ feature }) => {
-    const id = feature.getId();
-    if (featureVisibility.highlightedObjects[id]) {
-      featureVisibility.addHighlightFeature(id, feature);
-    }
-
-    if (featureVisibility.hiddenObjects[id]) {
-      featureVisibility.addHiddenFeature(id, feature);
-    }
-
-    if (globalHider.hiddenObjects[id]) {
-      globalHider.addFeature(id, feature);
-    }
-    const now = Date.now();
-    source[fvLastUpdated] = now;
-    source[globalHiderLastUpdated] = now;
-  });
-
-  if (!source[fvLastUpdated] || source[fvLastUpdated] < featureVisibility.lastUpdated) {
-    updateFeatureVisibility(featureVisibility, source);
-  }
-
-  if (!source[globalHiderLastUpdated] || source[globalHiderLastUpdated] < featureVisibility.lastUpdated) {
-    updateGlobalHider(globalHider, source);
-  }
-
-  return [
-    featureVisibility.changed.addEventListener(({ action, ids }) => {
-      if (action === FeatureVisibilityAction.HIGHLIGHT) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            featureVisibility.addHighlightFeature(id, feat);
-          }
-        });
-        source[fvLastUpdated] = Date.now();
-      } else if (action === FeatureVisibilityAction.HIDE) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            featureVisibility.addHiddenFeature(id, feat);
-          }
-        });
-        source[fvLastUpdated] = Date.now();
-      }
-    }),
-    globalHider.changed.addEventListener(({ action, ids }) => {
-      if (action === FeatureVisibilityAction.HIDE) {
-        ids.forEach((id) => {
-          const feat = source.getFeatureById(id);
-          if (feat) {
-            globalHider.addFeature(id, feat);
-          }
-        });
-        source[globalHiderLastUpdated] = Date.now();
-      }
-    }),
-    () => { unByKey(sourceListener); },
-  ];
-}
-
-/**
- * @param {VectorClickedObject} object
- * @param {import("@vcmap/core").VectorLayer|import("@vcmap/core").VectorTileLayer} layer
- * @returns {?GenericFeature}
- */
-export function getGenericFeatureFromClickedObject(object, layer) {
-  if (!(object instanceof Feature)) {
-    return null;
-  }
-  const attributes = object.getProperties();
-  delete attributes[object.getGeometryName()];
-
-  const { clickedPosition } = object;
-  if (!clickedPosition) {
-    return null;
-  }
-  let { latitude, longitude } = clickedPosition;
-  const geometry = object.getGeometry();
-  let heightOffset = clickedPosition.height;
-  let calculateHeight = !heightOffset;
-  if (!geometry) {
-    calculateHeight = false; // we cannot calculate the height without geometry;
-  }
-
-  let relativeToGround = !heightOffset;
-  // Edge Case ClickedPosition is next to the feature and Feature got detected in clickToleranz.
-  // if the clicked Position does not intersect the feature the closestPoint will be used.
-  // also if the clickedPosition is not on the Feature we do not trust the Height Value;
-  const mercatorPoint =
-    Projection.wgs84ToMercator([clickedPosition.longitude, clickedPosition.latitude, clickedPosition.height]);
-  if (geometry && !geometry.intersectsCoordinate(mercatorPoint)) {
-    const closestPoint = geometry.getClosestPoint(mercatorPoint);
-    [longitude, latitude] = Projection.mercatorToWgs84(closestPoint);
-    calculateHeight = true;
-  }
-
-  // edge case oblique in this case we do get a height value but not of the feature but the underlying terrain.
-  // this is necessary to calculate the correct position of the balloon
-
-  // if we do not have a height value from the clickedPosition we calculate the height based in the feature;
-  if (calculateHeight) {
-    const coordinates = getFlatCoordinatesFromGeometry(geometry);
-    const heightInfo = getHeightInfo(object, layer.vectorProperties, coordinates);
-    if (heightInfo.perPositionHeight || heightInfo.extruded) {
-      const extent = Extent3D.fromGeometry(geometry);
-      extent.extendWithHeightInfo(heightInfo);
-      heightOffset = extent.maxZ;
-    }
-    // edge case points are rendered depending on the terrain, so we set relativeToGround to true.
-    // In this case the heightAboveGroundAdjustment is also just an Offset.
-    if (
-      !heightInfo.extruded &&
-      (geometry.getType() === GeometryType.POINT || geometry.getType() === GeometryType.MULTI_POINT) &&
-      (
-        heightInfo.heightReference === HeightReference.RELATIVE_TO_GROUND ||
-        heightInfo.heightReference === HeightReference.CLAMP_TO_GROUND)
-    ) {
-      heightOffset = heightInfo.heightAboveGroundAdjustment;
-      relativeToGround = true;
-    } else {
-      heightOffset += heightInfo.heightAboveGroundAdjustment;
-    }
-
-    // if we have to calculate the height we have to take heightAboveGround into account
-  }
-
-  delete attributes.clickedPosition;
-  heightOffset = Number.isFinite(heightOffset) ? heightOffset : 0;
-  return {
-    layerName: layer.name,
-    layerClass: layer.className,
-    attributes: { ...layer.genericFeatureProperties, ...attributes },
-    longitude,
-    latitude,
-    height: heightOffset + layer.balloonHeightOffset,
-    relativeToGround,
-  };
-}