itowns 2.44.3-next.40 → 2.44.3-next.42

package/lib/Parser/ShapefileParser.js

@@ -1,78 +0,0 @@
-import proj4 from 'proj4';
-import shp from 'shpjs';
-import GeoJsonParser from "./GeoJsonParser.js";
-import { deprecatedParsingOptionsToNewOne } from "../Core/Deprecated/Undeprecator.js";
-
-/**
- * The ShapefileParser module provides a [parse]{@link
- * module:ShapefileParser.parse} method that takes a bunch of files constituing
- * a shapefile in and gives an object formateted for iTowns, containing all
- * necessary informations to display this shapefile.
- *
- * It uses the [shpjs](https://www.npmjs.com/package/shpjs) library to
- * parse all the files.
- *
- * @example
- * // Load all the necessary files for a shapefile, parse them and
- * // display them using a FileSource.
- * Promise.all([
- *     Fetcher.arrayBuffer('shapefile.shp'),
- *     Fetcher.arrayBuffer('shapefile.dbf'),
- *     Fetcher.arrayBuffer('shapefile.shx'),
- *     Fetcher.text('shapefile.prj'),
- * ]).then(function _(res) {
- *     return ShapefileParser.parse({
- *         shp: res[0],
- *         dbf: res[1],
- *         shx: res[2],
- *         prj: res[3],
- *     }, {
- *            in: {
- *              crs: 'EPSG:4326',
- *         },
- *         out: {
- *             crs: view.tileLayer.extent.crs,
- *         }
- *     });
- * }).then(function _(geojson) {
- *     var source = new FileSource({ features: geojson });
- *     var layer = new ColorLayer('velib', { source  });
- *     view.addLayer(layer);
- * });
- *
- *
- * @module ShapefileParser
- */
-export default {
-  /**
-   * Parse a bunch of Shapefile files and return a {@link FeatureCollection}.
-   *
-   * @param {Object} data - All the data that can be specified in a shapefile.
-   * @param {ArrayBuffer} data.shp - Data from the shapefile itself,
-   * containing the feature geometry itself.
-   * @param {ArrayBuffer} data.shx - A positional index of the feature
-   * geometry.
-   * @param {ArrayBuffer} data.dbf - Columnar attributes for each shape, in
-   * [dBase](https://en.wikipedia.org/wiki/DBase) IV format.
-   * @param {string} [data.prj] - The coordinate system and crs projection
-   * information.
-   * @param {ParsingOptions} [options]
-   *
-   * @return {Promise} A promise resolving with a {@link FeatureCollection}.
-   */
-  parse(data) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    options = deprecatedParsingOptionsToNewOne(options);
-    let result;
-
-    // If a zip is present, don't read anything else
-    if (data.zip) {
-      result = shp(data.zip);
-    } else if (data.shp && data.shx && data.dbf) {
-      result = shp(data);
-    }
-    options.in = options.in || {};
-    options.in.crs = data.prj ? proj4(data.prj).oProj.datumName : options.in.crs;
-    return Promise.resolve(result).then(res => GeoJsonParser.parse(res, options));
-  }
-};

package/lib/Parser/VectorTileParser.js

