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

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

@@ -0,0 +1,130 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
+
+/* eslint-disable indent */
+// This code is forked from https://github.com/mapbox/vector-tile-js under BSD 3-clause license.
+
+import Protobuf from 'pbf';
+import {VectorTileFeature} from './vector-tile-feature';
+import type {GeojsonGeometryInfo} from '@loaders.gl/arrow-geometry/legacy-binary';
+
+export class VectorTileLayer {
+  version: number;
+  name: string;
+  extent: number;
+  length: number;
+  _pbf: Protobuf;
+  _keys: string[];
+  _values: (string | number | boolean | null)[];
+  _features: number[];
+
+  constructor(pbf: Protobuf, end: number) {
+    // Public
+    this.version = 1;
+    this.name = '';
+    this.extent = 4096;
+    this.length = 0;
+
+    // Private
+    this._pbf = pbf;
+    this._keys = [];
+    this._values = [];
+    this._features = [];
+
+    pbf.readFields(readLayer, this, end);
+
+    this.length = this._features.length;
+  }
+
+  /**
+   * return feature `i` from this layer as a `VectorTileFeature`
+   * @param index
+   * @returns feature
+   */
+  getGeoJSONFeature(i: number): VectorTileFeature {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error('feature index out of bounds');
+    }
+
+    this._pbf.pos = this._features[i];
+
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+  }
+
+  /**
+   * return binary feature `i` from this layer as a `VectorTileFeature`
+   *
+   * @param index
+   * @param geometryInfo
+   * @returns binary feature
+   */
+  getBinaryFeature(i: number, geometryInfo: GeojsonGeometryInfo): VectorTileFeature {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error('feature index out of bounds');
+    }
+
+    this._pbf.pos = this._features[i];
+
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(
+      this._pbf,
+      end,
+      this.extent,
+      this._keys,
+      this._values,
+      geometryInfo
+    );
+  }
+}
+
+/**
+ *
+ * @param tag
+ * @param layer
+ * @param pbf
+ */
+function readLayer(tag: number, layer?: VectorTileLayer, pbf?: Protobuf): void {
+  if (layer && pbf) {
+    if (tag === 15) layer.version = pbf.readVarint();
+    else if (tag === 1) layer.name = pbf.readString();
+    else if (tag === 5) layer.extent = pbf.readVarint();
+    else if (tag === 2) layer._features.push(pbf.pos);
+    else if (tag === 3) layer._keys.push(pbf.readString());
+    else if (tag === 4) layer._values.push(readValueMessage(pbf));
+  }
+}
+
+/**
+ *
+ * @param pbf
+ * @returns value
+ */
+function readValueMessage(pbf: Protobuf) {
+  let value: string | number | boolean | null = null;
+  const end = pbf.readVarint() + pbf.pos;
+
+  while (pbf.pos < end) {
+    const tag = pbf.readVarint() >> 3;
+
+    value =
+      tag === 1
+        ? pbf.readString()
+        : tag === 2
+          ? pbf.readFloat()
+          : tag === 3
+            ? pbf.readDouble()
+            : tag === 4
+              ? pbf.readVarint64()
+              : tag === 5
+                ? pbf.readVarint()
+                : tag === 6
+                  ? pbf.readSVarint()
+                  : tag === 7
+                    ? pbf.readBoolean()
+                    : null;
+  }
+
+  return value;
+}

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

@@ -0,0 +1,32 @@
+// 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 {VectorTileLayer} from './vector-tile-layer';
+import Protobuf from 'pbf';
+
+export class VectorTile {
+  layers: {[x: string]: VectorTileLayer};
+  constructor(pbf: Protobuf, end?: number) {
+    this.layers = pbf.readFields(readTile, Object.create(null), end);
+  }
+}
+
+/**
+ *
+ * @param tag
+ * @param layers
+ * @param pbf
+ */
+function readTile(tag: number, layers?: {[x: string]: VectorTileLayer}, pbf?: Protobuf): void {
+  if (tag === 3) {
+    if (pbf) {
+      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+      if (layer.length && layers) {
+        layers[layer.name] = layer;
+      }
+    }
+  }
+}

package/src/mvt/lib/vector-tiler/LICENSE

@@ -0,0 +1,19 @@
+This directory is forked from Mapbox's https://github.com/mapbox/geojson-vt under ISC License.
+
+```
+ISC License
+
+Copyright (c) 2015, Mapbox
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
+```

package/src/mvt/lib/vector-tiler/arrow-tile.ts

