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

package/src/mvt/lib/vector-tiler/features/convert-feature.ts

@@ -0,0 +1,213 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+/* eslint-disable */
+// @ts-nocheck
+
+import type {Feature, FeatureCollection} from '@loaders.gl/core/schema';
+import type {ProtoFeature} from './proto-feature';
+
+import {createProtoFeature} from './proto-feature';
+import {simplifyPath} from './simplify-path';
+
+export type ConvertFeatureOptions = {
+  /** max zoom to preserve detail on */
+  maxZoom?: number;
+  /** simplification tolerance (higher means simpler) */
+  tolerance?: number;
+  /** tile extent */
+  extent?: number;
+  /** whether to calculate line metrics */
+  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) {
+        const convertedFeatures = convertFeature(feature, options, i++);
+        pushConvertedFeatures(protoFeatures, convertedFeatures);
+      }
+      break;
+    case 'Feature':
+      {
+        const convertedFeatures = convertFeature(data, options);
+        pushConvertedFeatures(protoFeatures, convertedFeatures);
+      }
+      break;
+    default: {
+      // single geometry or a geometry collection
+      const convertedFeatures = convertFeature({geometry: data}, options);
+      pushConvertedFeatures(protoFeatures, convertedFeatures);
+    }
+  }
+
+  return protoFeatures;
+}
+
+function pushConvertedFeatures(protoFeatures, convertedFeatures): void {
+  if (!convertedFeatures) {
+    return;
+  }
+
+  if (Array.isArray(convertedFeatures)) {
+    protoFeatures.push(...convertedFeatures);
+    return;
+  }
+
+  protoFeatures.push(convertedFeatures);
+}
+
+/**
+ * converts a GeoJSON feature into an intermediate projected JSON vector format
+ * with simplification data
+ */
+function convertFeature(
+  geojson: Feature,
+  options: ConvertFeatureOptions,
+  index: number
+): ProtoFeature | ProtoFeature[] | undefined {
+  // GeoJSON geometries can be null, but no vector tile will include them.
+  if (!geojson.geometry) {
+    return;
+  }
+
+  const coords = geojson.geometry.coordinates;
+  const type = geojson.geometry.type;
+  const tolerance = Math.pow(options.tolerance / ((1 << options.maxZoom) * options.extent), 2);
+  let geometry = [];
+  let id = geojson.id;
+  if (options.promoteId) {
+    id = geojson.properties[options.promoteId];
+  } else if (options.generateId) {
+    id = index || 0;
+  }
+
+  switch (type) {
+    case 'Point':
+      convertPoint(coords, geometry);
+      break;
+
+    case 'MultiPoint':
+      for (const p of coords) {
+        convertPoint(p, geometry);
+      }
+      break;
+
+    case 'LineString':
+      convertLine(coords, geometry, tolerance, false);
+      break;
+
+    case 'MultiLineString':
+      if (options.lineMetrics) {
+        // explode into linestrings to be able to track metrics
+        const features = [];
+        for (const line of coords) {
+          geometry = [];
+          convertLine(line, geometry, tolerance, false);
+          features.push(createProtoFeature(id, 'LineString', geometry, geojson.properties));
+        }
+        return features;
+      }
+      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': {
+      const features = [];
+      for (const singleGeometry of geojson.geometry.geometries) {
+        const convertedFeatures = convertFeature(
+          {
+            id,
+            geometry: singleGeometry,
+            properties: geojson.properties
+          },
+          options,
+          index
+        );
+        pushConvertedFeatures(features, convertedFeatures);
+      }
+      return features;
+    }
+
+    default:
+      throw new Error('Input data is not a valid GeoJSON object.');
+  }
+
+  return createProtoFeature(id, type, geometry, geojson.properties);
+}
+
+function convertPoint(coords, out): void {
+  out.push(projectX(coords[0]), projectY(coords[1]), 0);
+}
+
+function convertLine(ring: number[], out, tolerance: number, isPolygon: boolean): void {
+  let x0, y0;
+  let size = 0;
+
+  for (let j = 0; j < ring.length; j++) {
+    const x = projectX(ring[j][0]);
+    const y = projectY(ring[j][1]);
+
+    out.push(x, y, 0);
+
+    if (j > 0) {
+      if (isPolygon) {
+        size += (x0 * y - x * y0) / 2; // area
+      } else {
+        size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2)); // length
+      }
+    }
+    x0 = x;
+    y0 = y;
+  }
+
+  const last = out.length - 3;
+  out[2] = 1;
+  simplifyPath(out, 0, last, tolerance);
+  out[last + 2] = 1;
+
+  out.size = Math.abs(size);
+  out.start = 0;
+  out.end = out.size;
+}
+
+function convertLines(rings: number[][], out, tolerance: number, isPolygon: boolean): void {
+  for (let i = 0; i < rings.length; i++) {
+    const geom = [];
+    convertLine(rings[i], geom, tolerance, isPolygon);
+    out.push(geom);
+  }
+}
+
+function projectX(x: number): number {
+  return x / 360 + 0.5;
+}
+
+function projectY(y: number): number {
+  const sin = Math.sin((y * Math.PI) / 180);
+  const y2 = 0.5 - (0.25 * Math.log((1 + sin) / (1 - sin))) / Math.PI;
+  return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
+}

