@loaders.gl/gis 4.3.4 → 4.4.0-alpha.10

package/src/lib/geometry-converters/convert-binary-geometry-to-geojson.ts

@@ -0,0 +1,148 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  BinaryGeometry,
+  BinaryPointGeometry,
+  BinaryLineGeometry,
+  BinaryPolygonGeometry,
+  BinaryAttribute,
+  Geometry,
+  Position,
+  Point,
+  MultiPoint,
+  LineString,
+  MultiLineString,
+  Polygon,
+  MultiPolygon
+} from '@loaders.gl/schema';
+
+/** Parse input binary data and return a valid GeoJSON geometry object */
+export function convertBinaryGeometryToGeometry(
+  data: BinaryGeometry,
+  startIndex?: number,
+  endIndex?: number
+): Geometry {
+  switch (data.type) {
+    case 'Point':
+      return pointToGeoJson(data, startIndex, endIndex);
+    case 'LineString':
+      return lineStringToGeoJson(data, startIndex, endIndex);
+    case 'Polygon':
+      return polygonToGeoJson(data, startIndex, endIndex);
+    default:
+      const unexpectedInput: never = data;
+      throw new Error(`Unsupported geometry type: ${(unexpectedInput as any)?.type}`);
+  }
+}
+
+/** Parse binary data of type Polygon */
+function polygonToGeoJson(
+  data: BinaryPolygonGeometry,
+  startIndex: number = -Infinity,
+  endIndex: number = Infinity
+): Polygon | MultiPolygon {
+  const {positions} = data;
+  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+    (x) => x >= startIndex && x <= endIndex
+  );
+  const multi = polygonIndices.length > 2;
+
+  // Polygon
+  if (!multi) {
+    const coordinates: Position[][] = [];
+    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+      const startRingIndex = primitivePolygonIndices[i];
+      const endRingIndex = primitivePolygonIndices[i + 1];
+      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+      coordinates.push(ringCoordinates);
+    }
+
+    return {type: 'Polygon', coordinates};
+  }
+
+  // MultiPolygon
+  const coordinates: Position[][][] = [];
+  for (let i = 0; i < polygonIndices.length - 1; i++) {
+    const startPolygonIndex = polygonIndices[i];
+    const endPolygonIndex = polygonIndices[i + 1];
+    const polygonCoordinates = polygonToGeoJson(
+      data,
+      startPolygonIndex,
+      endPolygonIndex
+    ).coordinates;
+    coordinates.push(polygonCoordinates as Position[][]);
+  }
+
+  return {type: 'MultiPolygon', coordinates};
+}
+
+/** Parse binary data of type LineString */
+function lineStringToGeoJson(
+  data: BinaryLineGeometry,
+  startIndex: number = -Infinity,
+  endIndex: number = Infinity
+): LineString | MultiLineString {
+  const {positions} = data;
+  const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+  const multi = pathIndices.length > 2;
+
+  if (!multi) {
+    const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+    return {type: 'LineString', coordinates};
+  }
+
+  const coordinates: Position[][] = [];
+  for (let i = 0; i < pathIndices.length - 1; i++) {
+    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+    coordinates.push(ringCoordinates);
+  }
+
+  return {type: 'MultiLineString', coordinates};
+}
+
+/** Parse binary data of type Point */
+function pointToGeoJson(
+  data: BinaryPointGeometry,
+  startIndex?: number,
+  endIndex?: number
+): Point | MultiPoint {
+  const {positions} = data;
+  const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+  const multi = coordinates.length > 1;
+
+  if (multi) {
+    return {type: 'MultiPoint', coordinates};
+  }
+
+  return {type: 'Point', coordinates: coordinates[0]};
+}
+
+/**
+ * Parse a linear ring of positions to a GeoJSON linear ring
+ *
+ * @param positions Positions TypedArray
+ * @param startIndex Start index to include in ring
+ * @param endIndex End index to include in ring
+ * @returns GeoJSON ring
+ */
+function ringToGeoJson(
+  positions: BinaryAttribute,
+  startIndex?: number,
+  endIndex?: number
+): Position[] {
+  startIndex = startIndex || 0;
+  endIndex = endIndex || positions.value.length / positions.size;
+
+  const ringCoordinates: Position[] = [];
+  for (let j = startIndex; j < endIndex; j++) {
+    const coord = Array<number>();
+    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+      coord.push(Number(positions.value[k]));
+    }
+    ringCoordinates.push(coord);
+  }
+  return ringCoordinates;
+}

