@loaders.gl/mvt 3.2.12 → 3.3.0-alpha.10

package/src/lib/geojson-tiler/clip.ts

@@ -0,0 +1,248 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import type {GeoJSONTileFeature} from './tile';
+import {createFeature} from './feature';
+
+/* eslint-disable no-continue */
+
+/**
+ * Clip features between two vertical or horizontal axis-parallel lines:
+ *     |        |
+ *  ___|___     |     /
+ * /   |   \____|____/
+ *     |        |
+ *
+ * @param k1 and k2 are the line coordinates
+ * @param axis: 0 for x, 1 for y
+ * @param minAll and maxAll: minimum and maximum coordinate value for all features
+ */
+// eslint-disable-next-line max-params, complexity, max-statements
+export function clip(
+  features: GeoJSONTileFeature[],
+  scale: number,
+  k1: number,
+  k2: number,
+  axis,
+  minAll: number,
+  maxAll: number,
+  options: {lineMetrics: boolean}
+): GeoJSONTileFeature[] | null {
+  k1 /= scale;
+  k2 /= scale;
+
+  if (minAll >= k1 && maxAll < k2) {
+    return features;
+  }
+  // trivial accept
+  else if (maxAll < k1 || minAll >= k2) {
+    return null; // trivial reject
+  }
+
+  const clipped: GeoJSONTileFeature[] = [];
+
+  for (const feature of features) {
+    const geometry = feature.geometry;
+    let type = feature.type;
+
+    const min = axis === 0 ? feature.minX : feature.minY;
+    const max = axis === 0 ? feature.maxX : feature.maxY;
+
+    if (min >= k1 && max < k2) {
+      // trivial accept
+      clipped.push(feature);
+      continue;
+    } else if (max < k1 || min >= k2) {
+      // trivial reject
+      continue;
+    }
+
+    let newGeometry: number[][][] | number[][] = [];
+
+    if (type === 'Point' || type === 'MultiPoint') {
+      clipPoints(geometry, newGeometry, k1, k2, axis);
+    } else if (type === 'LineString') {
+      clipLine(geometry, newGeometry, k1, k2, axis, false, options.lineMetrics);
+    } else if (type === 'MultiLineString') {
+      clipLines(geometry, newGeometry, k1, k2, axis, false);
+    } else if (type === 'Polygon') {
+      clipLines(geometry, newGeometry, k1, k2, axis, true);
+    } else if (type === 'MultiPolygon') {
+      for (const polygon of geometry) {
+        const newPolygon = [];
+        clipLines(polygon, newPolygon, k1, k2, axis, true);
+        if (newPolygon.length) {
+          newGeometry.push(newPolygon);
+        }
+      }
+    }
+
+    if (newGeometry.length) {
+      if (options.lineMetrics && type === 'LineString') {
+        for (const line of newGeometry) {
+          clipped.push(createFeature(feature.id, type, line, feature.tags));
+        }
+        continue;
+      }
+
+      if (type === 'LineString' || type === 'MultiLineString') {
+        if (newGeometry.length === 1) {
+          type = 'LineString';
+          // @ts-expect-error TODO - use proper GeoJSON geometry types
+          newGeometry = newGeometry[0];
+        } else {
+          type = 'MultiLineString';
+        }
+      }
+      if (type === 'Point' || type === 'MultiPoint') {
+        type = newGeometry.length === 3 ? 'Point' : 'MultiPoint';
+      }
+
+      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    }
+  }
+
+  return clipped.length ? clipped : null;
+}
+
+function clipPoints(geom, newGeom, k1: number, k2: number, axis): void {
+  for (let i = 0; i < geom.length; i += 3) {
+    const a = geom[i + axis];
+
+    if (a >= k1 && a <= k2) {
+      addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
+    }
+  }
+}
+
+// eslint-disable-next-line max-params, complexity, max-statements
+function clipLine(
+  geom,
+  newGeom,
+  k1: number,
+  k2: number,
+  axis,
+  isPolygon: boolean,
+  trackMetrics: boolean
+): void {
+  let slice = newSlice(geom);
+  const intersect = axis === 0 ? intersectX : intersectY;
+  let len = geom.start;
+  let segLen;
+  let t;
+
+  for (let i = 0; i < geom.length - 3; i += 3) {
+    const ax = geom[i];
+    const ay = geom[i + 1];
+    const az = geom[i + 2];
+    const bx = geom[i + 3];
+    const by = geom[i + 4];
+    const a = axis === 0 ? ax : ay;
+    const b = axis === 0 ? bx : by;
+    let exited = false;
+
+    if (trackMetrics) {
+      segLen = Math.sqrt(Math.pow(ax - bx, 2) + Math.pow(ay - by, 2));
+    }
+
+    if (a < k1) {
+      // ---|-->  | (line enters the clip region from the left)
+      if (b > k1) {
+        t = intersect(slice, ax, ay, bx, by, k1);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else if (a > k2) {
+      // |  <--|--- (line enters the clip region from the right)
+      if (b < k2) {
+        t = intersect(slice, ax, ay, bx, by, k2);
+        if (trackMetrics) {
+          slice.start = len + segLen * t;
+        }
+      }
+    } else {
+      addPoint(slice, ax, ay, az);
+    }
+    if (b < k1 && a >= k1) {
+      // <--|---  | or <--|-----|--- (line exits the clip region on the left)
+      t = intersect(slice, ax, ay, bx, by, k1);
+      exited = true;
+    }
+    if (b > k2 && a <= k2) {
+      // |  ---|--> or ---|-----|--> (line exits the clip region on the right)
+      t = intersect(slice, ax, ay, bx, by, k2);
+      exited = true;
+    }
+
+    if (!isPolygon && exited) {
+      if (trackMetrics) {
+        slice.end = len + segLen * t;
+      }
+      newGeom.push(slice);
+      slice = newSlice(geom);
+    }
+
+    if (trackMetrics) {
+      len += segLen;
+    }
+  }
+
+  // add the last point
+  let last = geom.length - 3;
+  const ax = geom[last];
+  const ay = geom[last + 1];
+  const az = geom[last + 2];
+  const a = axis === 0 ? ax : ay;
+  if (a >= k1 && a <= k2) addPoint(slice, ax, ay, az);
+
+  // close the polygon if its endpoints are not the same after clipping
+  last = slice.length - 3;
+  if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
+    addPoint(slice, slice[0], slice[1], slice[2]);
+  }
+
+  // add the final slice
+  if (slice.length) {
+    newGeom.push(slice);
+  }
+}
+
+class Slice extends Array<number> {
+  size?: number;
+  start?: number;
+  end?: number;
+}
+
+function newSlice(line: {size: number; start: number; end: number}): Slice {
+  const slice: Slice = [];
+  slice.size = line.size;
+  slice.start = line.start;
+  slice.end = line.end;
+  return slice;
+}
+
+// eslint-disable-next-line max-params
+function clipLines(geom, newGeom, k1: number, k2: number, axis, isPolygon: boolean): void {
+  for (const line of geom) {
+    clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
+  }
+}
+
+function addPoint(out: number[], x: number, y: number, z: number): void {
+  out.push(x, y, z);
+}
+
+// eslint-disable-next-line max-params
+function intersectX(out, ax: number, ay: number, bx: number, by: number, x: number): number {
+  const t = (x - ax) / (bx - ax);
+  addPoint(out, x, ay + (by - ay) * t, 1);
+  return t;
+}
+
+// eslint-disable-next-line max-params
+function intersectY(out, ax: number, ay: number, bx: number, by: number, y): number {
+  const t = (y - ay) / (by - ay);
+  addPoint(out, ax + (bx - ax) * t, y, 1);
+  return t;
+}

package/src/lib/geojson-tiler/convert.ts

@@ -0,0 +1,158 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+/* eslint-disable */
+// @ts-nocheck
+
+import type {Feature} from '@loaders.gl/schema';
+import type {GeoJSONTileFeature} from './tile';
+
+import {simplify} from './simplify';
+import {createFeature} from './feature';
+
+// converts GeoJSON feature into an intermediate projected JSON vector format with simplification data
+
+export function convert(data: Feature, options): GeoJSONTileFeature[] {
+  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;
+}
+
+export type ConvertFeatureOptions = {
+  maxZoom?: number;
+  tolerance: number;
+  extent: number;
+  lineMetrics: boolean;
+};
+
+function convertFeature(
+  features: GeoJSONTileFeature[],
+  geojson: Feature,
+  options: ConvertFeatureOptions,
+  index: number
+): void {
+  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;
+  }
+  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));
+      }
+      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.');
+  }
+
+  features.push(createFeature(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;
+  simplify(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/lib/geojson-tiler/feature.ts

@@ -0,0 +1,45 @@
+// loaders.gl, MIT license
+// Forked from https://github.com/mapbox/geojson-vt under compatible ISC license
+
+import {GeoJSONTileFeature} from './tile';
+
+export function createFeature(id, type, geom, tags): GeoJSONTileFeature {
+  const feature: GeoJSONTileFeature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    geometry: geom,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+
+  if (type === 'Point' || type === 'MultiPoint' || type === 'LineString') {
+    calcLineBBox(feature, geom);
+  } else if (type === 'Polygon') {
+    // the outer ring (ie [0]) contains all inner rings
+    calcLineBBox(feature, geom[0]);
+  } else if (type === 'MultiLineString') {
+    for (const line of geom) {
+      calcLineBBox(feature, line);
+    }
+  } else if (type === 'MultiPolygon') {
+    for (const polygon of geom) {
+      // the outer ring (ie [0]) contains all inner rings
+      calcLineBBox(feature, polygon[0]);
+    }
+  }
+
+  return feature;
+}
+
+function calcLineBBox(feature, geom) {
+  for (let i = 0; i < geom.length; i += 3) {
+    feature.minX = Math.min(feature.minX, geom[i]);
+    feature.minY = Math.min(feature.minY, geom[i + 1]);
+    feature.maxX = Math.max(feature.maxX, geom[i]);
+    feature.maxY = Math.max(feature.maxY, geom[i + 1]);
+  }
+}