package/src/mvt/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/mvt/lib/vector-tiler/features/simplify-path.ts

@@ -0,0 +1,84 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+/**
+ * Calculate simplification data using optimized Douglas-Peucker algorithm
+ *
+ * @param coords contiguous list of coordinates
+ * @param first first coord to simplify
+ * @param last last coord to simplify
+ * @param sqTolerance tolerance (square distance)
+ */
+export function simplifyPath(
+  coords: number[],
+  first: number,
+  last: number,
+  sqTolerance: number
+): void {
+  let maxSqDist = sqTolerance;
+  const mid = (last - first) >> 1;
+  let minPosToMid = last - first;
+  let index;
+
+  const ax = coords[first];
+  const ay = coords[first + 1];
+  const bx = coords[last];
+  const by = coords[last + 1];
+
+  for (let i = first + 3; i < last; i += 3) {
+    const d = getSqSegDist(coords[i], coords[i + 1], ax, ay, bx, by);
+
+    if (d > maxSqDist) {
+      index = i;
+      maxSqDist = d;
+    } else if (d === maxSqDist) {
+      // a workaround to ensure we choose a pivot close to the middle of the list,
+      // reducing recursion depth, for certain degenerate inputs
+      // https://github.com/mapbox/geojson-vt/issues/104
+      const posToMid = Math.abs(i - mid);
+      if (posToMid < minPosToMid) {
+        index = i;
+        minPosToMid = posToMid;
+      }
+    }
+  }
+
+  if (maxSqDist > sqTolerance) {
+    if (index - first > 3) simplifyPath(coords, first, index, sqTolerance);
+    coords[index + 2] = maxSqDist;
+    if (last - index > 3) simplifyPath(coords, index, last, sqTolerance);
+  }
+}
+
+/** square distance from a point to a segment */
+// eslint-disable-next-line max-params
+function getSqSegDist(
+  px: number,
+  py: number,
+  x: number,
+  y: number,
+  bx: number,
+  by: number
+): number {
+  let dx = bx - x;
+  let dy = by - y;
+
+  if (dx !== 0 || dy !== 0) {
+    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+
+    if (t > 1) {
+      x = bx;
+      y = by;
+    } else if (t > 0) {
+      x += dx * t;
+      y += dy * t;
+    }
+  }
+
+  dx = px - x;
+  dy = py - y;
+
+  return dx * dx + dy * dy;
+}

package/src/mvt/lib/vector-tiler/features/wrap-features.ts

@@ -0,0 +1,125 @@
+// 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 './proto-feature';
+import {createProtoFeature} from './proto-feature';
+import {clipFeatures} from './clip-features';
+
+/**
+ * Options for wrap()
+ */
+export type WrapFeaturesOptions = {
+  buffer: number /** number of pixels of buffer for the tile */;
+  extent: number /** extent of each tile */;
+  lineMetrics: boolean;
+};
+
+/**
+ * Wrap across antemeridian, by clipping into two tiles, shifting the overflowing x coordinates
+ * @param list of features to be wrapped
+ * @param options buffer and extent
+ * @returns
+ */
+export function wrapFeatures(
+  features: ProtoFeature[],
+  options: WrapFeaturesOptions
+): ProtoFeature[] {
+  const buffer = options.buffer / options.extent;
+  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 = 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
+    }
+    if (right) {
+      merged = merged.concat(shiftFeatureCoords(right, -1)); // merge right into center
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Shift the x coordinates of a list of features
+ * @param features list of features to shift x coordinates for
+ * @param offset
+ * @returns
+ */
+function shiftFeatureCoords(features: ProtoFeature[], offset: number): ProtoFeature[] {
+  const newFeatures: ProtoFeature[] = [];
+
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i];
+    const type = feature.type;
+
+    let newGeometry;
+
+    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));
+        }
+        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(createProtoFeature(feature.id, type, newGeometry, feature.tags));
+  }
+
+  return newFeatures;
+}
+
+class Points extends Array<number> {
+  size?: number;
+  start?: number;
+  end?: number;
+}
+
+/**
+ * Shift the x coordinate of every point
+ * @param points
+ * @param offset
+ * @returns
+ */
+function shiftCoords(points: Points, offset: number): Points {
+  const newPoints: Points = [];
+  newPoints.size = points.size;
+
+  if (points.start !== undefined) {
+    newPoints.start = points.start;
+    newPoints.end = points.end;
+  }
+
+  for (let i = 0; i < points.length; i += 3) {
+    newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
+  }
+  return newPoints;
+}