@loaders.gl/wkt 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/lib/parse-wkb.ts

@@ -1,59 +1,70 @@
+// loaders.gl, MIT license
+
 import type {
   TypedArray,
   BinaryGeometry,
   BinaryPointGeometry,
   BinaryLineGeometry,
-  BinaryPolygonGeometry
+  BinaryPolygonGeometry,
+  Geometry
 } from '@loaders.gl/schema';
+import {binaryToGeometry} from '@loaders.gl/gis';
+import type {WKBLoaderOptions} from '../wkb-loader';
+
+import {parseWKBHeader, WKBGeometryType} from './parse-wkb-header';
+
+export function parseWKB(
+  arrayBuffer: ArrayBuffer,
+  options?: WKBLoaderOptions
+): BinaryGeometry | Geometry {
+  const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
+  const shape = options?.wkb?.shape || 'binary-geometry';
+  switch (shape) {
+    case 'binary-geometry':
+      return binaryGeometry;
+    case 'geometry':
+      return binaryToGeometry(binaryGeometry);
+    default:
+      throw new Error(shape);
+  }
+}
 
-const NUM_DIMENSIONS = {
-  0: 2, // 2D
-  1: 3, // 3D (Z)
-  2: 3, // 3D (M)
-  3: 4 // 4D (ZM)
-};
-
-export default function parseWKB(arrayBuffer: ArrayBuffer): BinaryGeometry {
-  const view = new DataView(arrayBuffer);
-  let offset = 0;
-
-  // Check endianness of data
-  const littleEndian = view.getUint8(offset) === 1;
-  offset++;
+export function parseWKBToBinary(
+  arrayBuffer: ArrayBuffer,
+  options?: WKBLoaderOptions
+): BinaryGeometry {
+  const dataView = new DataView(arrayBuffer);
 
-  // 4-digit code representing dimension and type of geometry
-  const geometryCode = view.getUint32(offset, littleEndian);
-  offset += 4;
+  const wkbHeader = parseWKBHeader(dataView);
 
-  const geometryType = geometryCode % 1000;
-  const type = ((geometryCode - geometryType) / 1000) as 0 | 1 | 2 | 3;
-  const dimension = NUM_DIMENSIONS[type];
+  const {geometryType, dimensions, littleEndian} = wkbHeader;
+  const offset = wkbHeader.byteOffset;
 
   switch (geometryType) {
-    case 1:
-      const point = parsePoint(view, offset, dimension, littleEndian);
+    case WKBGeometryType.Point:
+      const point = parsePoint(dataView, offset, dimensions, littleEndian);
       return point.geometry;
-    case 2:
-      const line = parseLineString(view, offset, dimension, littleEndian);
+    case WKBGeometryType.LineString:
+      const line = parseLineString(dataView, offset, dimensions, littleEndian);
       return line.geometry;
-    case 3:
-      const polygon = parsePolygon(view, offset, dimension, littleEndian);
+    case WKBGeometryType.Polygon:
+      const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
       return polygon.geometry;
-    case 4:
-      const multiPoint = parseMultiPoint(view, offset, dimension, littleEndian);
+    case WKBGeometryType.MultiPoint:
+      const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
       multiPoint.type = 'Point';
       return multiPoint;
-    case 5:
-      const multiLine = parseMultiLineString(view, offset, dimension, littleEndian);
+    case WKBGeometryType.MultiLineString:
+      const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
       multiLine.type = 'LineString';
       return multiLine;
-    case 6:
-      const multiPolygon = parseMultiPolygon(view, offset, dimension, littleEndian);
+    case WKBGeometryType.MultiPolygon:
+      const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
       multiPolygon.type = 'Polygon';
       return multiPolygon;
-    // case 7:
+    // case WKBGeometryType.GeometryCollection:
     // TODO: handle GeometryCollections
-    // return parseGeometryCollection(view, offset, dimension, littleEndian);
+    // return parseGeometryCollection(dataView, offset, dimensions, littleEndian);
     default:
       throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
   }
@@ -61,14 +72,14 @@ export default function parseWKB(arrayBuffer: ArrayBuffer): BinaryGeometry {
 
 // Primitives; parse point and linear ring
 function parsePoint(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): {geometry: BinaryPointGeometry; offset: number} {
   const positions = new Float64Array(dimension);
   for (let i = 0; i < dimension; i++) {
-    positions[i] = view.getFloat64(offset, littleEndian);
+    positions[i] = dataView.getFloat64(offset, littleEndian);
     offset += 8;
   }
 
@@ -79,18 +90,18 @@ function parsePoint(
 }
 
 function parseLineString(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): {geometry: BinaryLineGeometry; offset: number} {
-  const nPoints = view.getUint32(offset, littleEndian);
+  const nPoints = dataView.getUint32(offset, littleEndian);
   offset += 4;
 
   // Instantiate array
   const positions = new Float64Array(nPoints * dimension);
   for (let i = 0; i < nPoints * dimension; i++) {
-    positions[i] = view.getFloat64(offset, littleEndian);
+    positions[i] = dataView.getFloat64(offset, littleEndian);
     offset += 8;
   }
 
@@ -113,17 +124,17 @@ function parseLineString(
 const cumulativeSum = (sum: number) => (value: number) => (sum += value);
 
 function parsePolygon(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): {geometry: BinaryPolygonGeometry; offset: number} {
-  const nRings = view.getUint32(offset, littleEndian);
+  const nRings = dataView.getUint32(offset, littleEndian);
   offset += 4;
 
   const rings: TypedArray[] = [];
   for (let i = 0; i < nRings; i++) {
-    const parsed = parseLineString(view, offset, dimension, littleEndian);
+    const parsed = parseLineString(dataView, offset, dimension, littleEndian);
     const {positions} = parsed.geometry;
     offset = parsed.offset;
     rings.push(positions.value);
@@ -152,28 +163,28 @@ function parsePolygon(
 }
 
 function parseMultiPoint(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): BinaryPointGeometry {
-  const nPoints = view.getUint32(offset, littleEndian);
+  const nPoints = dataView.getUint32(offset, littleEndian);
   offset += 4;
 
   const binaryPointGeometries: BinaryPointGeometry[] = [];
   for (let i = 0; i < nPoints; i++) {
     // Byte order for point
-    const littleEndianPoint = view.getUint8(offset) === 1;
+    const littleEndianPoint = dataView.getUint8(offset) === 1;
     offset++;
 
     // Assert point type
-    if (view.getUint32(offset, littleEndianPoint) % 1000 !== 1) {
+    if (dataView.getUint32(offset, littleEndianPoint) % 1000 !== 1) {
       throw new Error('WKB: Inner geometries of MultiPoint not of type Point');
     }
 
     offset += 4;
 
-    const parsed = parsePoint(view, offset, dimension, littleEndianPoint);
+    const parsed = parsePoint(dataView, offset, dimension, littleEndianPoint);
     offset = parsed.offset;
     binaryPointGeometries.push(parsed.geometry);
   }
@@ -182,27 +193,27 @@ function parseMultiPoint(
 }
 
 function parseMultiLineString(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): BinaryLineGeometry {
-  const nLines = view.getUint32(offset, littleEndian);
+  const nLines = dataView.getUint32(offset, littleEndian);
   offset += 4;
 
   const binaryLineGeometries: BinaryLineGeometry[] = [];
   for (let i = 0; i < nLines; i++) {
     // Byte order for line
-    const littleEndianLine = view.getUint8(offset) === 1;
+    const littleEndianLine = dataView.getUint8(offset) === 1;
     offset++;
 
     // Assert type LineString
-    if (view.getUint32(offset, littleEndianLine) % 1000 !== 2) {
+    if (dataView.getUint32(offset, littleEndianLine) % 1000 !== 2) {
       throw new Error('WKB: Inner geometries of MultiLineString not of type LineString');
     }
     offset += 4;
 
-    const parsed = parseLineString(view, offset, dimension, littleEndianLine);
+    const parsed = parseLineString(dataView, offset, dimension, littleEndianLine);
     offset = parsed.offset;
     binaryLineGeometries.push(parsed.geometry);
   }
@@ -211,27 +222,27 @@ function parseMultiLineString(
 }
 
 function parseMultiPolygon(
-  view: DataView,
+  dataView: DataView,
   offset: number,
   dimension: number,
   littleEndian: boolean
 ): BinaryPolygonGeometry {
-  const nPolygons = view.getUint32(offset, littleEndian);
+  const nPolygons = dataView.getUint32(offset, littleEndian);
   offset += 4;
 
   const binaryPolygonGeometries: BinaryPolygonGeometry[] = [];
   for (let i = 0; i < nPolygons; i++) {
     // Byte order for polygon
-    const littleEndianPolygon = view.getUint8(offset) === 1;
+    const littleEndianPolygon = dataView.getUint8(offset) === 1;
     offset++;
 
     // Assert type Polygon
-    if (view.getUint32(offset, littleEndianPolygon) % 1000 !== 3) {
+    if (dataView.getUint32(offset, littleEndianPolygon) % 1000 !== 3) {
       throw new Error('WKB: Inner geometries of MultiPolygon not of type Polygon');
     }
     offset += 4;
 
-    const parsed = parsePolygon(view, offset, dimension, littleEndianPolygon);
+    const parsed = parsePolygon(dataView, offset, dimension, littleEndianPolygon);
     offset = parsed.offset;
     binaryPolygonGeometries.push(parsed.geometry);
   }

package/src/lib/parse-wkt-crs.ts

@@ -0,0 +1,147 @@
+// loaders.gl, MIT license
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+
+/* eslint-disable no-console */ // TODO switch to options.log
+
+export type ParseWKTCRSOptions = {
+  sort?: boolean;
+  keywords?: string[];
+  raw?: boolean;
+  debug?: boolean;
+};
+
+export type WKTCRS = any;
+
+/**
+ *
+ * @param wkt
+ * @param options
+ * @returns
+ */
+export function parseWKTCRS(wkt: string, options?: ParseWKTCRSOptions): WKTCRS {
+  if (options?.debug) {
+    console.log('[wktcrs] parse starting with\n', wkt);
+  }
+
+  // move all keywords into first array item slot
+  // from PARAM[12345, 67890] to ["PARAM", 12345, 67890]
+  wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+
+  // wrap variables in strings
+  // from [...,NORTH] to [...,"NORTH"]
+  wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+    const varname = p1.substr(0, p1.length - 1);
+    return ',' + `"${options?.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
+  });
+
+  if (options?.raw) {
+    // replace all numbers with strings
+    wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
+      return ',' + `"${options?.raw ? 'raw:' : ''}${p1}"`;
+    });
+  }
+
+  // str should now be valid JSON
+  if (options?.debug) {
+    console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(wkt);
+  } catch (error) {
+    console.error(`[wktcrs] failed to parse '${wkt}'`);
+    throw error;
+  }
+
+  if (options?.debug) {
+    console.log(`[wktcrs] json parsed: '${wkt}'`);
+  }
+
+  function process(data, parent) {
+    const kw = data[0];
+
+    // after removing the first element with .shift()
+    // data is now just an array of attributes
+
+    data.forEach(function (it) {
+      if (Array.isArray(it)) {
+        process(it, data);
+      }
+    });
+
+    const kwarr = `MULTIPLE_${kw}`;
+
+    if (kwarr in parent) {
+      parent[kwarr].push(data);
+    } else if (kw in parent) {
+      parent[kwarr] = [parent[kw], data];
+      delete parent[kw];
+    } else {
+      parent[kw] = data;
+    }
+    return parent;
+  }
+
+  const result = process(data, [data]);
+  if (options?.debug) {
+    console.log('[wktcrs] parse returning', result);
+  }
+
+  if (options?.sort) {
+    sort(result, options);
+  }
+
+  return result;
+}
+
+function sort(data: string[], options?: {keywords?: string[]}) {
+  const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+
+  const keywords: string[] = options?.keywords || [];
+  if (!options?.keywords) {
+    // try to find multiples
+    const counts = {};
+    if (Array.isArray(data)) {
+      data.forEach((it) => {
+        if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
+          const k = it[0];
+          if (!counts[k]) counts[k] = 0;
+          counts[k]++;
+        }
+      });
+      for (const k in counts) {
+        if (counts[k] > 0) keywords.push(k);
+      }
+    }
+  }
+
+  keys.forEach((key) => {
+    data[key] = sort(data[key]);
+  });
+
+  keywords.forEach((key) => {
+    const indices: number[] = [];
+    const params: string[] = [];
+
+    data.forEach((item, i) => {
+      if (Array.isArray(item) && item[0] === key) {
+        indices.push(i);
+        params.push(item);
+      }
+    });
+
+    params.sort((a, b) => {
+      a = a[1].toString();
+      b = b[1].toString();
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+
+    // replace in order
+    params.forEach((param, i) => {
+      data[indices[i]] = param;
+    });
+  });
+
+  return data;
+}