package/src/lib/geometry-converters/convert-geoarrow-to-geojson.ts

@@ -0,0 +1,193 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// import * as arrow from 'apache-arrow';
+import type {
+  MultiPolygon,
+  Position,
+  Polygon,
+  MultiPoint,
+  Point,
+  MultiLineString,
+  LineString,
+  Geometry
+} from '@loaders.gl/schema';
+import type {GeoArrowEncoding} from '@loaders.gl/geoarrow';
+import {convertWKBToGeometry} from './wkb/convert-wkb-to-geometry';
+import {convertWKTToGeometry} from './wkb/convert-wkt-to-geometry';
+
+/**
+ * parse geometry from arrow data that is returned from processArrowData()
+ * NOTE: this function could be deduplicated with the binaryToGeometry() in deck.gl,
+ * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
+ *
+ * @param data data extraced from arrow vector representing a geometry
+ * @param encoding the geoarrow encoding of the geometry column
+ * @returns Feature or null
+ */
+export function convertGeoArrowGeometryToGeoJSON(
+  arrowCellValue: any,
+  encoding?: GeoArrowEncoding
+): Geometry | null {
+  // sanity
+  encoding = encoding?.toLowerCase() as GeoArrowEncoding;
+  if (!encoding || !arrowCellValue) {
+    return null;
+  }
+
+  switch (encoding) {
+    case 'geoarrow.multipolygon':
+      return arrowMultiPolygonToGeometry(arrowCellValue);
+    case 'geoarrow.polygon':
+      return arrowPolygonToGeometry(arrowCellValue);
+    case 'geoarrow.multipoint':
+      return arrowMultiPointToGeometry(arrowCellValue);
+    case 'geoarrow.point':
+      return arrowPointToGeometry(arrowCellValue);
+    case 'geoarrow.multilinestring':
+      return arrowMultiLineStringToGeometry(arrowCellValue);
+    case 'geoarrow.linestring':
+      return arrowLineStringToGeometry(arrowCellValue);
+    case 'geoarrow.wkb':
+      return arrowWKBToGeometry(arrowCellValue);
+    case 'geoarrow.wkt':
+      return arrowWKTToGeometry(arrowCellValue);
+    default: {
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
+    }
+  }
+}
+
+function arrowWKBToGeometry(arrowCellValue: any): Geometry | null {
+  // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength
+  const arrayBuffer: ArrayBuffer = arrowCellValue.buffer.slice(
+    arrowCellValue.byteOffset,
+    arrowCellValue.byteOffset + arrowCellValue.byteLength
+  );
+  return convertWKBToGeometry(arrayBuffer);
+}
+
+function arrowWKTToGeometry(arrowCellValue: any): Geometry | null {
+  const string: string = arrowCellValue;
+  return convertWKTToGeometry(string);
+}
+
+/**
+ * convert Arrow MultiPolygon to geojson Feature
+ */
+function arrowMultiPolygonToGeometry(arrowMultiPolygon: any): MultiPolygon {
+  const multiPolygon: Position[][][] = [];
+  for (let m = 0; m < arrowMultiPolygon.length; m++) {
+    const arrowPolygon = arrowMultiPolygon.get(m);
+    const polygon: Position[][] = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+      const arrowRing = arrowPolygon?.get(i);
+      const ring: Position[] = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coord: Position = Array.from(arrowCoord);
+        ring.push(coord);
+      }
+      polygon.push(ring);
+    }
+    multiPolygon.push(polygon);
+  }
+  const geometry: MultiPolygon = {
+    type: 'MultiPolygon',
+    coordinates: multiPolygon
+  };
+  return geometry;
+}
+
+/**
+ * convert Arrow Polygon to geojson Feature
+ */
+function arrowPolygonToGeometry(arrowPolygon: any): Polygon {
+  const polygon: Position[][] = [];
+  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+    const arrowRing = arrowPolygon.get(i);
+    const ring: Position[] = [];
+    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+      const arrowCoord = arrowRing.get(j);
+      const coords: Position = Array.from(arrowCoord);
+      ring.push(coords);
+    }
+    polygon.push(ring);
+  }
+  const geometry: Polygon = {
+    type: 'Polygon',
+    coordinates: polygon
+  };
+  return geometry;
+}
+
+/**
+ * convert Arrow MultiPoint to geojson MultiPoint
+ */
+function arrowMultiPointToGeometry(arrowMultiPoint: any): MultiPoint {
+  const multiPoint: Position[] = [];
+  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+    const arrowPoint = arrowMultiPoint.get(i);
+    if (arrowPoint) {
+      const coord: Position = Array.from(arrowPoint);
+      multiPoint.push(coord);
+    }
+  }
+  return {
+    type: 'MultiPoint',
+    coordinates: multiPoint
+  };
+}
+
+/**
+ * convert Arrow Point to geojson Point
+ */
+function arrowPointToGeometry(arrowPoint: any): Point {
+  const point: Position = Array.from(arrowPoint);
+  return {
+    type: 'Point',
+    coordinates: point
+  };
+}
+
+/**
+ * convert Arrow MultiLineString to geojson MultiLineString
+ */
+function arrowMultiLineStringToGeometry(arrowMultiLineString: any): MultiLineString {
+  const multiLineString: Position[][] = [];
+  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+    const arrowLineString = arrowMultiLineString.get(i);
+    const lineString: Position[] = [];
+    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+      const arrowCoord = arrowLineString.get(j);
+      if (arrowCoord) {
+        const coords: Position = Array.from(arrowCoord);
+        lineString.push(coords);
+      }
+    }
+    multiLineString.push(lineString);
+  }
+  return {
+    type: 'MultiLineString',
+    coordinates: multiLineString
+  };
+}
+
+/**
+ * convert Arrow LineString to geojson LineString
+ */
+function arrowLineStringToGeometry(arrowLineString: any): LineString {
+  const lineString: Position[] = [];
+  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+    const arrowCoord = arrowLineString.get(i);
+    if (arrowCoord) {
+      const coords: Position = Array.from(arrowCoord);
+      lineString.push(coords);
+    }
+  }
+  return {
+    type: 'LineString',
+    coordinates: lineString
+  };
+}

