@loaders.gl/tiles 5.0.0-alpha.11 → 5.0.0-alpha.13

package/src/mvt/lib/utils/geometry-utils.ts

@@ -0,0 +1,238 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+import {getPolygonSignedArea} from '@math.gl/geometry/polygon';
+import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/core/schema';
+
+/**
+ *
+ * @param ring
+ * @returns sum
+ */
+export function signedArea(ring: number[][]) {
+  let sum = 0;
+  for (let i = 0, j = ring.length - 1, p1: number[], p2: number[]; i < ring.length; j = i++) {
+    p1 = ring[i];
+    p2 = ring[j];
+    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  }
+  return sum;
+}
+
+/**
+ * This function projects 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.
+ * @param line
+ * @param feature
+ */
+export function convertToLocalCoordinates(
+  coordinates: number[] | number[][] | number[][][] | number[][][][],
+  extent: number
+): void {
+  if (Array.isArray(coordinates[0])) {
+    for (const subcoords of coordinates) {
+      convertToLocalCoordinates(subcoords as number[] | number[][] | number[][][], extent);
+    }
+    return;
+  }
+
+  // Just a point
+  const p = coordinates as number[];
+  p[0] /= extent;
+  p[1] /= extent;
+}
+
+/**
+ * For the binary code path, the feature data is just
+ * one big flat array, so we just divide each value
+ * @param data
+ * @param feature
+ */
+export function convertToLocalCoordinatesFlat(data: number[], extent: number): void {
+  for (let i = 0; i < data.length; ++i) {
+    data[i] /= extent;
+  }
+}
+
+/**
+ * Projects local tile coordinates to lngLat in place.
+ * @param points
+ * @param tileIndex
+ */
+export function projectToLngLat(
+  line: number[] | number[][] | number[][][],
+  tileIndex: {x: number; y: number; z: number},
+  extent: number
+): void {
+  if (typeof line[0] === 'number') {
+    projectToLngLat([line as number[]], tileIndex, extent);
+    return;
+  }
+  if (typeof line[0][0] !== 'number') {
+    for (const point of line) {
+      // @ts-expect-error
+      projectToLngLat(point, tileIndex, extent);
+    }
+    return;
+  }
+  const size = extent * Math.pow(2, tileIndex.z);
+  const x0 = extent * tileIndex.x;
+  const y0 = extent * tileIndex.y;
+  for (let j = 0; j < line.length; j++) {
+    const p = line[j];
+    p[0] = ((p[0] + x0) * 360) / size - 180;
+    const y2 = 180 - ((p[1] + y0) * 360) / size;
+    p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+  }
+}
+
+/**
+ * Projects local tile coordinates to lngLat in place.
+ * @param points
+ * @param tileIndex
+export function projectTileCoordinatesToLngLat(
+  points: number[][],
+  tileIndex: {x: number; y: number; z: number},
+  extent: number
+): void {
+  const {x, y, z} = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+
+  for (const p of points) {
+    p[0] = ((p[0] + x0) * 360) / size - 180;
+    const y2 = 180 - ((p[1] + y0) * 360) / size;
+    p[1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+  }
+}
+ */
+
+/**
+ *
+ * @param data
+ * @param x0
+ * @param y0
+ * @param size
+ */
+export function projectToLngLatFlat(
+  data: number[],
+  tileIndex: {x: number; y: number; z: number},
+  extent: number
+): void {
+  const {x, y, z} = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+
+  for (let j = 0, jl = data.length; j < jl; j += 2) {
+    data[j] = ((data[j] + x0) * 360) / size - 180;
+    const y2 = 180 - ((data[j + 1] + y0) * 360) / size;
+    data[j + 1] = (360 / Math.PI) * Math.atan(Math.exp((y2 * Math.PI) / 180)) - 90;
+  }
+}
+
+/**
+ * Classifies an array of rings into polygons with outer rings and holes
+ * @param rings
+ * @returns polygons
+ */
+export function classifyRings(rings: number[][][]): number[][][][] {
+  const len = rings.length;
+
+  if (len <= 1) return [rings];
+
+  const polygons: number[][][][] = [];
+  let polygon: number[][][] | undefined;
+  let ccw: boolean | undefined;
+
+  for (let i = 0; i < len; i++) {
+    const area = signedArea(rings[i]);
+    if (area === 0) continue; // eslint-disable-line no-continue
+
+    if (ccw === undefined) ccw = area < 0;
+
+    if (ccw === area < 0) {
+      if (polygon) polygons.push(polygon);
+      polygon = [rings[i]];
+    } else if (polygon) polygon.push(rings[i]);
+  }
+  if (polygon) polygons.push(polygon);
+
+  return polygons;
+}
+
+/**
+ * Classifies an array of rings into polygons with outer rings and holes
+ * The function also detects holes which have zero area and
+ * removes them. In doing so it modifies the input
+ * `geom.data` array to remove the unneeded data
+ *
+ * @param geometry
+ * @returns object
+ */
+// eslint-disable-next-line max-statements
+export function classifyRingsFlat(geom: FlatIndexedGeometry): FlatPolygon {
+  const len = geom.indices.length;
+  const type = 'Polygon';
+
+  if (len <= 1) {
+    return {
+      type,
+      data: geom.data,
+      areas: [[getPolygonSignedArea(geom.data)]],
+      indices: [geom.indices]
+    };
+  }
+
+  const areas: any[] = [];
+  const polygons: any[] = [];
+  let ringAreas: number[] = [];
+  let polygon: number[] = [];
+  let ccw: boolean | undefined;
+  let offset = 0;
+
+  for (let endIndex: number, i = 0, startIndex: number; i < len; i++) {
+    startIndex = geom.indices[i] - offset;
+
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
+    const shape = geom.data.slice(startIndex, endIndex);
+    const area = getPolygonSignedArea(shape);
+
+    if (area === 0) {
+      // This polygon has no area, so remove it from the shape
+      // Remove the section from the data array
+      const before = geom.data.slice(0, startIndex);
+      const after = geom.data.slice(endIndex);
+      geom.data = before.concat(after);
+
+      // Need to offset any remaining indices as we have
+      // modified the data buffer
+      offset += endIndex - startIndex;
+
+      // Do not add this index to the output and process next shape
+      continue; // eslint-disable-line no-continue
+    }
+
+    if (ccw === undefined) ccw = area < 0;
+
+    if (ccw === area < 0) {
+      if (polygon.length) {
+        areas.push(ringAreas);
+        polygons.push(polygon);
+      }
+      polygon = [startIndex];
+      ringAreas = [area];
+    } else {
+      ringAreas.push(area);
+      polygon.push(startIndex);
+    }
+  }
+  if (ringAreas) areas.push(ringAreas);
+  if (polygon.length) polygons.push(polygon);
+
+  return {type, areas, indices: polygons, data: geom.data};
+}

