@loaders.gl/mvt 3.0.12 → 3.1.0-alpha.4

package/src/lib/binary-vector-tile/vector-tile-layer.ts

@@ -0,0 +1,109 @@
+/* eslint-disable indent */
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import VectorTileFeature from './vector-tile-feature';
+import Protobuf from 'pbf';
+import {MvtFirstPassedData} from '../types';
+
+export default class VectorTileLayer {
+  version: number;
+  name: string;
+  extent: number;
+  length: number;
+  _pbf: Protobuf;
+  _keys: string[];
+  _values: (string | number | boolean | null)[];
+  _features: number[];
+  constructor(pbf: Protobuf, end: number) {
+    // Public
+    this.version = 1;
+    this.name = '';
+    this.extent = 4096;
+    this.length = 0;
+
+    // Private
+    this._pbf = pbf;
+    this._keys = [];
+    this._values = [];
+    this._features = [];
+
+    pbf.readFields(readLayer, this, end);
+
+    this.length = this._features.length;
+  }
+
+  /**
+   * return feature `i` from this layer as a `VectorTileFeature`
+   *
+   * @param index
+   * @param firstPassData
+   * @returns {VectorTileFeature}
+   */
+  feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error('feature index out of bounds');
+    }
+
+    this._pbf.pos = this._features[i];
+
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(
+      this._pbf,
+      end,
+      this.extent,
+      this._keys,
+      this._values,
+      firstPassData
+    );
+  }
+}
+
+/**
+ *
+ * @param tag
+ * @param layer
+ * @param pbf
+ */
+function readLayer(tag: number, layer?: VectorTileLayer, pbf?: Protobuf): void {
+  if (layer && pbf) {
+    if (tag === 15) layer.version = pbf.readVarint();
+    else if (tag === 1) layer.name = pbf.readString();
+    else if (tag === 5) layer.extent = pbf.readVarint();
+    else if (tag === 2) layer._features.push(pbf.pos);
+    else if (tag === 3) layer._keys.push(pbf.readString());
+    else if (tag === 4) layer._values.push(readValueMessage(pbf));
+  }
+}
+
+/**
+ *
+ * @param pbf
+ * @returns value
+ */
+function readValueMessage(pbf: Protobuf) {
+  let value: string | number | boolean | null = null;
+  const end = pbf.readVarint() + pbf.pos;
+
+  while (pbf.pos < end) {
+    const tag = pbf.readVarint() >> 3;
+
+    value =
+      tag === 1
+        ? pbf.readString()
+        : tag === 2
+        ? pbf.readFloat()
+        : tag === 3
+        ? pbf.readDouble()
+        : tag === 4
+        ? pbf.readVarint64()
+        : tag === 5
+        ? pbf.readVarint()
+        : tag === 6
+        ? pbf.readSVarint()
+        : tag === 7
+        ? pbf.readBoolean()
+        : null;
+  }
+
+  return value;
+}

package/src/lib/binary-vector-tile/vector-tile.ts

@@ -0,0 +1,28 @@
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import VectorTileLayer from './vector-tile-layer';
+import Protobuf from 'pbf';
+
+export default class VectorTile {
+  layers: {[x: string]: VectorTileLayer};
+  constructor(pbf: Protobuf, end?: number) {
+    this.layers = pbf.readFields(readTile, {}, end);
+  }
+}
+
+/**
+ *
+ * @param tag
+ * @param layers
+ * @param pbf
+ */
+function readTile(tag: number, layers?: {[x: string]: VectorTileLayer}, pbf?: Protobuf): void {
+  if (tag === 3) {
+    if (pbf) {
+      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+      if (layer.length && layers) {
+        layers[layer.name] = layer;
+      }
+    }
+  }
+}

package/src/lib/mapbox-vector-tile/{vector-tile-feature.js → vector-tile-feature.ts}