package/src/lib/geometry-converters/convert-to-geojson.ts

@@ -0,0 +1,52 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Geometry, BinaryGeometry} from '@loaders.gl/schema';
+
+import {convertGeometryToWKB} from './wkb/convert-geometry-to-wkb';
+import {convertGeometryToWKT} from './wkb/convert-geometry-to-wkt';
+import {convertWKBToBinaryGeometry} from './wkb/convert-wkb-to-binary-geometry';
+import {convertWKTToGeometry} from './wkb/convert-wkt-to-geometry';
+
+import {convertBinaryGeometryToGeometry} from './convert-binary-geometry-to-geojson';
+
+export function convertToGeoJSON(geometry: ArrayBuffer | string): Geometry {
+  if (geometry instanceof ArrayBuffer) {
+    const binaryGeometry = convertWKBToBinaryGeometry(geometry);
+    return convertBinaryGeometryToGeometry(binaryGeometry);
+  }
+
+  // Assume string encoded WKT
+  if (typeof geometry === 'string') {
+    return convertWKTToGeometry(geometry)!;
+  }
+
+  throw new Error('Geo conversion not implemented');
+}
+
+export function convertToBinaryGeometry(geometry: ArrayBuffer | string | Geometry): BinaryGeometry {
+  if (geometry instanceof ArrayBuffer) {
+    return convertWKBToBinaryGeometry(geometry);
+  }
+
+  // Assume string encoded WKT
+  if (typeof geometry === 'string') {
+    // const geometry = convertWKTToGeometry(geometry);
+    // return convertGeometryToBinaryGeometry(geometry);
+  }
+
+  throw new Error('Geo conversion not implemented');
+}
+
+export function convertToWKT(geometry: Geometry): string {
+  return convertGeometryToWKT(geometry);
+}
+
+export function convertToWKB(geometry: Geometry): ArrayBuffer {
+  return convertGeometryToWKB(geometry);
+}
+
+// export function convertToTWKB(geometry: Geometry): ArrayBuffer {
+//   return convertGeometryToTWKB(geometry);
+// }

package/src/lib/geometry-converters/wkb/convert-geometry-to-twkb.ts