package/src/mvt/lib/vector-tile/LICENSE.txt

@@ -0,0 +1,31 @@
+This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+---
+
+Copyright (c) 2014, Mapbox
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of Mapbox nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

@@ -0,0 +1,430 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import type {Feature, FlatFeature, FlatIndexedGeometry} from '@loaders.gl/core/schema';
+import type {GeojsonGeometryInfo} from '@loaders.gl/arrow-geometry/legacy-binary';
+import Protobuf from 'pbf';
+import {
+  classifyRings,
+  classifyRingsFlat,
+  projectToLngLat,
+  projectToLngLatFlat,
+  convertToLocalCoordinates,
+  convertToLocalCoordinatesFlat
+} from '../utils/geometry-utils';
+
+export 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)[];
+  _geometryInfo: GeojsonGeometryInfo;
+
+  static types: Readonly<string[]> = ['Unknown', 'Point', 'LineString', 'Polygon'];
+
+  // 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._geometry = -1;
+    this._keys = keys;
+    this._values = values;
+
+    // Only used by binary tiles
+    this._geometryInfo = geometryInfo!;
+
+    pbf.readFields(readFeature, this, end);
+  }
+
+  toGeoJSONFeature(
+    coordinates: 'wgs84' | 'local',
+    tileIndex?: {x: number; y: number; z: number}
+  ): Feature {
+    const coords = this.loadGeometry();
+
+    switch (coordinates) {
+      case 'wgs84':
+        return _toGeoJSONFeature(this, coords, (line: number[][]) =>
+          projectToLngLat(line, tileIndex!, this.extent)
+        );
+
+      default:
+        return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
+    }
+  }
+  /**
+   *
+   * @param options
+   * @returns
+   */
+  toBinaryFeature(
+    coordinates: 'wgs84' | 'local',
+    tileIndex?: {x: number; y: number; z: number}
+  ): FlatFeature {
+    const geom = this.loadFlatGeometry();
+
+    switch (coordinates) {
+      case 'wgs84':
+        return this._toBinaryCoordinates(geom, (coords: number[]) =>
+          projectToLngLatFlat(coords, tileIndex!, this.extent)
+        );
+
+      default:
+        return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
+    }
+  }
+
+  /** Read a bounding box from the feature */
+  // eslint-disable-next-line max-statements
+  bbox() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let x1 = Infinity;
+    let x2 = -Infinity;
+    let y1 = Infinity;
+    let y2 = -Infinity;
+
+    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 (x < x1) x1 = x;
+        if (x > x2) x2 = x;
+        if (y < y1) y1 = y;
+        if (y > y2) y2 = y;
+      } else if (cmd !== 7) {
+        throw new Error(`unknown command ${cmd}`);
+      }
+    }
+
+    return [x1, y1, x2, y2];
+  }
+
+  // BINARY HELPERS
+
+  /**
+   *
+   * @param transform
+   * @returns result
+   */
+  _toBinaryCoordinates(
+    geom: FlatIndexedGeometry,
+    transform: (data: number[], extent: number) => void
+  ) {
+    let geometry;
+
+    // Apply the supplied transformation to data
+    transform(geom.data, this.extent);
+
+    const coordLength = 2;
+
+    // eslint-disable-next-line default-case
+    switch (this.type) {
+      case 1: // Point
+        this._geometryInfo.pointFeaturesCount++;
+        this._geometryInfo.pointPositionsCount += geom.indices.length;
+        geometry = {type: 'Point', ...geom};
+        break;
+
+      case 2: // LineString
+        this._geometryInfo.lineFeaturesCount++;
+        this._geometryInfo.linePathsCount += geom.indices.length;
+        this._geometryInfo.linePositionsCount += geom.data.length / coordLength;
+        geometry = {type: 'LineString', ...geom};
+        break;
+
+      case 3: // Polygon
+        geometry = classifyRingsFlat(geom);
+
+        // Unlike Point & LineString geom.indices is a 2D array, thanks
+        // to the classifyRings method
+        this._geometryInfo.polygonFeaturesCount++;
+        this._geometryInfo.polygonObjectsCount += geometry.indices.length;
+
+        for (const indices of geometry.indices) {
+          this._geometryInfo.polygonRingsCount += indices.length;
+        }
+        this._geometryInfo.polygonPositionsCount += geometry.data.length / coordLength;
+
+        break;
+      default:
+        throw new Error(`Invalid geometry type: ${this.type}`);
+    }
+
+    const result: FlatFeature = {type: 'Feature', geometry, properties: this.properties};
+
+    if (this.id !== null) {
+      result.id = this.id;
+    }
+
+    return result;
+  }
+
+  // GEOJSON HELPER
+
+  // eslint-disable-next-line complexity, max-statements
+  loadGeometry(): number[][][] {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    const lines: number[][][] = [];
+    let line: number[][] | undefined;
+
+    while (pbf.pos < end) {
+      if (length <= 0) {
+        const cmdLen = pbf.readVarint();
+        cmd = cmdLen & 0x7;
+        length = cmdLen >> 3;
+      }
+
+      length--;
+
+      switch (cmd) {
+        case 1:
+        case 2:
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+
+          if (cmd === 1) {
+            // moveTo
+            if (line) lines.push(line);
+            line = [];
+          }
+          if (line) line.push([x, y]);
+          break;
+        case 7:
+          // Workaround for https://github.com/mapbox/mapnik-vector-tile/issues/90
+          if (line) {
+            line.push(line[0].slice()); // closePolygon
+          }
+          break;
+        default:
+          throw new Error(`unknown command ${cmd}`);
+      }
+    }
+
+    if (line) lines.push(line);
+
+    return 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 `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
+  loadFlatGeometry(): FlatIndexedGeometry {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+
+    const endPos = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let cmdLen: number;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let i = 0;
+
+    // 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
+
+    while (pbf.pos < endPos) {
+      if (length <= 0) {
+        cmdLen = pbf.readVarint();
+        cmd = cmdLen & 0x7;
+        length = cmdLen >> 3;
+      }
+
+      length--;
+
+      if (cmd === 1 || cmd === 2) {
+        x += pbf.readSVarint();
+        y += pbf.readSVarint();
+
+        if (cmd === 1) {
+          // New line
+          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 = indices[indices.length - 1]; // start index of polygon
+          data.push(data[start], data[start + 1]); // closePolygon
+          i += 2;
+        }
+      } else {
+        throw new Error(`unknown command ${cmd}`);
+      }
+    }
+
+    return {data, indices};
+  }
+}
+
+function _toGeoJSONFeature(
+  vtFeature: VectorTileFeature,
+  coords: number[][][],
+  transform: (data: number[][], extent: number) => void
+): Feature {
+  let type = VectorTileFeature.types[vtFeature.type];
+  let i: number;
+  let j: number;
+
+  let coordinates: number[][] | number[][][] | number[][][][];
+  switch (vtFeature.type) {
+    case 1:
+      const points: number[][] = [];
+      for (i = 0; i < coords.length; i++) {
+        points[i] = coords[i][0];
+      }
+      coordinates = points;
+      transform(coordinates, vtFeature.extent);
+      break;
+
+    case 2:
+      coordinates = coords;
+      for (i = 0; i < coordinates.length; i++) {
+        transform(coordinates[i], vtFeature.extent);
+      }
+      break;
+
+    case 3:
+      coordinates = classifyRings(coords);
+      for (i = 0; i < coordinates.length; i++) {
+        for (j = 0; j < coordinates[i].length; j++) {
+          transform(coordinates[i][j], vtFeature.extent);
+        }
+      }
+      break;
+
+    default:
+      throw new Error('illegal vector tile type');
+  }
+
+  if (coordinates.length === 1) {
+    // @ts-expect-error
+    coordinates = coordinates[0];
+  } else {
+    type = `Multi${type}`;
+  }
+
+  const result: Feature = {
+    type: 'Feature',
+    geometry: {
+      type: type as any,
+      coordinates: coordinates as any
+    },
+    properties: vtFeature.properties
+  };
+
+  if (vtFeature.id !== null) {
+    result.id = vtFeature.id;
+  }
+
+  return result;
+}
+
+// PBF READER UTILS
+
+/**
+ *
+ * @param tag
+ * @param feature
+ * @param pbf
+ */
+function readFeature(tag: number, feature?: VectorTileFeature, pbf?: Protobuf): void {
+  if (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;
+  }
+}
+
+/**
+ *
+ * @param pbf
+ * @param feature
+ */
+function readTag(pbf: Protobuf, feature: VectorTileFeature): void {
+  const end = pbf.readVarint() + pbf.pos;
+
+  while (pbf.pos < end) {
+    const key = feature._keys[pbf.readVarint()];
+    const value = feature._values[pbf.readVarint()];
+    if (key === '__proto__') {
+      Object.defineProperty(feature.properties, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      feature.properties[key] = value;
+    }
+  }
+}