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

package/src/lib/vector-tiler/{convert.ts → features/convert-feature.ts}

@@ -7,30 +7,10 @@
 // @ts-nocheck
 
 import type {Feature, FeatureCollection} from '@loaders.gl/schema';
-import type {TableTileFeature} from './tile';
+import type {ProtoFeature} from './proto-feature';
 
-import {simplify} from './simplify';
-import {createFeature} from './feature';
-
-/**
- * converts a GeoJSON feature into an intermediate projected JSON vector format
- * with simplification data
- */
-export function convert(data: Feature | FeatureCollection, options): TableTileFeature[] {
-  const features = [];
-  if (data.type === 'FeatureCollection') {
-    for (let i = 0; i < data.features.length; i++) {
-      convertFeature(features, data.features[i], options, i);
-    }
-  } else if (data.type === 'Feature') {
-    convertFeature(features, data, options);
-  } else {
-    // single geometry or a geometry collection
-    convertFeature(features, {geometry: data}, options);
-  }
-
-  return features;
-}
+import {createProtoFeature} from './proto-feature';
+import {simplifyPath} from './simplify-path';
 
 export type ConvertFeatureOptions = {
   /** max zoom to preserve detail on */
@@ -43,16 +23,43 @@ export type ConvertFeatureOptions = {
   lineMetrics?: boolean;
 };
 
+/**
+ * converts a GeoJSON feature into an intermediate projected JSON vector format
+ * with simplification data
+ */
+export function convertFeaturesToProtoFeature(
+  data: Feature | FeatureCollection,
+  options: ConvertFeatureOptions
+): ProtoFeature[] {
+  const protoFeatures = [];
+  switch (data.type) {
+    case 'FeatureCollection':
+      let i = 0;
+      for (const feature of data.features) {
+        protoFeatures.push(convertFeature(feature, options, i++));
+      }
+      break;
+    case 'Feature':
+      protoFeatures.push(convertFeature(data, options));
+      break;
+    default:
+      // single geometry or a geometry collection
+      protoFeatures.push(convertFeature({geometry: data}, options));
+  }
+
+  return protoFeatures;
+}
+
 /**
  * converts a GeoJSON feature into an intermediate projected JSON vector format
  * with simplification data
  */
 function convertFeature(
-  features: TableTileFeature[],
   geojson: Feature,
   options: ConvertFeatureOptions,
   index: number
-): void {
+): ProtoFeature {
+  // GeoJSON geometries can be null, but no vector tile will include them.
   if (!geojson.geometry) {
     return;
   }
@@ -67,53 +74,67 @@ function convertFeature(
   } else if (options.generateId) {
     id = index || 0;
   }
-  if (type === 'Point') {
-    convertPoint(coords, geometry);
-  } else if (type === 'MultiPoint') {
-    for (const p of coords) {
-      convertPoint(p, geometry);
-    }
-  } else if (type === 'LineString') {
-    convertLine(coords, geometry, tolerance, false);
-  } else if (type === 'MultiLineString') {
-    if (options.lineMetrics) {
-      // explode into linestrings to be able to track metrics
-      for (const line of coords) {
-        geometry = [];
-        convertLine(line, geometry, tolerance, false);
-        features.push(createFeature(id, 'LineString', geometry, geojson.properties));
+
+  switch (type) {
+    case 'Point':
+      convertPoint(coords, geometry);
+      break;
+
+    case 'MultiPoint':
+      for (const p of coords) {
+        convertPoint(p, geometry);
       }
-      return;
-    } else {
-      convertLines(coords, geometry, tolerance, false);
-    }
-  } else if (type === 'Polygon') {
-    convertLines(coords, geometry, tolerance, true);
-  } else if (type === 'MultiPolygon') {
-    for (const polygon of coords) {
-      const newPolygon = [];
-      convertLines(polygon, newPolygon, tolerance, true);
-      geometry.push(newPolygon);
-    }
-  } else if (type === 'GeometryCollection') {
-    for (const singleGeometry of geojson.geometry.geometries) {
-      convertFeature(
-        features,
-        {
-          id,
-          geometry: singleGeometry,
-          properties: geojson.properties
-        },
-        options,
-        index
-      );
-    }
-    return;
-  } else {
-    throw new Error('Input data is not a valid GeoJSON object.');
+      break;
+
+    case 'LineString':
+      convertLine(coords, geometry, tolerance, false);
+      break;
+
+    case 'MultiLineString':
+      if (options.lineMetrics) {
+        // explode into linestrings to be able to track metrics
+        for (const line of coords) {
+          geometry = [];
+          convertLine(line, geometry, tolerance, false);
+          features.push(createProtoFeature(id, 'LineString', geometry, geojson.properties));
+        }
+        return;
+        convertLines(coords, geometry, tolerance, false);
+      }
+      break;
+
+    case 'Polygon':
+      convertLines(coords, geometry, tolerance, true);
+      break;
+
+    case 'MultiPolygon':
+      for (const polygon of coords) {
+        const newPolygon = [];
+        convertLines(polygon, newPolygon, tolerance, true);
+        geometry.push(newPolygon);
+      }
+      break;
+
+    case 'GeometryCollection':
+      for (const singleGeometry of geojson.geometry.geometries) {
+        convertFeature(
+          features,
+          {
+            id,
+            geometry: singleGeometry,
+            properties: geojson.properties
+          },
+          options,
+          index
+        );
+      }
+      break;
+
+    default:
+      throw new Error('Input data is not a valid GeoJSON object.');
   }
 
-  features.push(createFeature(id, type, geometry, geojson.properties));
+  return createProtoFeature(id, type, geometry, geojson.properties);
 }
 
 function convertPoint(coords, out): void {
@@ -143,7 +164,7 @@ function convertLine(ring: number[], out, tolerance: number, isPolygon: boolean)
 
   const last = out.length - 3;
   out[2] = 1;
-  simplify(out, 0, last, tolerance);
+  simplifyPath(out, 0, last, tolerance);
   out[last + 2] = 1;
 
   out.size = Math.abs(size);

package/src/lib/vector-tiler/features/proto-feature.ts

@@ -0,0 +1,104 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+export type ProtoFeature = {
+  type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
+  simplifiedType: 1 | 2 | 3;
+  geometry: any[];
+
+  // book keeping
+  id?: string;
+  tags?: Record<string, unknown>;
+
+  /** spatial extents */
+  minX: number;
+  /** spatial extents */
+  maxX: number;
+  /** spatial extents */
+  minY: number;
+  /** spatial extents */
+  maxY: number;
+};
+
+export type GeoJSONTileGeometry =
+  | GeoJSONTilePointGeometry
+  | GeoJSONTileLineGeometry
+  | GeoJSONTilePolygonGeometry;
+
+export type GeoJSONTilePointGeometry = {
+  simplifiedType: 1;
+  geometry: number[];
+};
+
+export type GeoJSONTileLineGeometry = {
+  simplifiedType: 1;
+  geometry: number[][];
+};
+
+export type GeoJSONTilePolygonGeometry = {
+  simplifiedType: 1;
+  geometry: number[][][];
+};
+
+export function createProtoFeature(
+  id: any,
+  type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon',
+  geometry: any[],
+  tags
+): ProtoFeature {
+  const feature: ProtoFeature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    simplifiedType: undefined!, // TODO
+    geometry,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+
+  // TODO break out into separate function
+  switch (type) {
+    case 'Point':
+    case 'MultiPoint':
+    case 'LineString':
+      calcLineBBox(feature, geometry);
+      break;
+
+    case 'MultiLineString':
+      for (const line of geometry) {
+        calcLineBBox(feature, line);
+      }
+      break;
+
+    case 'Polygon':
+      // the outer ring (ie [0]) contains all inner rings
+      calcLineBBox(feature, geometry[0]);
+      break;
+
+    case 'MultiPolygon':
+      for (const polygon of geometry) {
+        // the outer ring (ie [0]) contains all inner rings
+        calcLineBBox(feature, polygon[0]);
+      }
+      break;
+
+    default:
+      throw new Error(String(type));
+  }
+
+  return feature;
+}
+
+function calcLineBBox(feature, geometry) {
+  for (let i = 0; i < geometry.length; i += 3) {
+    feature.minX = Math.min(feature.minX, geometry[i]);
+    feature.minY = Math.min(feature.minY, geometry[i + 1]);
+    feature.maxX = Math.max(feature.maxX, geometry[i]);
+    feature.maxY = Math.max(feature.maxY, geometry[i + 1]);
+  }
+}

package/src/lib/vector-tiler/{simplify.ts → features/simplify-path.ts}

@@ -11,7 +11,12 @@
  * @param last last coord to simplify
  * @param sqTolerance tolerance (square distance)
  */
-export function simplify(coords: number[], first: number, last: number, sqTolerance: number): void {
+export function simplifyPath(
+  coords: number[],
+  first: number,
+  last: number,
+  sqTolerance: number
+): void {
   let maxSqDist = sqTolerance;
   const mid = (last - first) >> 1;
   let minPosToMid = last - first;
@@ -41,9 +46,9 @@ export function simplify(coords: number[], first: number, last: number, sqTolera
   }
 
   if (maxSqDist > sqTolerance) {
-    if (index - first > 3) simplify(coords, first, index, sqTolerance);
+    if (index - first > 3) simplifyPath(coords, first, index, sqTolerance);
     coords[index + 2] = maxSqDist;
-    if (last - index > 3) simplify(coords, index, last, sqTolerance);
+    if (last - index > 3) simplifyPath(coords, index, last, sqTolerance);
   }
 }
 

package/src/lib/vector-tiler/{wrap.ts → features/wrap-features.ts}

@@ -3,14 +3,14 @@
 // Copyright (c) vis.gl contributors
 // Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
 
-import type {TableTileFeature} from './tile';
-import {clip} from './clip';
-import {createFeature} from './feature';
+import type {ProtoFeature} from './proto-feature';
+import {createProtoFeature} from './proto-feature';
+import {clipFeatures} from './clip-features';
 
 /**
  * Options for wrap()
  */
-export type WrapOptions = {
+export type WrapFeaturesOptions = {
   buffer: number /** number of pixels of buffer for the tile */;
   extent: number /** extent of each tile */;
   lineMetrics: boolean;
@@ -18,18 +18,21 @@ export type WrapOptions = {
 
 /**
  * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
- * @param features list of features to be wrapped
+ * @param list of features to be wrapped
  * @param options buffer and extent
  * @returns
  */
-export function wrap(features: TableTileFeature[], options: WrapOptions) {
+export function wrapFeatures(
+  features: ProtoFeature[],
+  options: WrapFeaturesOptions
+): ProtoFeature[] {
   const buffer = options.buffer / options.extent;
-  let merged: TableTileFeature[] = features;
-  const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options); // left world copy
-  const right = clip(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
+  let merged: ProtoFeature[] = features;
+  const left = clipFeatures(features, 1, -1 - buffer, buffer, 0, -1, 2, options); // left world copy
+  const right = clipFeatures(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options); // right world copy
 
   if (left || right) {
-    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
+    merged = clipFeatures(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || []; // center world copy
 
     if (left) {
       merged = shiftFeatureCoords(left, 1).concat(merged); // merge left into center
@@ -48,8 +51,8 @@ export function wrap(features: TableTileFeature[], options: WrapOptions) {
  * @param offset
  * @returns
  */
-function shiftFeatureCoords(features: TableTileFeature[], offset: number): TableTileFeature[] {
-  const newFeatures: TableTileFeature[] = [];
+function shiftFeatureCoords(features: ProtoFeature[], offset: number): ProtoFeature[] {
+  const newFeatures: ProtoFeature[] = [];
 
   for (let i = 0; i < features.length; i++) {
     const feature = features[i];
@@ -57,26 +60,38 @@ function shiftFeatureCoords(features: TableTileFeature[], offset: number): Table
 
     let newGeometry;
 
-    if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
-      newGeometry = shiftCoords(feature.geometry, offset);
-    } else if (type === 'MultiLineString' || type === 'Polygon') {
-      newGeometry = [];
-      for (const line of feature.geometry) {
-        newGeometry.push(shiftCoords(line, offset));
-      }
-    } else if (type === 'MultiPolygon') {
-      newGeometry = [];
-      for (const polygon of feature.geometry) {
-        const newPolygon: Points = [];
-        for (const line of polygon) {
-          // @ts-expect-error TODO
-          newPolygon.push(shiftCoords(line, offset));
+    switch (type) {
+      case 'Point':
+      case 'MultiPoint':
+      case 'LineString':
+        newGeometry = shiftCoords(feature.geometry, offset);
+        break;
+
+      case 'MultiLineString':
+      case 'Polygon':
+        newGeometry = [];
+        for (const line of feature.geometry) {
+          newGeometry.push(shiftCoords(line, offset));
         }
-        newGeometry.push(newPolygon);
-      }
+        break;
+
+      case 'MultiPolygon':
+        newGeometry = [];
+        for (const polygon of feature.geometry) {
+          const newPolygon: Points = [];
+          for (const line of polygon) {
+            // @ts-expect-error TODO
+            newPolygon.push(shiftCoords(line, offset));
+          }
+          newGeometry.push(newPolygon);
+        }
+        break;
+
+      default:
+        throw new Error(String(type));
     }
 
-    newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    newFeatures.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
   }
 
   return newFeatures;

package/src/lib/vector-tiler/proto-tile.ts

@@ -0,0 +1,217 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {ProtoFeature} from './features/proto-feature';
+
+export type ProtoTile = {
+  /** Processed features */
+  protoFeatures: ProtoFeature[];
+  /** if we slice further down, no need to keep source geometry */
+  sourceFeatures: ProtoFeature[] | null;
+
+  /** Properties */
+  tags?: Record<string, string>;
+
+  /** tile x coordinate */
+  x: number;
+  /** tile y coordinate */
+  y: number;
+  /** tile z coordinate */
+  z: number;
+
+  /** spatial extent */
+  minX: number;
+  /** spatial extent */
+  maxX: number;
+  /** spatial extent */
+  minY: number;
+  /** spatial extent */
+  maxY: number;
+
+  /** Whether this tile has been transformed */
+  transformed: boolean;
+  numPoints: number;
+  numSimplified: number;
+  /** Number of features in this tile */
+  numFeatures: number;
+};
+
+export type CreateTileOptions = {
+  maxZoom?: number;
+  tolerance: number;
+  extent: number;
+  lineMetrics: boolean;
+};
+
+/**
+ * Create a tile from features and tile index
+ */
+export function createProtoTile(
+  features: ProtoFeature[],
+  z,
+  tx,
+  ty,
+  options: CreateTileOptions
+): ProtoTile {
+  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+  const tile: ProtoTile = {
+    protoFeatures: [],
+    sourceFeatures: null,
+    numPoints: 0,
+    numSimplified: 0,
+    numFeatures: features.length,
+    x: tx,
+    y: ty,
+    z,
+    transformed: false,
+    minX: 2,
+    minY: 1,
+    maxX: -1,
+    maxY: 0
+  };
+  for (const feature of features) {
+    addProtoFeature(tile, feature, tolerance, options);
+  }
+  return tile;
+}
+
+// eslint-disable-next-line complexity, max-statements
+function addProtoFeature(
+  tile: ProtoTile,
+  feature: ProtoFeature,
+  tolerance: number,
+  options: CreateTileOptions
+) {
+  const geometry = feature.geometry;
+  const type = feature.type;
+  const simplifiedGeometry: number[] = [];
+
+  tile.minX = Math.min(tile.minX, feature.minX);
+  tile.minY = Math.min(tile.minY, feature.minY);
+  tile.maxX = Math.max(tile.maxX, feature.maxX);
+  tile.maxY = Math.max(tile.maxY, feature.maxY);
+
+  let simplifiedType: 1 | 2 | 3;
+  switch (type) {
+    case 'Point':
+    case 'MultiPoint':
+      simplifiedType = 1;
+      for (let i = 0; i < geometry.length; i += 3) {
+        simplifiedGeometry.push(geometry[i], geometry[i + 1]);
+        tile.numPoints++;
+        tile.numSimplified++;
+      }
+      break;
+
+    case 'LineString':
+      simplifiedType = 2;
+      addProtoLine(simplifiedGeometry, geometry, tile, tolerance, false, false);
+      break;
+
+    case 'MultiLineString':
+      simplifiedType = 2;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, false, i === 0);
+      }
+      break;
+
+    case 'Polygon':
+      simplifiedType = 3;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, true, i === 0);
+      }
+      break;
+
+    case 'MultiPolygon':
+      simplifiedType = 3;
+      for (let k = 0; k < geometry.length; k++) {
+        const polygon = geometry[k];
+        for (let i = 0; i < polygon.length; i++) {
+          addProtoLine(simplifiedGeometry, polygon[i], tile, tolerance, true, i === 0);
+        }
+      }
+      break;
+
+    default:
+      throw new Error(`Unknown geometry type: ${type}`);
+  }
+
+  if (simplifiedGeometry.length) {
+    let tags: Record<string, unknown> | null = feature.tags || null;
+
+    if (type === 'LineString' && options.lineMetrics) {
+      tags = {};
+      for (const key in feature.tags) {
+        tags[key] = feature.tags[key];
+      }
+      // @ts-expect-error adding fields to arrays
+      // eslint-disable-next-line camelcase
+      tags.mapbox_clip_start = geometry.start / geometry.size;
+      // @ts-expect-error adding fields to arrays
+      // eslint-disable-next-line camelcase
+      tags.mapbox_clip_end = geometry.end / geometry.size;
+    }
+
+    const tileFeature: ProtoFeature = {
+      geometry: simplifiedGeometry,
+      simplifiedType,
+      // @ts-expect-error
+      tags
+    };
+    if (feature.id !== null) {
+      tileFeature.id = feature.id;
+    }
+
+    tile.protoFeatures.push(tileFeature);
+  }
+}
+
+// eslint-disable-next-line max-params, max-statements
+function addProtoLine(
+  result: any[],
+  geometry: any,
+  tile: ProtoTile,
+  tolerance: number,
+  isPolygon: boolean,
+  isOuter: boolean
+): void {
+  const sqTolerance = tolerance * tolerance;
+
+  if (tolerance > 0 && geometry.size < (isPolygon ? sqTolerance : tolerance)) {
+    tile.numPoints += geometry.length / 3;
+    return;
+  }
+
+  const ring: number[] = [];
+
+  for (let i = 0; i < geometry.length; i += 3) {
+    if (tolerance === 0 || geometry[i + 2] > sqTolerance) {
+      tile.numSimplified++;
+      ring.push(geometry[i], geometry[i + 1]);
+    }
+    tile.numPoints++;
+  }
+
+  if (isPolygon) rewind(ring, isOuter);
+
+  result.push(ring);
+}
+
+function rewind(ring: number[], clockwise?: boolean): void {
+  let area = 0;
+  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+  }
+  if (area > 0 === clockwise) {
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+      const x = ring[i];
+      const y = ring[i + 1];
+      ring[i] = ring[len - 2 - i];
+      ring[i + 1] = ring[len - 1 - i];
+      ring[len - 2 - i] = x;
+      ring[len - 1 - i] = y;
+    }
+  }
+}