@@ -1,215 +0,0 @@
-import { Vector2, Vector3 } from 'three';
-import Protobuf from 'pbf';
-import { VectorTile } from '@mapbox/vector-tile';
-import { globalExtentTMS } from "../Core/Tile/TileGrid.js";
-import { FeatureCollection, FEATURE_TYPES } from "../Core/Feature.js";
-import { deprecatedParsingOptionsToNewOne } from "../Core/Deprecated/Undeprecator.js";
-import Coordinates from "../Core/Geographic/Coordinates.js";
-const worldDimension3857 = globalExtentTMS.get('EPSG:3857').planarDimensions();
-const globalExtent = new Vector3(worldDimension3857.x, worldDimension3857.y, 1);
-const lastPoint = new Vector2();
-const firstPoint = new Vector2();
-
-// Calculate the projected coordinates in EPSG:4326 of a given point in the VT local system
-// adapted from @mapbox/vector-tile
-function project(x, y, tileNumbers, tileExtent) {
-  const size = tileExtent * 2 ** tileNumbers.z;
-  const x0 = tileExtent * tileNumbers.x;
-  const y0 = tileExtent * tileNumbers.y;
-  return new Coordinates('EPSG:4326', (x + x0) * 360 / size - 180, 360 / Math.PI * Math.atan(Math.exp((180 - (y + y0) * 360 / size) * Math.PI / 180)) - 90);
-}
-
-// Classify option, it allows to classify a full polygon and its holes.
-// Each polygon with its holes are in one FeatureGeometry.
-// A polygon is determined by its clockwise direction and the holes are in the opposite direction.
-// Clockwise direction is determined by Shoelace formula https://en.wikipedia.org/wiki/Shoelace_formula
-// Draw polygon with canvas doesn't need to classify however it is necessary for meshs.
-function vtFeatureToFeatureGeometry(vtFeature, feature) {
-  let classify = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  let geometry = feature.bindNewGeometry();
-  const isPolygon = feature.type === FEATURE_TYPES.POLYGON;
-  classify = classify && isPolygon;
-  geometry.properties = vtFeature.properties;
-  const pbf = vtFeature._pbf;
-  pbf.pos = vtFeature._geometry;
-  const end = pbf.readVarint() + pbf.pos;
-  let cmd = 1;
-  let length = 0;
-  let x = 0;
-  let y = 0;
-  let count = 0;
-  let sum = 0;
-  while (pbf.pos < end) {
-    if (length <= 0) {
-      const cmdLen = pbf.readVarint();
-      cmd = cmdLen & 0x7;
-      length = cmdLen >> 3;
-    }
-    length--;
-    if (cmd === 1 || cmd === 2) {
-      x += pbf.readSVarint();
-      y += pbf.readSVarint();
-      if (cmd === 1) {
-        if (count) {
-          if (classify && sum > 0 && geometry.indices.length > 0) {
-            feature.updateExtent(geometry);
-            geometry = feature.bindNewGeometry();
-            geometry.properties = vtFeature.properties;
-          }
-          geometry.closeSubGeometry(count, feature);
-          geometry.getLastSubGeometry().ccw = sum < 0;
-        }
-        count = 0;
-        sum = 0;
-      }
-      count++;
-      const coordProj = project(x, y, vtFeature.tileNumbers, vtFeature.extent);
-      geometry.pushCoordinatesValues(feature, {
-        x,
-        y
-      }, coordProj);
-      if (count == 1) {
-        firstPoint.set(x, y);
-        firstPoint.coordProj = coordProj;
-        lastPoint.set(x, y);
-      } else if (isPolygon && count > 1) {
-        sum += (lastPoint.x - x) * (lastPoint.y + y);
-        lastPoint.set(x, y);
-      }
-    } else if (cmd === 7) {
-      if (count) {
-        count++;
-        geometry.pushCoordinatesValues(feature, {
-          x: firstPoint.x,
-          y: firstPoint.y
-        }, firstPoint.coordProj);
-        if (isPolygon) {
-          sum += (lastPoint.x - firstPoint.x) * (lastPoint.y + firstPoint.y);
-        }
-      }
-    } else {
-      throw new Error(`unknown command ${cmd}`);
-    }
-  }
-  if (count) {
-    if (classify && sum > 0 && geometry.indices.length > 0) {
-      feature.updateExtent(geometry);
-      geometry = feature.bindNewGeometry();
-      geometry.properties = vtFeature.properties;
-    }
-    geometry.closeSubGeometry(count, feature);
-    geometry.getLastSubGeometry().ccw = sum < 0;
-  }
-  feature.updateExtent(geometry);
-}
-function readPBF(file, options) {
-  options.out = options.out || {};
-  const vectorTile = new VectorTile(new Protobuf(file));
-  const vtLayerNames = Object.keys(vectorTile.layers);
-  const collection = new FeatureCollection(options.out);
-  if (vtLayerNames.length < 1) {
-    return Promise.resolve(collection);
-  }
-
-  // x,y,z tile coordinates
-  const x = options.extent.col;
-  const z = options.extent.zoom;
-  // We need to move from TMS to Google/Bing/OSM coordinates
-  // https://alastaira.wordpress.com/2011/07/06/converting-tms-tile-coordinates-to-googlebingosm-tile-coordinates/
-  // Only if the layer.origin is top
-  const y = options.in.isInverted ? options.extent.row : (1 << z) - options.extent.row - 1;
-  const vFeature0 = vectorTile.layers[vtLayerNames[0]];
-  // TODO: verify if size is correct because is computed with only one feature (vFeature0).
-  const size = vFeature0.extent * 2 ** z;
-  const center = -0.5 * size;
-  collection.scale.set(globalExtent.x / size, -globalExtent.y / size, 1);
-  collection.position.set(vFeature0.extent * x + center, vFeature0.extent * y + center, 0).multiply(collection.scale);
-  collection.updateMatrixWorld();
-  vtLayerNames.forEach(vtLayerName => {
-    if (!options.in.layers[vtLayerName]) {
-      return Promise.resolve(collection);
-    }
-    const vectorTileLayer = vectorTile.layers[vtLayerName];
-    for (let i = vectorTileLayer.length - 1; i >= 0; i--) {
-      const vtFeature = vectorTileLayer.feature(i);
-      vtFeature.tileNumbers = {
-        x,
-        y: options.extent.row,
-        z
-      };
-      // Find layers where this vtFeature is used
-      const layers = options.in.layers[vtLayerName].filter(l => l.filterExpression.filter({
-        zoom: z
-      }, vtFeature));
-      for (const layer of layers) {
-        const feature = collection.requestFeatureById(layer.id, vtFeature.type - 1);
-        feature.id = layer.id;
-        feature.order = layer.order;
-        feature.style = options.in.styles[feature.id];
-        vtFeatureToFeatureGeometry(vtFeature, feature);
-      }
-
-      /*
-      // This optimization is not fully working and need to be reassessed
-      // (see https://github.com/iTowns/itowns/pull/2469/files#r1861802136)
-      let feature;
-      for (const layer of layers) {
-          if (!feature) {
-              feature = collection.requestFeatureById(layer.id, vtFeature.type - 1);
-              feature.id = layer.id;
-              feature.order = layer.order;
-              feature.style = options.in.styles[feature.id];
-              vtFeatureToFeatureGeometry(vtFeature, feature);
-          } else if (!collection.features.find(f => f.id === layer.id)) {
-              feature = collection.newFeatureByReference(feature);
-              feature.id = layer.id;
-              feature.order = layer.order;
-              feature.style = options.in.styles[feature.id];
-          }
-      }
-      */
-    }
-  });
-  collection.removeEmptyFeature();
-  // TODO Some vector tiles are already sorted
-  collection.features.sort((a, b) => a.order - b.order);
-  // TODO verify if is needed to updateExtent for previous features.
-  collection.updateExtent();
-  collection.extent = options.extent;
-  collection.isInverted = options.in.isInverted;
-  return Promise.resolve(collection);
-}
-
-/**
- * @module VectorTileParser
- */
-export default {
-  /**
-   * Parse a vector tile file and return a [Feature]{@link module:GeoJsonParser.Feature}
-   * or an array of Features. While multiple formats of vector tile are
-   * available, the only one supported for the moment is the
-   * [Mapbox Vector Tile](https://www.mapbox.com/vector-tiles/specification/).
-   *
-   * @param {ArrayBuffer} file - The vector tile file to parse.
-   *
-   * @param {Object} options - Options controlling the parsing {@link ParsingOptions}.
-   *
-   * @param {Object} options.in - Object containing all styles,
-   * layers and informations data, see {@link InformationsData}.
-   *
-   * @param {Object} options.in.styles - Object containing subobject with
-   * informations on a specific style layer. Styles available is by `layer.id` and by zoom.
-   *
-   * @param {Object} options.in.layers - Object containing subobject with
-   *
-   * @param {FeatureBuildingOptions} options.out - options indicates how the features should be built,
-   * see {@link FeatureBuildingOptions}.
-   *
-   * @return {Promise} A Promise resolving with a Feature or an array a
-   * Features.
-   */
-  parse(file, options) {
-    options = deprecatedParsingOptionsToNewOne(options);
-    return Promise.resolve(readPBF(file, options));
-  }
-};

