@loaders.gl/mvt 4.2.1 → 4.3.0-alpha.2

package/src/lib/parse-mvt.ts

@@ -2,23 +2,17 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
+import type {FlatFeature, Feature, GeojsonGeometryInfo} from '@loaders.gl/schema';
+import type {GeoJSONTable, BinaryFeatureCollection} from '@loaders.gl/schema';
 import {flatGeojsonToBinary} from '@loaders.gl/gis';
-import type {
-  FlatFeature,
-  Feature,
-  GeojsonGeometryInfo,
-  BinaryFeatureCollection,
-  GeoJSONTable
-} from '@loaders.gl/schema';
+import {log} from '@loaders.gl/loader-utils';
 import Protobuf from 'pbf';
 
-import type {MVTMapboxCoordinates, MVTOptions} from '../lib/types';
-import type {MVTLoaderOptions} from '../mvt-loader';
+import {VectorTile} from './vector-tile/vector-tile';
+import {VectorTileFeature} from './vector-tile/vector-tile-feature';
 
-import {VectorTile} from './mapbox-vector-tile/vector-tile';
-import {BinaryVectorTile} from './binary-vector-tile/vector-tile';
-import {BinaryVectorTileFeature} from './binary-vector-tile/vector-tile-feature';
-import {VectorTileFeature as VectorTileFeatureMapBox} from './mapbox-vector-tile/vector-tile-feature';
+import type {MVTLoaderOptions} from '../mvt-loader';
+type MVTOptions = Required<MVTLoaderOptions>['mvt'];
 
 /**
  * Parse MVT arrayBuffer and return GeoJSON.
@@ -28,7 +22,7 @@ import {VectorTileFeature as VectorTileFeatureMapBox} from './mapbox-vector-tile
  * @returns A GeoJSON geometry object or a binary representation
  */
 export function parseMVT(arrayBuffer: ArrayBuffer, options?: MVTLoaderOptions) {
-  const mvtOptions = normalizeOptions(options);
+  const mvtOptions = checkOptions(options);
 
   const shape: string | undefined =
     options?.gis?.format || options?.mvt?.shape || (options?.shape as string);
@@ -87,7 +81,7 @@ function parseToFlatGeoJson(
     return [features, geometryInfo];
   }
 
-  const tile = new BinaryVectorTile(new Protobuf(arrayBuffer));
+  const tile = new VectorTile(new Protobuf(arrayBuffer));
 
   const selectedLayers =
     options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -99,7 +93,7 @@ function parseToFlatGeoJson(
     }
 
     for (let i = 0; i < vectorTileLayer.length; i++) {
-      const vectorTileFeature = vectorTileLayer.feature(i, geometryInfo);
+      const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
       const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
@@ -113,7 +107,7 @@ function parseToGeojsonFeatures(arrayBuffer: ArrayBuffer, options: MVTOptions):
     return [];
   }
 
-  const features: MVTMapboxCoordinates[] = [];
+  const features: Feature[] = [];
   const tile = new VectorTile(new Protobuf(arrayBuffer));
 
   const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -125,33 +119,29 @@ function parseToGeojsonFeatures(arrayBuffer: ArrayBuffer, options: MVTOptions):
     }
 
     for (let i = 0; i < vectorTileLayer.length; i++) {
-      const vectorTileFeature = vectorTileLayer.feature(i);
+      const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
       const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
   });
 
-  return features as Feature[];
+  return features;
 }
 
