@loaders.gl/gis 4.3.1 → 4.4.0-alpha.1

package/dist/lib/geometry-converters/convert-geoarrow-to-geojson.js

@@ -0,0 +1,164 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertWKBToGeometry } from "./wkb/convert-wkb-to-geometry.js";
+import { convertWKTToGeometry } from "./wkb/convert-wkt-to-geometry.js";
+/**
+ * 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, encoding) {
+    // sanity
+    encoding = encoding?.toLowerCase();
+    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) {
+    // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength
+    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
+    return convertWKBToGeometry(arrayBuffer);
+}
+function arrowWKTToGeometry(arrowCellValue) {
+    const string = arrowCellValue;
+    return convertWKTToGeometry(string);
+}
+/**
+ * convert Arrow MultiPolygon to geojson Feature
+ */
+function arrowMultiPolygonToGeometry(arrowMultiPolygon) {
+    const multiPolygon = [];
+    for (let m = 0; m < arrowMultiPolygon.length; m++) {
+        const arrowPolygon = arrowMultiPolygon.get(m);
+        const polygon = [];
+        for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+            const arrowRing = arrowPolygon?.get(i);
+            const ring = [];
+            for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+                const arrowCoord = arrowRing.get(j);
+                const coord = Array.from(arrowCoord);
+                ring.push(coord);
+            }
+            polygon.push(ring);
+        }
+        multiPolygon.push(polygon);
+    }
+    const geometry = {
+        type: 'MultiPolygon',
+        coordinates: multiPolygon
+    };
+    return geometry;
+}
+/**
+ * convert Arrow Polygon to geojson Feature
+ */
+function arrowPolygonToGeometry(arrowPolygon) {
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+        const arrowRing = arrowPolygon.get(i);
+        const ring = [];
+        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+            const arrowCoord = arrowRing.get(j);
+            const coords = Array.from(arrowCoord);
+            ring.push(coords);
+        }
+        polygon.push(ring);
+    }
+    const geometry = {
+        type: 'Polygon',
+        coordinates: polygon
+    };
+    return geometry;
+}
+/**
+ * convert Arrow MultiPoint to geojson MultiPoint
+ */
+function arrowMultiPointToGeometry(arrowMultiPoint) {
+    const multiPoint = [];
+    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+        const arrowPoint = arrowMultiPoint.get(i);
+        if (arrowPoint) {
+            const coord = Array.from(arrowPoint);
+            multiPoint.push(coord);
+        }
+    }
+    return {
+        type: 'MultiPoint',
+        coordinates: multiPoint
+    };
+}
+/**
+ * convert Arrow Point to geojson Point
+ */
+function arrowPointToGeometry(arrowPoint) {
+    const point = Array.from(arrowPoint);
+    return {
+        type: 'Point',
+        coordinates: point
+    };
+}
+/**
+ * convert Arrow MultiLineString to geojson MultiLineString
+ */
+function arrowMultiLineStringToGeometry(arrowMultiLineString) {
+    const multiLineString = [];
+    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+        const arrowLineString = arrowMultiLineString.get(i);
+        const lineString = [];
+        for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+            const arrowCoord = arrowLineString.get(j);
+            if (arrowCoord) {
+                const coords = Array.from(arrowCoord);
+                lineString.push(coords);
+            }
+        }
+        multiLineString.push(lineString);
+    }
+    return {
+        type: 'MultiLineString',
+        coordinates: multiLineString
+    };
+}
+/**
+ * convert Arrow LineString to geojson LineString
+ */
+function arrowLineStringToGeometry(arrowLineString) {
+    const lineString = [];
+    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+        const arrowCoord = arrowLineString.get(i);
+        if (arrowCoord) {
+            const coords = Array.from(arrowCoord);
+            lineString.push(coords);
+        }
+    }
+    return {
+        type: 'LineString',
+        coordinates: lineString
+    };
+}

package/dist/lib/geometry-converters/convert-to-geojson.d.ts

@@ -0,0 +1,6 @@
+import type { Geometry, BinaryGeometry } from '@loaders.gl/schema';
+export declare function convertToGeoJSON(geometry: ArrayBuffer | string): Geometry;
+export declare function convertToBinaryGeometry(geometry: ArrayBuffer | string | Geometry): BinaryGeometry;
+export declare function convertToWKT(geometry: Geometry): string;
+export declare function convertToWKB(geometry: Geometry): ArrayBuffer;
+//# sourceMappingURL=convert-to-geojson.d.ts.map

