@loaders.gl/mvt 4.3.2 → 4.4.0-alpha.2

package/src/lib/pojo-parser/mvt-constants.ts

@@ -0,0 +1,135 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+/**
+ * MVT spec constants
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ */
+export enum TileInfo {
+  /** repeated Layer */
+  layers = 3
+}
+
+/**
+ * MVT spec constants
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ * @note Layers are described in section 4.1 of the specification
+ */
+export enum LayerInfo {
+  /**
+   * Any compliant implementation must first read the version
+   * number encoded in this message and choose the correct
+   * implementation for this version number before proceeding to
+   * decode other parts of this message.
+   * required uint32  [ default = 1 ];
+   */
+  version = 15,
+
+  /** PBF: required string */
+  name = 1,
+
+  /** The actual features in this tile.
+   * PBF: repeated Feature
+   */
+  features = 2,
+
+  /**
+   * Dictionary encoding for keys
+   * PBF: repeated string
+   */
+  keys = 3,
+
+  /**
+   * Dictionary encoding for values
+   * PBF: repeated Value
+   */
+  values = 4,
+
+  /**
+   * Although this is an "optional" field it is required by the specification.
+   * See https://github.com/mapbox/vector-tile-spec/issues/47
+   * PBF: optional uint32 [ default = 4096 ];
+   */
+  extent = 5
+
+  // extensions 16 to max;
+}
+
+/**
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ * Features are described in section 4.2 of the specification
+ */
+export enum FeatureInfo {
+  /** optional uint64 [ default = 0 ]; */
+  id = 1,
+
+  /**
+   * Tags of this feature are encoded as repeated pairs of integers.
+   * A detailed description of tags is located in sections 4.2 and 4.4 of the specification
+   * repeated uint32  [ packed = true ];
+   */
+  tags = 2,
+
+  /**
+   * The type of geometry stored in this feature.
+   * GeomType  [ default = UNKNOWN ];
+   */
+  type = 3,
+
+  /**
+   * Contains a stream of commands and parameters (vertices).
+   * A detailed description on geometry encoding is located in
+   * section 4.3 of the specification.
+   * repeated uint32  [ packed = true ];
+   */
+  geometry = 4
+}
+
+/**
+ * GeomType is described in section 4.3.4 of the specification
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ * */
+export enum GeometryType {
+  UNKNOWN = 0,
+  POINT = 1,
+  LINESTRING = 2,
+  POLYGON = 3
+}
+
+/**
+ * Variant type encoding
+ * The use of values is described in section 4.1 of the specification
+ * @note Exactly one of these values must be present in a valid message
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ */
+export enum PropertyType {
+  /** string */
+  string_value = 1, //
+  /** float */
+  float_value = 2,
+  /** double */
+  double_value = 3,
+  /** int64 */
+  int_value = 4,
+  /** uint64 */
+  uint_value = 5,
+  /** sint64 */
+  sint_value = 6,
+  /** bool */
+  bool_value = 7
+  // extensions 8 to max;
+}
+
+/**
+ * "Turtle graphics" style geometry commands
+ * @see https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md
+ */
+export enum Command {
+  /** 2 Parameters: dX, dY */
+  MoveTo = 1,
+  /** 2 Parameters dX, dY */
+  LineTo = 2,
+  /** No parameters */
+  ClosePath = 7
+}

package/src/lib/pojo-parser/mvt-types.ts

@@ -0,0 +1,22 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+import type {Schema, FlatIndexedGeometry} from '@loaders.gl/schema';
+
+export type MVTTile = {
+  layers: Record<string, MVTLayer>;
+};
+
+export type MVTLayer = {
+  version: number;
+  name: string;
+  extent: number;
+  length: number;
+  schema: Schema;
+  columns: Record<string, (string | number | boolean | null)[]>;
+  idColumn: number[];
+  boundingBoxColumn: [number, number, number, number][];
+  geometryTypeColumn: number[];
+  geometryColumn: FlatIndexedGeometry[];
+};

package/src/lib/pojo-parser/parse-geometry-from-pbf.ts