@@ -0,0 +1,93 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as arrow from 'apache-arrow';
+import type {ArrowTable} from '@loaders.gl/core/schema';
+import {makeWKBGeometryDataFromWriters} from '@loaders.gl/arrow-geometry/wkb-arrow-utils';
+import {type WKBBuilder} from '@loaders.gl/arrow-geometry';
+import {convertArrowToSchema} from '@loaders.gl/core/schema-utils';
+import type {ProtoTile} from './proto-tile';
+import type {ProtoFeature} from './features/proto-feature';
+import {classifyRings} from '../utils/geometry-utils';
+
+/** Gathers source attribute columns and writes clipped geometry directly into Arrow WKB buffers. */
+export function createArrowTile(
+  table: arrow.Table,
+  schema: arrow.Schema,
+  geometryColumn: string,
+  tile: ProtoTile,
+  extent: number,
+  localCoordinates: boolean
+): ArrowTable {
+  const rowIndices = tile.protoFeatures.map(feature => Number(feature.tags!.sourceRowIndex));
+  const geometryData = makeWKBGeometryDataFromWriters(
+    tile.protoFeatures.map(feature => builder => writeTileGeometry(builder, feature)),
+    {
+      transform: coordinate => {
+        if (localCoordinates) return [coordinate[0] / extent, coordinate[1] / extent];
+        const size = extent * 2 ** tile.z;
+        const latitude = 180 - ((coordinate[1] + extent * tile.y) * 360) / size;
+        return [
+          ((coordinate[0] + extent * tile.x) * 360) / size - 180,
+          (360 / Math.PI) * Math.atan(Math.exp((latitude * Math.PI) / 180)) - 90
+        ];
+      }
+    }
+  );
+  const columns: Record<string, arrow.Vector> = Object.create(null);
+  for (const field of schema.fields) {
+    const column = table.getChild(field.name)!;
+    columns[field.name] =
+      field.name === geometryColumn
+        ? arrow.makeVector(geometryData)
+        : gatherColumnRows(column, rowIndices);
+  }
+  const data = new arrow.Table(schema, columns);
+  return {shape: 'arrow-table', schema: convertArrowToSchema(data.schema), data};
+}
+
+/** Gathers contiguous row runs as Arrow views, preserving nested values and dictionary buffers. */
+function gatherColumnRows(column: arrow.Vector, rowIndices: number[]): arrow.Vector {
+  const chunks: arrow.Data[] = [];
+  for (let index = 0; index < rowIndices.length; ) {
+    const start = rowIndices[index];
+    let end = start + 1;
+    index++;
+    while (index < rowIndices.length && rowIndices[index] === end) {
+      end++;
+      index++;
+    }
+    chunks.push(...column.slice(start, end).data);
+  }
+  return new arrow.Vector(chunks);
+}
+
+/** Writes a transformed proto-feature without mutating the cached tile coordinates. */
+function writeTileGeometry(builder: WKBBuilder, feature: ProtoFeature): void {
+  if (feature.simplifiedType === 1) {
+    const points = feature.geometry as number[][];
+    if (points.length !== 1) builder.beginMultiPoint(points.length);
+    for (const point of points) {
+      builder.beginPoint();
+      builder.writeCoordinate(point[0], point[1]);
+    }
+  } else if (feature.simplifiedType === 2) {
+    const lines = feature.geometry as number[][][];
+    if (lines.length !== 1) builder.beginMultiLineString(lines.length);
+    for (const line of lines) {
+      builder.beginLineString(line.length);
+      for (const point of line) builder.writeCoordinate(point[0], point[1]);
+    }
+  } else {
+    const polygons = classifyRings(feature.geometry as number[][][]);
+    if (polygons.length !== 1) builder.beginMultiPolygon(polygons.length);
+    for (const polygon of polygons) {
+      builder.beginPolygon(polygon.length);
+      for (const ring of polygon) {
+        builder.beginLinearRing(ring.length);
+        for (const point of ring) builder.writeCoordinate(point[0], point[1]);
+      }
+    }
+  }
+}

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

@@ -0,0 +1,250 @@
+// 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';
+
+/* 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 clipFeatures(
+  features: ProtoFeature[],
+  scale: number,
+  k1: number,
+  k2: number,
+  axis,
+  minAll: number,
+  maxAll: number,
+  options: {lineMetrics: boolean}
+): ProtoFeature[] | 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: ProtoFeature[] = [];
+
+  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(createProtoFeature(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(createProtoFeature(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;
+}