package/dist/lib/geometry-converters/convert-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/geometry-converters/convert-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AASjE,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,CAYzE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,QAAQ,GAAG,cAAc,CAYjG;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAEvD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,WAAW,CAE5D"}

package/dist/lib/geometry-converters/convert-to-geojson.js

@@ -0,0 +1,39 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertGeometryToWKB } from "./wkb/convert-geometry-to-wkb.js";
+import { convertGeometryToWKT } from "./wkb/convert-geometry-to-wkt.js";
+import { convertWKBToBinaryGeometry } from "./wkb/convert-wkb-to-binary-geometry.js";
+import { convertWKTToGeometry } from "./wkb/convert-wkt-to-geometry.js";
+import { convertBinaryGeometryToGeometry } from "./convert-binary-geometry-to-geojson.js";
+export function convertToGeoJSON(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) {
+    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) {
+    return convertGeometryToWKT(geometry);
+}
+export function convertToWKB(geometry) {
+    return convertGeometryToWKB(geometry);
+}
+// export function convertToTWKB(geometry: Geometry): ArrayBuffer {
+//   return convertGeometryToTWKB(geometry);
+// }

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

@@ -0,0 +1,6 @@
+import type { Geometry } from '@loaders.gl/schema';
+export declare function convertGeometryToTWKB(geometry: Geometry, options?: {
+    hasZ?: boolean;
+    hasM?: boolean;
+}): ArrayBuffer;
+//# sourceMappingURL=convert-geometry-to-twkb.d.ts.map

package/dist/lib/geometry-converters/wkb/convert-geometry-to-twkb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geometry-to-twkb.d.ts","sourceRoot":"","sources":["../../../../src/lib/geometry-converters/wkb/convert-geometry-to-twkb.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,oBAAoB,CAAC;AAmB5B,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;IAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,CAAA;CAAC,GACzC,WAAW,CAab"}

package/dist/lib/geometry-converters/wkb/convert-geometry-to-twkb.js

@@ -0,0 +1,195 @@
+// 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 { BinaryWriter } from "../../utils/binary-writer.js";
+import { WKBGeometryType } from "./helpers/wkb-types.js";
+export function convertGeometryToTWKB(geometry, options) {
+    const writer = new BinaryWriter(0, true);
+    const context = {
+        ...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, geometry, context) {
+    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, context, point) {
+    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, context, lineString) {
+    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, context, polygon) {
+    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, context, multiPoint) {
+    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, context, multiLineStrings) {
+    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, context, multiPolygon) {
+    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, context, geometryCollection) {
+    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, context, geometryType, isEmpty) {
+    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, context, point, previousPoint) {
+    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) {
+    return (value << 1) ^ (value >> 31);
+}
+function getTwkbPrecision(xyPrecision, zPrecision, mPrecision) {
+    return {
+        xy: xyPrecision,
+        z: zPrecision,
+        m: mPrecision,
+        xyFactor: Math.pow(10, xyPrecision),
+        zFactor: Math.pow(10, zPrecision),
+        mFactor: Math.pow(10, mPrecision)
+    };
+}

package/dist/lib/geometry-converters/wkb/convert-geometry-to-wkb.d.ts

@@ -0,0 +1,9 @@
+import type { Feature, Geometry } from '@loaders.gl/schema';
+import { WKBOptions } from "./helpers/wkb-types.js";
+/**
+ * Encodes a GeoJSON object into WKB
+ * @param geojson A GeoJSON Feature or Geometry
+ * @returns string
+ */
+export declare function convertGeometryToWKB(geometry: Geometry | Feature, options?: WKBOptions): ArrayBuffer;
+//# sourceMappingURL=convert-geometry-to-wkb.d.ts.map

package/dist/lib/geometry-converters/wkb/convert-geometry-to-wkb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geometry-to-wkb.d.ts","sourceRoot":"","sources":["../../../../src/lib/geometry-converters/wkb/convert-geometry-to-wkb.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EAQT,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAkB,UAAU,EAAC,+BAA4B;AAGhE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,GAAG,OAAO,EAC5B,OAAO,GAAE,UAAe,GACvB,WAAW,CAwBb"}