@@ -0,0 +1,285 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+// This code is inspired by https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import type {
+  // Feature,
+  // FlatFeature,
+  // FlatGeometry,
+  FlatIndexedGeometry
+  // GeojsonGeometryInfo
+} from '@loaders.gl/schema';
+
+import Protobuf from 'pbf';
+
+import * as MVT from './mvt-constants';
+
+// import {
+//   classifyRings,
+//   classifyRingsFlat,
+//   projectToLngLat,
+//   projectToLngLatFlat,
+//   convertToLocalCoordinates,
+//   convertToLocalCoordinatesFlat
+// } from '../utils/geometry-utils';
+
+type GeometryCommand = {type: 'moveto' | 'lineto' | 'closepath'; x: number; y: number};
+
+export function* makeMVTGeometryCommandIterator(pbf: Protobuf): IterableIterator<GeometryCommand> {
+  const endPos = pbf.readVarint() + pbf.pos;
+  let cmd = 1;
+  let cmdLen: number;
+  let length = 0;
+
+  // Note: We reuse and return the same command object to avoid creating new objects
+  const command: GeometryCommand = {type: 'closepath', x: 0, y: 0};
+
+  while (pbf.pos < endPos) {
+    if (length <= 0) {
+      cmdLen = pbf.readVarint();
+      cmd = cmdLen & 0x7;
+      length = cmdLen >> 3;
+    }
+
+    length--;
+
+    switch (cmd as MVT.Command) {
+      case MVT.Command.MoveTo:
+        command.type = 'moveto';
+        command.x += pbf.readSVarint();
+        command.y += pbf.readSVarint();
+        yield command;
+        break;
+
+      case MVT.Command.LineTo:
+        command.type = 'lineto';
+        command.x += pbf.readSVarint();
+        command.y += pbf.readSVarint();
+        yield command;
+        break;
+
+      case MVT.Command.ClosePath:
+        command.type = 'moveto';
+        yield command;
+        break;
+
+      default:
+        throw new Error(`unknown command ${cmd}`);
+    }
+  }
+}
+
+/**
+ * Creates a bounding box from the feature geometry at the current position
+ * @todo - Reparses the entire PBF geometry - replace with a generic bounding box calculation on parsed data?
+ */
+export function readBoundingBoxFromPBF(pbf: Protobuf): [number, number, number, number] {
+  let x1 = Infinity;
+  let x2 = -Infinity;
+  let y1 = Infinity;
+  let y2 = -Infinity;
+
+  for (const command of makeMVTGeometryCommandIterator(pbf)) {
+    switch (command.type) {
+      case 'moveto':
+      case 'lineto':
+        if (command.x < x1) x1 = command.x;
+        if (command.x > x2) x2 = command.x;
+        if (command.y < y1) y1 = command.y;
+        if (command.y > y2) y2 = command.y;
+        break;
+
+      case 'closepath':
+      default:
+      // ignore
+    }
+  }
+
+  return [x1, y1, x2, y2];
+}
+
+/**
+ * Extract 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 `indices`
+ * parameter, e.g.
+ *
+ * geometry: {
+ *   type: 'Point', data: [1,2], indices: [0]
+ * }
+ * geometry: {
+ *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+ * }
+ * geometry: {
+ *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+ * }
+ * 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 indices array
+ */
+// eslint-disable-next-line complexity, max-statements
+export function loadFlatGeometryFromPBF(pbf: Protobuf): FlatIndexedGeometry {
+  // Note: I attempted to replace the `data` array with a
+  // Float32Array, but performance was worse, both using
+  // `set()` and direct index access. Also, we cannot
+  // know how large the buffer should be, so it would
+  // increase memory usage
+  const indices: number[] = []; // Indices where geometries start
+  const data: number[] = []; // Flat array of coordinate data
+  let i = 0;
+
+  for (const command of makeMVTGeometryCommandIterator(pbf)) {
+    switch (command.type) {
+      case 'moveto':
+        // New line
+        indices.push(i);
+        data.push(command.x, command.y);
+        i += 2;
+        break;
+
+      case 'lineto':
+        data.push(command.x, command.y);
+        i += 2;
+        break;
+
+      case 'closepath':
+        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+        if (i > 0) {
+          const start = indices[indices.length - 1]; // start index of polygon
+          data.push(data[start], data[start + 1]); // closePolygon
+          i += 2;
+        }
+        break;
+
+      default:
+      // just for eslint
+    }
+  }
+
+  return {data, indices};
+}
+
+/**
+ * Load a GeoJSON style Geometry from the raw PBF
+ *
+function readGeoJSONGeometryFromPBF(pbf): number[][][] {
+  const lines: number[][][] = [];
+  let line: number[][] | undefined;
+
+  for (const command of makeMVTGeometryCommandIterator(pbf)) {
+    switch (command.type) {
+      case 'moveto':
+        // moveTo
+        if (line) lines.push(line);
+        line = [];
+        if (line) line.push([command.x, command.y]);
+        break;
+
+      case 'lineto':
+        if (line) line.push([command.x, command.y]);
+        break;
+
+      case 'closepath':
+        // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+        if (line) {
+          line.push(line[0].slice()); // closePolygon
+        }
+        break;
+
+      default:
+      // just for eslint
+    }
+  }
+
+  if (line) {
+    lines.push(line);
+  }
+
+  return lines;
+}
+*/
+
+// export class VectorTileFeature implements MVTFeature {
+//   properties: Record<string, string | number | boolean | null>;
+//   extent: any;
+//   type: number;
+//   id: number | null;
+//   _pbf: Protobuf;
+//   _geometryPos: number;
+//   _keys: string[];
+//   _values: (string | number | boolean | null)[];
+//   _geometryInfo: GeojsonGeometryInfo;
+
+//   static types = MVT_GEOMETRY_TYPES;
+
+//   // eslint-disable-next-line max-params
+//   constructor(
+//     pbf: Protobuf,
+//     end: number,
+//     extent: any,
+//     keys: string[],
+//     values: (string | number | boolean | null)[],
+//     geometryInfo?: GeojsonGeometryInfo
+//   ) {
+//     // Public
+//     this.properties = {};
+//     this.extent = extent;
+//     this.type = 0;
+//     this.id = null;
+
+//     // Private
+//     this._pbf = pbf;
+//     this._geometryPos = -1;
+//     this._keys = keys;
+//     this._values = values;
+
+//     // Only used by binary tiles
+//     this._geometryInfo = geometryInfo!;
+
+//     pbf.readFields(readFeatureFromPBF, this, end);
+//   }
+
+//   toGeoJSONFeature(
+//     coordinates: 'wgs84' | 'local',
+//     tileIndex?: {x: number; y: number; z: number}
+//   ): Feature {
+//     return readGeoJSONFeatureFromPBF(this, coordinates, this.extent, tileIndex);
+//   }
+
+//   /**
+//    *
+//    * @param options
+//    * @returns
+//    */
+//   toBinaryFeature(
+//     coordinates: 'wgs84' | 'local',
+//     tileIndex?: {x: number; y: number; z: number}
+//   ): FlatFeature {
+//     return readFlatFeatureFromPBF(this, coordinates, this.extent, tileIndex);
+//   }
+
+//   /** Read a bounding box from the feature */
+//   bbox() {
+//     this._pbf.pos = this._geometryPos;
+//     return readBoundingBoxFromPBF(this._pbf);
+//   }
+
+//   // Geometry helpers
+
+//   /** Parses protobuf data to nested "GeoJSON like" coordinates array */
+//   loadGeometry(): number[][][] {
+//     this._pbf.pos = this._geometryPos;
+//     return readGeoJSONGeometryFromPBF(this._pbf);
+//   }
+
+//   /** Parses protobuf data to an intermediate "Flat GeoJSON" data format */
+//   loadFlatGeometry(): FlatIndexedGeometry {
+//     this._pbf.pos = this._geometryPos;
+//     return loadFlatGeometryFromPBF(this._pbf);
+//   }
+// }