@@ -1,12 +1,28 @@
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
-/* eslint-disable */
+import Protobuf from 'pbf';
+import {MvtMapboxCoordinates, MvtMapboxGeometry} from '../types';
+import {readFeature, classifyRings} from '../../helpers/mapbox-util-functions';
 
 export default class VectorTileFeature {
+  properties: {[x: string]: string | number | boolean | null};
+  extent: any;
+  type: number;
+  id: number | null;
+  _pbf: Protobuf;
+  _geometry: number;
+  _keys: string[];
+  _values: (string | number | boolean | null)[];
   static get types() {
     return ['Unknown', 'Point', 'LineString', 'Polygon'];
   }
 
-  constructor(pbf, end, extent, keys, values) {
+  constructor(
+    pbf: Protobuf,
+    end: number,
+    extent: any,
+    keys: string[],
+    values: (string | number | boolean | null)[]
+  ) {
     // Public
     this.properties = {};
     this.extent = extent;
@@ -23,7 +39,7 @@ export default class VectorTileFeature {
   }
 
   // eslint-disable-next-line complexity, max-statements
-  loadGeometry() {
+  loadGeometry(): MvtMapboxGeometry {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
 
@@ -32,8 +48,8 @@ export default class VectorTileFeature {
     let length = 0;
     let x = 0;
     let y = 0;
-    const lines = [];
-    let line;
+    const lines: number[][][] = [];
+    let line: number[][] | undefined;
 
     while (pbf.pos < end) {
       if (length <= 0) {
@@ -53,8 +69,7 @@ export default class VectorTileFeature {
           if (line) lines.push(line);
           line = [];
         }
-        // @ts-ignore
-        line.push([x, y]);
+        if (line) line.push([x, y]);
       } else if (cmd === 7) {
         // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
         if (line) {
@@ -112,12 +127,13 @@ export default class VectorTileFeature {
   _toGeoJSON(transform) {
     let coords = this.loadGeometry();
     let type = VectorTileFeature.types[this.type];
-    let i;
-    let j;
+    let i: number;
+    let j: number;
 
+    // eslint-disable-next-line default-case
     switch (this.type) {
       case 1:
-        var points = [];
+        const points: number[] = [];
         for (i = 0; i < coords.length; i++) {
           points[i] = coords[i][0];
         }
@@ -147,7 +163,7 @@ export default class VectorTileFeature {
       type = `Multi${type}`;
     }
 
-    const result = {
+    const result: MvtMapboxCoordinates = {
       type: 'Feature',
       geometry: {
         type,
@@ -163,7 +179,9 @@ export default class VectorTileFeature {
     return result;
   }
 
-  toGeoJSON(options) {
+  toGeoJSON(
+    options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
+  ): MvtMapboxCoordinates {
     if (typeof options === 'function') {
       return this._toGeoJSON(options);
     }
@@ -172,7 +190,7 @@ export default class VectorTileFeature {
     const x0 = this.extent * x;
     const y0 = this.extent * y;
 
-    function project(line) {
+    function project(line: number[]) {
       for (let j = 0; j < line.length; j++) {
         const p = line[j];
         p[0] = ((p[0] + x0) * 360) / size - 180;
@@ -183,62 +201,3 @@ export default class VectorTileFeature {
     return this._toGeoJSON(project);
   }
 }
-
-/**
- * Classifies an array of rings into polygons with outer rings and holes
- */
-
-function classifyRings(rings) {
-  const len = rings.length;
-
-  if (len <= 1) return [rings];
-
-  const polygons = [];
-  let polygon;
-  let ccw;
-
-  for (let i = 0; i < len; i++) {
-    const area = signedArea(rings[i]);
-    if (area === 0) continue;
-
-    if (ccw === undefined) ccw = area < 0;
-
-    if (ccw === area < 0) {
-      if (polygon) polygons.push(polygon);
-      polygon = [rings[i]];
-    } else {
-      // @ts-ignore
-      polygon.push(rings[i]);
-    }
-  }
-  if (polygon) polygons.push(polygon);
-
-  return polygons;
-}
-
-function signedArea(ring) {
-  let sum = 0;
-  for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
-    p1 = ring[i];
-    p2 = ring[j];
-    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
-  }
-  return sum;
-}
-
-function readFeature(tag, feature, pbf) {
-  if (tag === 1) feature.id = pbf.readVarint();
-  else if (tag === 2) readTag(pbf, feature);
-  else if (tag === 3) feature.type = pbf.readVarint();
-  else if (tag === 4) feature._geometry = pbf.pos;
-}
-
-function readTag(pbf, feature) {
-  const end = pbf.readVarint() + pbf.pos;
-
-  while (pbf.pos < end) {
-    const key = feature._keys[pbf.readVarint()];
-    const value = feature._values[pbf.readVarint()];
-    feature.properties[key] = value;
-  }
-}

package/src/lib/mapbox-vector-tile/{vector-tile-layer.js → vector-tile-layer.ts}

@@ -1,12 +1,22 @@
+/* eslint-disable indent */
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
 
-import VectorTileFeature from './vector-tile-feature.js';
+import Protobuf from 'pbf';
+import VectorTileFeature from './vector-tile-feature';
 
 export default class VectorTileLayer {
-  constructor(pbf, end) {
+  version: number;
+  name: string;
+  extent: number;
+  length: number;
+  _pbf: Protobuf;
+  _keys: string[];
+  _values: (string | number | boolean | null)[];
+  _features: number[];
+  constructor(pbf: Protobuf, end: number) {
     // Public
     this.version = 1;
-    this.name = null;
+    this.name = '';
     this.extent = 4096;
     this.length = 0;
 
@@ -21,8 +31,13 @@ export default class VectorTileLayer {
     this.length = this._features.length;
   }
 
-  // return feature `i` from this layer as a `VectorTileFeature`
-  feature(i) {
+  /**
+   * return feature `i` from this layer as a `VectorTileFeature`
+   * @param index
+   * @returns feature
+   */
+
+  feature(i: number): VectorTileFeature {
     if (i < 0 || i >= this._features.length) {
       throw new Error('feature index out of bounds');
     }
@@ -34,17 +49,30 @@ export default class VectorTileLayer {
   }
 }
 
-function readLayer(tag, layer, pbf) {
-  if (tag === 15) layer.version = pbf.readVarint();
-  else if (tag === 1) layer.name = pbf.readString();
-  else if (tag === 5) layer.extent = pbf.readVarint();
-  else if (tag === 2) layer._features.push(pbf.pos);
-  else if (tag === 3) layer._keys.push(pbf.readString());
-  else if (tag === 4) layer._values.push(readValueMessage(pbf));
+/**
+ *
+ * @param tag
+ * @param layer
+ * @param pbf
+ */
+function readLayer(tag: number, layer?: VectorTileLayer, pbf?: Protobuf): void {
+  if (layer && pbf) {
+    if (tag === 15) layer.version = pbf.readVarint();
+    else if (tag === 1) layer.name = pbf.readString();
+    else if (tag === 5) layer.extent = pbf.readVarint();
+    else if (tag === 2) layer._features.push(pbf.pos);
+    else if (tag === 3) layer._keys.push(pbf.readString());
+    else if (tag === 4) layer._values.push(readValueMessage(pbf));
+  }
 }
 
-function readValueMessage(pbf) {
-  let value = null;
+/**
+ *
+ * @param pbf
+ * @returns value
+ */
+function readValueMessage(pbf: Protobuf) {
+  let value: string | number | boolean | null = null;
   const end = pbf.readVarint() + pbf.pos;
 
   while (pbf.pos < end) {

package/src/lib/mapbox-vector-tile/vector-tile.ts

@@ -0,0 +1,28 @@
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import VectorTileLayer from './vector-tile-layer';
+import Protobuf from 'pbf';
+
+export default class VectorTile {
+  layers: {[x: string]: VectorTileLayer};
+  constructor(pbf: Protobuf, end?: number) {
+    this.layers = pbf.readFields(readTile, {}, end);
+  }
+}
+
+/**
+ *
+ * @param tag
+ * @param layers
+ * @param pbf
+ */
+function readTile(tag: number, layers?: {[x: string]: VectorTileLayer}, pbf?: Protobuf): void {
+  if (tag === 3) {
+    if (pbf) {
+      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+      if (layer.length && layers) {
+        layers[layer.name] = layer;
+      }
+    }
+  }
+}

package/src/lib/parse-mvt.ts

@@ -0,0 +1,174 @@
+// import {VectorTile} from '@mapbox/vector-tile';
+import VectorTile from './mapbox-vector-tile/vector-tile';
+import BinaryVectorTile from './binary-vector-tile/vector-tile';
+
+import {featuresToBinary} from './binary-vector-tile/features-to-binary';
+import Protobuf from 'pbf';
+import {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';
+import VectorTileFeatureBinary from './binary-vector-tile/vector-tile-feature';
+import VectorTileFeatureMapBox from './mapbox-vector-tile/vector-tile-feature';
+import {LoaderOptions} from '@loaders.gl/loader-utils/';
+
+/**
+ * Parse MVT arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer A MVT arrayBuffer
+ * @param options
+ * @returns A GeoJSON geometry object or a binary representation
+ */
+export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {
+  options = normalizeOptions(options);
+  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];
+
+  if (options) {
+    const binary = options.gis.format === 'binary';
+    const firstPassData = {
+      pointPositionsCount: 0,
+      pointFeaturesCount: 0,
+      linePositionsCount: 0,
+      linePathsCount: 0,
+      lineFeaturesCount: 0,
+      polygonPositionsCount: 0,
+      polygonObjectsCount: 0,
+      polygonRingsCount: 0,
+      polygonFeaturesCount: 0
+    };
+
+    if (arrayBuffer.byteLength > 0) {
+      const tile = binary
+        ? new BinaryVectorTile(new Protobuf(arrayBuffer))
+        : new VectorTile(new Protobuf(arrayBuffer));
+      const loaderOptions = options.mvt;
+
+      const selectedLayers = Array.isArray(loaderOptions.layers)
+        ? loaderOptions.layers
+        : Object.keys(tile.layers);
+
+      selectedLayers.forEach((layerName: string) => {
+        const vectorTileLayer = tile.layers[layerName];
+        const featureOptions = {...loaderOptions, layerName};
+
+        if (!vectorTileLayer) {
+          return;
+        }
+
+        for (let i = 0; i < vectorTileLayer.length; i++) {
+          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
+
+          const decodedFeature = binary
+            ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)
+            : getDecodedFeature(vectorTileFeature as VectorTileFeatureMapBox, featureOptions);
+          features.push(decodedFeature);
+        }
+      });
+    }
+
+    if (binary) {
+      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);
+      // Add the original byteLength (as a reasonable approximation of the size of the binary data)
+      // TODO decide where to store extra fields like byteLength (header etc) and document
+      // @ts-ignore
+      data.byteLength = arrayBuffer.byteLength;
+      return data;
+    }
+  }
+  return features;
+}
+
+/**
+ * @param options
+ * @returns options
+ */
+function normalizeOptions(options: LoaderOptions | undefined) {
+  if (options) {
+    options = {
+      ...options,
+      mvt: options.mvt || {},
+      gis: options.gis || {}
+    };
+
+    // Validate
+    const wgs84Coordinates = options.coordinates === 'wgs84';
+    const {tileIndex} = options;
+    const hasTileIndex =
+      tileIndex &&
+      Number.isFinite(tileIndex.x) &&
+      Number.isFinite(tileIndex.y) &&
+      Number.isFinite(tileIndex.z);
+
+    if (wgs84Coordinates && !hasTileIndex) {
+      throw new Error(
+        'MVT Loader: WGS84 coordinates need tileIndex property. Check documentation.'
+      );
+    }
+  }
+  return options;
+}
+
+/**
+ * @param feature
+ * @param options
+ * @returns decoded feature
+ */
+function getDecodedFeature(
+  feature: VectorTileFeatureMapBox,
+  options: MvtOptions
+): MvtMapboxCoordinates {
+  const decodedFeature = feature.toGeoJSON(
+    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates
+  );
+
+  // Add layer name to GeoJSON properties
+  if (options.layerProperty) {
+    decodedFeature.properties[options.layerProperty] = options.layerName;
+  }
+
+  return decodedFeature;
+}
+
+/**
+ * @param feature
+ * @param options
+ * @returns decoded binary feature
+ */
+function getDecodedFeatureBinary(
+  feature: VectorTileFeatureBinary,
+  options: MvtOptions
+): MvtBinaryCoordinates {
+  const decodedFeature = feature.toBinaryCoordinates(
+    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary
+  );
+
+  // Add layer name to GeoJSON properties
+  if (options.layerProperty) {
+    decodedFeature.properties[options.layerProperty] = options.layerName;
+  }
+
+  return decodedFeature;
+}
+
+/**
+ * @param line
+ * @param feature
+ */
+function transformToLocalCoordinates(line: number[], feature: {extent: any}): void {
+  // This function transforms local coordinates in a
+  // [0 - bufferSize, this.extent + bufferSize] range to a
+  // [0 - (bufferSize / this.extent), 1 + (bufferSize / this.extent)] range.
+  // The resulting extent would be 1.
+  const {extent} = feature;
+  for (let i = 0; i < line.length; i++) {
+    const p = line[i];
+    p[0] /= extent;
+    p[1] /= extent;
+  }
+}
+
+function transformToLocalCoordinatesBinary(data: number[], feature: {extent: any}) {
+  // For the binary code path, the feature data is just
+  // one big flat array, so we just divide each value
+  const {extent} = feature;
+  for (let i = 0, il = data.length; i < il; ++i) {
+    data[i] /= extent;
+  }
+}