@@ -0,0 +1,308 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
+
+import type {
+  Point,
+  MultiPoint,
+  LineString,
+  MultiLineString,
+  Polygon,
+  MultiPolygon,
+  GeometryCollection,
+  Geometry
+} from '@loaders.gl/schema';
+
+import {BinaryWriter} from '../../utils/binary-writer';
+import {WKBGeometryType} from './helpers/wkb-types';
+
+type TWKBPrecision = {
+  xy: number;
+  z: number;
+  m: number;
+  xyFactor: number;
+  zFactor: number;
+  mFactor: number;
+};
+
+type TWKBEncoderContext = TWKBPrecision & {
+  hasZ?: boolean;
+  hasM?: boolean;
+};
+
+export function convertGeometryToTWKB(
+  geometry: Geometry,
+  options?: {hasZ?: boolean; hasM?: boolean}
+): ArrayBuffer {
+  const writer = new BinaryWriter(0, true);
+
+  const context: TWKBEncoderContext = {
+    ...getTwkbPrecision(5, 0, 0),
+    hasZ: options?.hasZ,
+    hasM: options?.hasM
+  };
+
+  encodeGeometry(writer, geometry, context);
+
+  // TODO - we need to slice it?
+  return writer.arrayBuffer;
+}
+
+function encodeGeometry(writer: BinaryWriter, geometry: Geometry, context: TWKBEncoderContext) {
+  switch (geometry.type) {
+    case 'Point':
+      return encodePoint(writer, context, geometry);
+    case 'LineString':
+      return encodeLineString(writer, context, geometry);
+    case 'Polygon':
+      return encodePolygon(writer, context, geometry);
+    case 'MultiPoint':
+      return encodeMultiPoint(writer, context, geometry);
+    case 'MultiLineString':
+      return encodeMultiLineString(writer, context, geometry);
+    case 'MultiPolygon':
+      return encodeMultiPolygon(writer, context, geometry);
+    case 'GeometryCollection':
+      return encodeGeometryCollection(writer, context, geometry);
+    default:
+      throw new Error('unsupported geometry type');
+  }
+}
+
+function encodePoint(writer: BinaryWriter, context: TWKBEncoderContext, point: Point): void {
+  const isEmpty =
+    point.coordinates.length === 0 || point[0] === 'undefined' || point[1] === 'undefined';
+
+  writeTwkbHeader(writer, context, WKBGeometryType.Point, isEmpty);
+
+  if (!isEmpty) {
+    const previousPoint = [0, 0, 0, 0];
+    writeTwkbPoint(writer, context, point.coordinates, previousPoint);
+  }
+}
+
+function encodeLineString(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  lineString: LineString
+): ArrayBuffer {
+  const points = lineString.coordinates;
+  const isEmpty = points.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.LineString, isEmpty);
+
+  if (!isEmpty) {
+    writer.writeVarInt(points.length);
+    const previousPoint = [0, 0, 0, 0];
+    for (const point of points) {
+      writeTwkbPoint(writer, context, point, previousPoint);
+    }
+  }
+
+  return writer.arrayBuffer;
+}
+
+function encodePolygon(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  polygon: Polygon
+): ArrayBuffer {
+  const polygonRings = polygon.coordinates;
+
+  const isEmpty = polygonRings.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.Polygon, isEmpty);
+
+  if (!isEmpty) {
+    writer.writeVarInt(polygonRings.length);
+
+    const previousPoint = [0, 0, 0, 0];
+    for (const ring of polygonRings) {
+      writer.writeVarInt(ring.length);
+      for (const point of ring) {
+        writeTwkbPoint(writer, context, previousPoint, point);
+      }
+    }
+  }
+
+  return writer.arrayBuffer;
+}
+
+function encodeMultiPoint(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  multiPoint: MultiPoint
+): void {
+  const points = multiPoint.coordinates;
+  const isEmpty = points.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiPoint, isEmpty);
+
+  if (!isEmpty) {
+    writer.writeVarInt(points.length);
+
+    const previousPoint = [0, 0, 0, 0];
+    for (let i = 0; i < points.length; i++) {
+      writeTwkbPoint(writer, context, previousPoint, points[i]);
+    }
+  }
+}
+
+function encodeMultiLineString(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  multiLineStrings: MultiLineString
+): ArrayBuffer {
+  const lineStrings = multiLineStrings.coordinates;
+  const isEmpty = lineStrings.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiLineString, isEmpty);
+
+  if (!isEmpty) {
+    writer.writeVarInt(lineStrings.length);
+
+    const previousPoint = [0, 0, 0, 0];
+    for (const lineString of lineStrings) {
+      writer.writeVarInt(lineString.length);
+
+      for (const point of lineString) {
+        writeTwkbPoint(writer, context, previousPoint, point);
+      }
+    }
+  }
+
+  return writer.arrayBuffer;
+}
+
+function encodeMultiPolygon(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  multiPolygon: MultiPolygon
+): void {
+  const {coordinates} = multiPolygon;
+  const isEmpty = coordinates.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.MultiPolygon, isEmpty);
+
+  if (!isEmpty) {
+    const polygons = coordinates;
+    writer.writeVarInt(polygons.length);
+
+    const previousPoint = [0, 0, 0, 0];
+
+    for (const polygonRings of polygons) {
+      writer.writeVarInt(polygonRings.length);
+      for (const ring of polygonRings) {
+        writer.writeVarInt(ring.length);
+        for (const point of ring) {
+          writeTwkbPoint(writer, context, previousPoint, point);
+        }
+      }
+    }
+  }
+}
+
+function encodeGeometryCollection(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  geometryCollection: GeometryCollection
+): void {
+  const {geometries} = geometryCollection;
+  const isEmpty = geometries.length === 0;
+
+  writeTwkbHeader(writer, context, WKBGeometryType.GeometryCollection, isEmpty);
+
+  if (geometries.length > 0) {
+    writer.writeVarInt(geometries.length);
+    for (const geometry of geometries) {
+      encodeGeometry(writer, geometry, context);
+    }
+  }
+}
+
+/**
+ *
+ * @param writer
+ * @param context
+ * @param geometryType
+ * @param isEmpty
+ */
+function writeTwkbHeader(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  geometryType: WKBGeometryType,
+  isEmpty: boolean
+) {
+  const type = (zigZagEncode(context.xy) << 4) + geometryType;
+  let metadataHeader = context.hasZ || context.hasM ? 1 << 3 : 0;
+  metadataHeader += isEmpty ? 1 << 4 : 0;
+
+  writer.writeUInt8(type);
+  writer.writeUInt8(metadataHeader);
+
+  if (context.hasZ || context.hasM) {
+    let extendedPrecision = 0;
+    if (context.hasZ) {
+      extendedPrecision |= 0x1;
+    }
+    if (context.hasM) {
+      extendedPrecision |= 0x2;
+    }
+    writer.writeUInt8(extendedPrecision);
+  }
+}
+
+/**
+ * Write one point to array buffer. ZigZagEncoding the delta fdrom the previous point. Mutates previousPoint.
+ * @param writer
+ * @param context
+ * @param previousPoint - Mutated by this function
+ * @param point
+ */
+function writeTwkbPoint(
+  writer: BinaryWriter,
+  context: TWKBEncoderContext,
+  point: number[],
+  previousPoint: number[]
+): void {
+  const x = point[0] * context.xyFactor;
+  const y = point[1] * context.xyFactor;
+  const z = point[2] * context.zFactor;
+  const m = point[3] * context.mFactor;
+
+  writer.writeVarInt(zigZagEncode(x - previousPoint[0]));
+  writer.writeVarInt(zigZagEncode(y - previousPoint[1]));
+  if (context.hasZ) {
+    writer.writeVarInt(zigZagEncode(z - previousPoint[2]));
+  }
+  if (context.hasM) {
+    writer.writeVarInt(zigZagEncode(m - previousPoint[3]));
+  }
+
+  previousPoint[0] = x;
+  previousPoint[1] = y;
+  previousPoint[2] = z;
+  previousPoint[3] = m;
+}
+
+// HELPERS
+
+function zigZagEncode(value: number): number {
+  return (value << 1) ^ (value >> 31);
+}
+
+function getTwkbPrecision(
+  xyPrecision: number,
+  zPrecision: number,
+  mPrecision: number
+): TWKBPrecision {
+  return {
+    xy: xyPrecision,
+    z: zPrecision,
+    m: mPrecision,
+    xyFactor: Math.pow(10, xyPrecision),
+    zFactor: Math.pow(10, zPrecision),
+    mFactor: Math.pow(10, mPrecision)
+  };
+}