@loaders.gl/mvt 3.1.0 → 3.1.4

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

@@ -1,7 +1,7 @@
 // This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
 
 import Protobuf from 'pbf';
-import {MvtBinaryCoordinates, MvtBinaryGeometry, MvtFirstPassedData} from '../types';
+import {FlatFeature, FlatIndexedGeometry, GeojsonGeometryInfo} from '@loaders.gl/schema';
 import {classifyRings, project, readFeature} from '../../helpers/binary-util-functions';
 
 // Reduce GC by reusing variables
@@ -26,10 +26,7 @@ export default class VectorTileFeature {
   _geometry: number;
   _keys: string[];
   _values: (string | number | boolean | null)[];
-  _firstPassData: MvtFirstPassedData;
-  static get types() {
-    return ['Unknown', 'Point', 'LineString', 'Polygon'];
-  }
+  _geometryInfo: GeojsonGeometryInfo;
 
   // eslint-disable-next-line max-params
   constructor(
@@ -38,7 +35,7 @@ export default class VectorTileFeature {
     extent: any,
     keys: string[],
     values: (string | number | boolean | null)[],
-    firstPassData: MvtFirstPassedData
+    geometryInfo: GeojsonGeometryInfo
   ) {
     // Public
     this.properties = {};
@@ -51,13 +48,13 @@ export default class VectorTileFeature {
     this._geometry = -1;
     this._keys = keys;
     this._values = values;
-    this._firstPassData = firstPassData;
+    this._geometryInfo = geometryInfo;
 
     pbf.readFields(readFeature, this, end);
   }
 
   // eslint-disable-next-line complexity, max-statements
-  loadGeometry(): MvtBinaryGeometry {
+  loadGeometry(): FlatIndexedGeometry {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
 
@@ -73,7 +70,7 @@ export default class VectorTileFeature {
     // `set()` and direct index access. Also, we cannot
     // know how large the buffer should be, so it would
     // increase memory usage
-    const lines: number[] = []; // Indices where lines start
+    const indices: number[] = []; // Indices where geometries start
     const data: number[] = []; // Flat array of coordinate data
 
     while (pbf.pos < endPos) {
@@ -91,14 +88,14 @@ export default class VectorTileFeature {
 
         if (cmd === 1) {
           // New line
-          lines.push(i);
+          indices.push(i);
         }
         data.push(x, y);
         i += 2;
       } else if (cmd === 7) {
         // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
         if (i > 0) {
-          const start = lines[lines.length - 1]; // start index of polygon
+          const start = indices[indices.length - 1]; // start index of polygon
           data.push(data[start], data[start + 1]); // closePolygon
           i += 2;
         }
@@ -107,7 +104,7 @@ export default class VectorTileFeature {
       }
     }
 
-    return {data, lines};
+    return {data, indices};
   }
 
   /**
@@ -116,27 +113,28 @@ export default class VectorTileFeature {
    * @returns result
    */
   _toBinaryCoordinates(transform) {
-    // Expands the protobuf data to an intermediate `lines`
+    // Expands the protobuf data to an intermediate Flat GeoJSON
     // data format, which maps closely to the binary data buffers.
     // It is similar to GeoJSON, but rather than storing the coordinates
     // in multidimensional arrays, we have a 1D `data` with all the
-    // coordinates, and then index into this using the `lines`
+    // coordinates, and then index into this using the `indices`
     // parameter, e.g.
     //
     // geometry: {
-    //   type: 'Point', data: [1,2], lines: [0]
+    //   type: 'Point', data: [1,2], indices: [0]
     // }
     // geometry: {
-    //   type: 'LineString', data: [1,2,3,4,...], lines: [0]
+    //   type: 'LineString', data: [1,2,3,4,...], indices: [0]
     // }
     // geometry: {
-    //   type: 'Polygon', data: [1,2,3,4,...], lines: [[0, 2]]
+    //   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
     // }
-    // Thus the lines member lets us look up the relevant range
+    // Thus the indices member lets us look up the relevant range
     // from the data array.
     // The Multi* versions of the above types share the same data
-    // structure, just with multiple elements in the lines array
-    let geom = this.loadGeometry();
+    // structure, just with multiple elements in the indices array
+    const geom = this.loadGeometry();
+    let geometry;
 
     // Apply the supplied transformation to data
     transform(geom.data, this);
@@ -146,43 +144,37 @@ export default class VectorTileFeature {
     // eslint-disable-next-line default-case
     switch (this.type) {
       case 1: // Point
-        this._firstPassData.pointFeaturesCount++;
-        this._firstPassData.pointPositionsCount += geom.lines.length;
+        this._geometryInfo.pointFeaturesCount++;
+        this._geometryInfo.pointPositionsCount += geom.indices.length;
+        geometry = {type: 'Point', ...geom};
         break;
 
       case 2: // LineString
-        this._firstPassData.lineFeaturesCount++;
-        this._firstPassData.linePathsCount += geom.lines.length;
-        this._firstPassData.linePositionsCount += geom.data.length / coordLength;
+        this._geometryInfo.lineFeaturesCount++;
+        this._geometryInfo.linePathsCount += geom.indices.length;
+        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+        geometry = {type: 'LineString', ...geom};
         break;
 
       case 3: // Polygon
-        const classified = classifyRings(geom);
+        geometry = classifyRings(geom);
 
-        // Unlike Point & LineString geom.lines is a 2D array, thanks
+        // Unlike Point & LineString geom.indices is a 2D array, thanks
         // to the classifyRings method
-        this._firstPassData.polygonFeaturesCount++;
-        this._firstPassData.polygonObjectsCount += classified.lines.length;
+        this._geometryInfo.polygonFeaturesCount++;
+        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
 
-        for (const lines of classified.lines) {
-          this._firstPassData.polygonRingsCount += lines.length;
+        for (const indices of geometry.indices) {
+          this._geometryInfo.polygonRingsCount += indices.length;
         }
-        this._firstPassData.polygonPositionsCount += classified.data.length / coordLength;
+        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
 
-        geom = classified;
         break;
+      default:
+        throw new Error(`Invalid geometry type: ${this.type}`);
     }
 
-    geom.type = VectorTileFeature.types[this.type];
-    if (geom.lines.length > 1) {
-      geom.type = `Multi${geom.type}`;
-    }
-
-    const result: MvtBinaryCoordinates = {
-      type: 'Feature',
-      geometry: geom,
-      properties: this.properties
-    };
+    const result: FlatFeature = {type: 'Feature', geometry, properties: this.properties};
 
     if (this.id !== null) {
       result.id = this.id;
@@ -193,7 +185,7 @@ export default class VectorTileFeature {
 
   toBinaryCoordinates(
     options: {x: number; y: number; z: number} | ((data: number[], feature: {extent: any}) => void)
-  ): MvtBinaryCoordinates {
+  ): FlatFeature {
     if (typeof options === 'function') {
       return this._toBinaryCoordinates(options);
     }

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

@@ -3,7 +3,7 @@
 
 import VectorTileFeature from './vector-tile-feature';
 import Protobuf from 'pbf';
-import {MvtFirstPassedData} from '../types';
+import {GeojsonGeometryInfo} from '@loaders.gl/schema';
 
 export default class VectorTileLayer {
   version: number;
@@ -36,10 +36,10 @@ export default class VectorTileLayer {
    * return feature `i` from this layer as a `VectorTileFeature`
    *
    * @param index
-   * @param firstPassData
+   * @param geometryInfo
    * @returns {VectorTileFeature}
    */
-  feature(i: number, firstPassData: MvtFirstPassedData): VectorTileFeature {
+  feature(i: number, geometryInfo: GeojsonGeometryInfo): VectorTileFeature {
     if (i < 0 || i >= this._features.length) {
       throw new Error('feature index out of bounds');
     }
@@ -53,7 +53,7 @@ export default class VectorTileLayer {
       this.extent,
       this._keys,
       this._values,
-      firstPassData
+      geometryInfo
     );
   }
 }

package/src/lib/parse-mvt.ts

@@ -2,9 +2,10 @@
 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 {flatGeojsonToBinary} from '@loaders.gl/gis';
 import Protobuf from 'pbf';
-import {MvtBinaryCoordinates, MvtMapboxCoordinates, MvtOptions} from '../lib/types';
+import type {FlatFeature} from '@loaders.gl/schema';
+import type {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';
@@ -18,11 +19,12 @@ import {LoaderOptions} from '@loaders.gl/loader-utils';
  */
 export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptions) {
   options = normalizeOptions(options);
-  const features: (MvtBinaryCoordinates | MvtMapboxCoordinates)[] = [];
+  const features: (FlatFeature | MvtMapboxCoordinates)[] = [];
 
   if (options) {
     const binary = options.gis.format === 'binary';
-    const firstPassData = {
+    const geometryInfo = {
+      coordLength: 2,
       pointPositionsCount: 0,
       pointFeaturesCount: 0,
       linePositionsCount: 0,
@@ -53,7 +55,7 @@ export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptio
         }
 
         for (let i = 0; i < vectorTileLayer.length; i++) {
-          const vectorTileFeature = vectorTileLayer.feature(i, firstPassData);
+          const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
 
           const decodedFeature = binary
             ? getDecodedFeatureBinary(vectorTileFeature as VectorTileFeatureBinary, featureOptions)
@@ -64,7 +66,7 @@ export default function parseMVT(arrayBuffer: ArrayBuffer, options?: LoaderOptio
     }
 
     if (binary) {
-      const data = featuresToBinary(features as MvtBinaryCoordinates[], firstPassData);
+      const data = flatGeojsonToBinary(features as FlatFeature[], geometryInfo);
       // 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
@@ -134,13 +136,13 @@ function getDecodedFeature(
 function getDecodedFeatureBinary(
   feature: VectorTileFeatureBinary,
   options: MvtOptions
-): MvtBinaryCoordinates {
+): FlatFeature {
   const decodedFeature = feature.toBinaryCoordinates(
     options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary
   );
 
   // Add layer name to GeoJSON properties
-  if (options.layerProperty) {
+  if (options.layerProperty && decodedFeature.properties) {
     decodedFeature.properties[options.layerProperty] = options.layerName;
   }
 

package/src/lib/types.ts

@@ -5,14 +5,6 @@ export type MvtOptions = {
   layerName: string;
 };
 
-export type MvtBinaryGeometry = {
-  data: number[];
-  lines: any[];
-  areas?: number[];
-  type?: string;
-  id?: number;
-};
-
 export type MvtMapboxGeometry = {
   type?: string;
   id?: number;
@@ -20,13 +12,6 @@ export type MvtMapboxGeometry = {
   coordinates?: any[];
 };
 
-export type MvtBinaryCoordinates = {
-  type: string;
-  geometry: MvtBinaryGeometry;
-  properties: {[x: string]: string | number | boolean | null};
-  id?: number;
-};
-
 export type MvtMapboxCoordinates = {
   type: string;
   geometry: {
@@ -36,63 +21,3 @@ export type MvtMapboxCoordinates = {
   properties: {[x: string]: string | number | boolean | null};
   id?: number;
 };
-
-export type MvtPropArrayConstructor =
-  | Float32ArrayConstructor
-  | Float64ArrayConstructor
-  | ArrayConstructor;
-
-export type MvtBinaryOptions = {
-  numericPropKeys: string[];
-  propArrayTypes: {[key: string]: MvtPropArrayConstructor};
-  PositionDataType: Float32ArrayConstructor;
-};
-
-export type MvtFirstPassedData = {
-  pointPositionsCount: number;
-  pointFeaturesCount: number;
-  linePositionsCount: number;
-  linePathsCount: number;
-  lineFeaturesCount: number;
-  polygonPositionsCount: number;
-  polygonObjectsCount: number;
-  polygonRingsCount: number;
-  polygonFeaturesCount: number;
-};
-
-export type MvtPoints = {
-  positions: Float32Array;
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};
-
-export type MvtLines = {
-  pathIndices: Uint16Array | Uint32Array;
-  positions: Float32Array;
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};
-
-export type MvtPolygons = {
-  polygonIndices: Uint16Array | Uint32Array;
-  primitivePolygonIndices: Uint16Array | Uint32Array;
-  positions: Float32Array;
-  triangles: number[];
-  globalFeatureIds: Uint16Array | Uint32Array;
-  featureIds: Uint16Array | Uint32Array;
-  numericProps: object;
-  properties: {}[];
-  fields: {
-    id?: number;
-  }[];
-};