-function normalizeOptions(options?: MVTLoaderOptions): MVTOptions {
+/** Check that options are good */
+function checkOptions(options?: MVTLoaderOptions): MVTOptions {
   if (!options?.mvt) {
     throw new Error('mvt options required');
   }
 
-  // Validate
-  const wgs84Coordinates = options.mvt?.coordinates === 'wgs84';
-  const {tileIndex} = options.mvt;
-  const hasTileIndex =
-    tileIndex &&
-    Number.isFinite(tileIndex.x) &&
-    Number.isFinite(tileIndex.y) &&
-    Number.isFinite(tileIndex.z);
-
-  if (wgs84Coordinates && !hasTileIndex) {
+  if (options.mvt?.coordinates === 'wgs84' && !options.mvt.tileIndex) {
     throw new Error('MVT Loader: WGS84 coordinates need tileIndex property');
   }
 
+  if (options.gis) {
+    log.warn('MVTLoader: "options.gis" is deprecated, use "options.mvt.shape" instead')();
+  }
+
   return options.mvt;
 }
 
@@ -161,17 +151,18 @@ function normalizeOptions(options?: MVTLoaderOptions): MVTOptions {
  * @returns decoded feature
  */
 function getDecodedFeature(
-  feature: VectorTileFeatureMapBox,
+  feature: VectorTileFeature,
   options: MVTOptions,
   layerName: string
-): MVTMapboxCoordinates {
-  const decodedFeature = feature.toGeoJSON(
-    // @ts-expect-error What is going on here?
-    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinates
+): Feature {
+  const decodedFeature = feature.toGeoJSONFeature(
+    options.coordinates || 'local',
+    options.tileIndex
   );
 
   // Add layer name to GeoJSON properties
   if (options.layerProperty) {
+    decodedFeature.properties ||= {};
     decodedFeature.properties[options.layerProperty] = layerName;
   }
 
@@ -184,14 +175,11 @@ function getDecodedFeature(
  * @returns decoded binary feature
  */
 function getDecodedFeatureBinary(
-  feature: BinaryVectorTileFeature,
+  feature: VectorTileFeature,
   options: MVTOptions,
   layerName: string
 ): FlatFeature {
-  const decodedFeature = feature.toBinaryCoordinates(
-    // @ts-expect-error
-    options.coordinates === 'wgs84' ? options.tileIndex : transformToLocalCoordinatesBinary
-  );
+  const decodedFeature = feature.toBinaryFeature(options.coordinates || 'local', options.tileIndex);
 
   // Add layer name to GeoJSON properties
   if (options.layerProperty && decodedFeature.properties) {
@@ -200,29 +188,3 @@ function getDecodedFeatureBinary(
 
   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;
-  }
-}

package/src/lib/parse-tilejson.ts

@@ -16,11 +16,6 @@ export type TileJSON = {
   tileFormat?: string;
   tilesetType?: string;
 
-  /** Generating application. Tippecanoe adds this. */
-  generator?: string;
-  /** Generating application options. Tippecanoe adds this. */
-  generatorOptions?: string;
-
   /** Tile indexing scheme */
   scheme?: 'xyz' | 'tms';
   /** Sharded URLs */
@@ -38,6 +33,11 @@ export type TileJSON = {
   // Combination of tilestats (if present) and tilejson layer information
   layers?: TileJSONLayer[];
 
+  /** Generating application. Tippecanoe adds this. */
+  generator?: string;
+  /** Generating application options. Tippecanoe adds this. */
+  generatorOptions?: string;
+
   /** Any nested JSON metadata */
   metaJson?: any | null;
 };

package/src/lib/types.ts

@@ -2,45 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
 
-/** For local coordinates, the tileIndex is not required */
-type MVTLocalCoordinatesOptions = {
-  /**
-   * When set to `local`, the parser will return a flat array of GeoJSON objects with local coordinates decoded from tile origin.
-   */
-  coordinates: 'local';
-  tileIndex: null;
-};
-
-/** In WGS84 coordinates, the tileIndex is required */
-type MVTWgs84CoordinatesOptions = {
-  /**
-   * When set to `wgs84`, the parser will return a flat array of GeoJSON objects with coordinates in longitude, latitude decoded from the provided tile index.
-   */
-  coordinates?: 'wgs84';
-
-  /**
-   * Mandatory with `wgs84` coordinates option. An object containing tile index values (`x`, `y`,
-   * `z`) to reproject features' coordinates into WGS84.
-   */
-  tileIndex?: {x: number; y: number; z: number};
-};
-
-export type MVTOptions = (MVTLocalCoordinatesOptions | MVTWgs84CoordinatesOptions) & {
-  shape?: 'geojson-table' | 'columnar-table' | 'geojson' | 'binary' | 'binary-geometry';
-  /**
-   * When non-`null`, the layer name of each feature is added to
-   * `feature.properties[layerProperty]`. (A `feature.properties` object is created if the feature
-   * has no existing properties). If set to `null`, a layer name property will not be added.
-   */
-  layerProperty?: string | number;
-
-  /**
-   * Optional list of layer names. If not `null`, only features belonging to the named layers will
-   * be included in the output. If `null`, features from all layers are returned.
-   */
-  layers?: string[];
-};
-
+/** TODO where is this used? */
 export type MVTMapboxGeometry = {
   type?: string;
   id?: number;

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

@@ -0,0 +1,234 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+import {getPolygonSignedArea} from '@math.gl/polygon';
+import {FlatIndexedGeometry, FlatPolygon} from '@loaders.gl/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, il = data.length; i < il; ++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][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};
+}