package/lib/Parser/XbilParser.js

@@ -1,120 +0,0 @@
-import { readTextureValueWithBilinearFiltering } from "../Utils/DEMUtils.js";
-function minMax4Corners(texture, pitch, options) {
-  const u = pitch.x;
-  const v = pitch.y;
-  const w = pitch.z;
-  const z = [readTextureValueWithBilinearFiltering(options, texture, u, v), readTextureValueWithBilinearFiltering(options, texture, u + w, v), readTextureValueWithBilinearFiltering(options, texture, u + w, v + w), readTextureValueWithBilinearFiltering(options, texture, u, v + w)].filter(val => val != undefined);
-  if (z.length) {
-    return {
-      min: Math.min(...z),
-      max: Math.max(...z)
-    };
-  } else {
-    return {
-      min: Infinity,
-      max: -Infinity
-    };
-  }
-}
-
-/**
- * Calculates the minimum maximum texture elevation with xbil data
- *
- * @param      {THREE.Texture}   texture                     The texture to parse
- * @param      {THREE.Vector4}   pitch                       The pitch,  restrict zone to parse
- * @param      {Object}          options                     No data value and clamp values
- * @param      {number}          options.noDataValue         No data value
- * @param      {number}          [options.zmin]   The minimum elevation value after which it will be clamped
- * @param      {number}          [options.zmax]   The maximum elevation value after which it will be clamped
- * @return     {Object}  The minimum and maximum elevation.
- */
-export function computeMinMaxElevation(texture, pitch, options) {
-  const {
-    width,
-    height,
-    data
-  } = texture.image;
-  if (!data) {
-    // Return null values means there's no elevation values.
-    // They can't be determined.
-    // Don't return 0 because the result will be wrong
-    return {
-      min: null,
-      max: null
-    };
-  }
-
-  // compute the minimum and maximum elevation on the 4 corners texture.
-  let {
-    min,
-    max
-  } = minMax4Corners(texture, pitch, options);
-  const sizeX = Math.floor(pitch.z * width);
-  if (sizeX > 2) {
-    const sizeY = Math.floor(pitch.z * height);
-    const xs = Math.floor(pitch.x * width);
-    const ys = Math.floor(pitch.y * height);
-    const inc = Math.max(Math.floor(sizeX / 32), 2);
-    for (let y = ys; y < ys + sizeY; y += inc) {
-      const pit = y * (width || 0);
-      let x = pit + xs;
-      const limX = x + sizeX;
-      for (x; x < limX; x += inc) {
-        const val = data[x];
-        if (val !== options.noDataValue) {
-          max = Math.max(max, val);
-          min = Math.min(min, val);
-        }
-      }
-    }
-  }
-
-  // Clamp values to zmin and zmax values configured in ElevationLayer
-  if (options.zmin != null) {
-    if (min < options.zmin) {
-      min = options.zmin;
-    }
-    if (max < options.zmin) {
-      max = options.zmin;
-    }
-  }
-  if (options.zmax != null) {
-    if (min > options.zmax) {
-      min = options.zmax;
-    }
-    if (max > options.zmax) {
-      max = options.zmax;
-    }
-  }
-  if (max === -Infinity || min === Infinity) {
-    // Return null values means the elevation values are incoherent
-    // They can't be determined.
-    // Don't return 0, -Infinity or Infinity because the result will be wrong
-    return {
-      min: null,
-      max: null
-    };
-  } else {
-    return {
-      min,
-      max
-    };
-  }
-}
-
-// We check if the elevation texture has some significant values through corners
-export function checkNodeElevationTextureValidity(data, noDataValue) {
-  const l = data.length;
-  return data[0] > noDataValue && data[l - 1] > noDataValue && data[Math.sqrt(l) - 1] > noDataValue && data[l - Math.sqrt(l)] > noDataValue;
-}
-
-// This function replaces noDataValue by significant values from parent texture (or 0)
-export function insertSignificantValuesFromParent(data) {
-  let dataParent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => 0;
-  let noDataValue = arguments.length > 2 ? arguments[2] : undefined;
-  for (let i = 0, l = data.length; i < l; ++i) {
-    if (data[i] === noDataValue) {
-      data[i] = dataParent(i);
-    }
-  }
-}