itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Parser/ShapefileParser.js

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,215 @@
+import { Vector2, Vector3 } from 'three';
+import Protobuf from 'pbf';
+import { VectorTile } from '@mapbox/vector-tile';
+import { FeatureCollection, FEATURE_TYPES } from "../Core/Feature.js";
+import { globalExtentTMS } from "../Core/Tile/TileGrid.js";
+import { deprecatedParsingOptionsToNewOne } from "../Core/Deprecated/Undeprecator.js";
+import { Coordinates } from '@itowns/geographic';
+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

@@ -0,0 +1,120 @@
+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);
+    }
+  }
+}