@loaders.gl/geoarrow 4.4.0-alpha.1

package/dist/get-arrow-bounds.js

@@ -0,0 +1,34 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ *  Update bounds from geoarrow sample data
+ *
+ * @param flatCoords the flattend coordinates array from one chunk of geoarrow column
+ * @param nDim the number of dimensions of the coordinates
+ * @param bounds the bounds to be updated
+ * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk
+ * @returns the updated bounds
+ */
+export function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+    const numberOfFeatures = flatCoords.length / nDim;
+    const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+    const newBounds = [...bounds];
+    for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+        const lng = flatCoords[i * nDim];
+        const lat = flatCoords[i * nDim + 1];
+        if (lng < newBounds[0]) {
+            newBounds[0] = lng;
+        }
+        if (lat < newBounds[1]) {
+            newBounds[1] = lat;
+        }
+        if (lng > newBounds[2]) {
+            newBounds[2] = lng;
+        }
+        if (lat > newBounds[3]) {
+            newBounds[3] = lat;
+        }
+    }
+    return newBounds;
+}

package/dist/get-geoarrow-geometry-info.d.ts

@@ -0,0 +1,30 @@
+import * as arrow from 'apache-arrow';
+import type { GeoArrowEncoding } from "./metadata/geoarrow-metadata.js";
+/**
+ * @see https://geoarrow.org/format.html#memory-layouts
+ */
+export type GeoArrowGeometryInfo = {
+    /** Geometry encodings that are compatible with this column (Field) */
+    compatibleEncodings: GeoArrowEncoding[];
+    /** How many levels of List<> nesting  */
+    nesting: 0 | 1 | 2 | 3;
+    /** How many values per coordinate */
+    dimension: number;
+    /**
+     * - 0: A point is just a Coordinate
+     * - 1: A line string or a multipoint is a List<Coordinate>
+     * - 2: A polygon or a multilinestring are List<List<Coordinate>>
+     * - 3: multipolygons are List<List<List<Coordinate>>>
+     */
+    /** Coordinate memory layout {x,y,...} vs [x,y,...] */
+    coordinates: 'separated' | 'interleaved';
+    /** Coordinate  */
+    valueType: 'double';
+};
+/**
+ * Examines a column containing GeoArrow formatted data and returns information about the geometry type
+ * that can be useful during traversal
+ * @see https://geoarrow.org/format.html#memory-layouts
+ */
+export declare function getGeoArrowGeometryInfo(arrowField: arrow.Field): GeoArrowGeometryInfo | null;
+//# sourceMappingURL=get-geoarrow-geometry-info.d.ts.map

package/dist/get-geoarrow-geometry-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-geoarrow-geometry-info.d.ts","sourceRoot":"","sources":["../src/get-geoarrow-geometry-info.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAC,gBAAgB,EAAC,wCAAqC;AAEnE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,sEAAsE;IACtE,mBAAmB,EAAE,gBAAgB,EAAE,CAAC;IACxC,yCAAyC;IACzC,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACvB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,sDAAsD;IACtD,WAAW,EAAE,WAAW,GAAG,aAAa,CAAC;IACzC,kBAAkB;IAClB,SAAS,EAAE,QAAQ,CAAC;CACrB,CAAC;AASF;;;;GAIG;AAEH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,GAAG,oBAAoB,GAAG,IAAI,CA8E5F"}

package/dist/get-geoarrow-geometry-info.js

@@ -0,0 +1,124 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+/**
+ * Examines a column containing GeoArrow formatted data and returns information about the geometry type
+ * that can be useful during traversal
+ * @see https://geoarrow.org/format.html#memory-layouts
+ */
+// eslint-disable-next-line max-statements
+export function getGeoArrowGeometryInfo(arrowField) {
+    if (arrowField.type instanceof arrow.Utf8) {
+        return {
+            compatibleEncodings: ['geoarrow.wkt'],
+            nesting: 0,
+            /** @note: Dimension encoded in WKT */
+            dimension: 2,
+            coordinates: 'interleaved',
+            valueType: 'double'
+        };
+    }
+    if (arrowField.type instanceof arrow.Binary || arrowField.type instanceof arrow.LargeBinary) {
+        return {
+            compatibleEncodings: ['geoarrow.wkb'],
+            nesting: 0,
+            /** @note: Dimension encoded in WKB */
+            dimension: 2,
+            coordinates: 'interleaved',
+            valueType: 'double'
+        };
+    }
+    let coordinateInfo = getCoordinateFieldInfo(arrowField);
+    // A point is just a Coordinate
+    if (coordinateInfo) {
+        return {
+            compatibleEncodings: ['geoarrow.point'],
+            nesting: 0,
+            ...coordinateInfo
+        };
+    }
+    // A line string or a multipoint is a List<Coordinate>
+    if (!(arrowField.type instanceof arrow.List)) {
+        return null;
+    }
+    arrowField = arrowField.type.children[0];
+    coordinateInfo = getCoordinateFieldInfo(arrowField);
+    if (coordinateInfo) {
+        return {
+            compatibleEncodings: ['geoarrow.linestring', 'geoarrow.multipoint'],
+            nesting: 1,
+            ...coordinateInfo
+        };
+    }
+    // A polygon or a multiline string are List<List<Coordinate>>
+    if (!(arrowField.type instanceof arrow.List)) {
+        return null;
+    }
+    arrowField = arrowField.type.children[0];
+    coordinateInfo = getCoordinateFieldInfo(arrowField);
+    if (coordinateInfo) {
+        return {
+            compatibleEncodings: ['geoarrow.polygon', 'geoarrow.multilinestring'],
+            nesting: 2,
+            ...coordinateInfo
+        };
+    }
+    // A multipolygons are List<List<List<Coordinate>>>
+    if (!(arrowField.type instanceof arrow.List)) {
+        return null;
+    }
+    arrowField = arrowField.type.children[0];
+    coordinateInfo = getCoordinateFieldInfo(arrowField);
+    if (coordinateInfo) {
+        return {
+            compatibleEncodings: ['geoarrow.multipolygon'],
+            nesting: 3,
+            ...coordinateInfo
+        };
+    }
+    return null;
+}
+/**
+ * @see https://geoarrow.org/format.html#memory-layouts
+ */
+function getCoordinateFieldInfo(arrowField) {
+    // interleaved case
+    if (arrowField.type instanceof arrow.FixedSizeList) {
+        const dimension = arrowField.type.listSize;
+        if (dimension < 2 || dimension > 4) {
+            return null;
+        }
+        const child = arrowField.type.children[0];
+        // Spec currently only supports 64 bit coordinates
+        if (!(child.type instanceof arrow.Float)) {
+            return null;
+        }
+        return {
+            coordinates: 'interleaved',
+            dimension: dimension,
+            valueType: 'double'
+        };
+    }
+    // separated case
+    if (arrowField.type instanceof arrow.Struct) {
+        const children = arrowField.type.children;
+        const dimension = children.length;
+        if (dimension < 2 || dimension > 4) {
+            return null;
+        }
+        // Spec currently only supports 64 bit coordinates
+        for (const child of children) {
+            if (!(child.type instanceof arrow.Float)) {
+                return null;
+            }
+        }
+        return {
+            coordinates: 'separated',
+            dimension: dimension,
+            valueType: 'double'
+        };
+    }
+    // No other types are valid coordinates
+    return null;
+}

package/dist/index.cjs

@@ -0,0 +1,430 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  getBoundingBoxFromArrowPositions: () => getBoundingBoxFromArrowPositions,
+  getDeckBinaryDataFromArrowMesh: () => getDeckBinaryDataFromArrowMesh,
+  getGeoArrowGeometryInfo: () => getGeoArrowGeometryInfo,
+  getGeoMetadata: () => getGeoMetadata,
+  getGeometryColumnsFromSchema: () => getGeometryColumnsFromSchema,
+  isGeoArrowGeometry: () => isGeoArrowGeometry,
+  isGeoArrowLineString: () => isGeoArrowLineString,
+  isGeoArrowMultiLineString: () => isGeoArrowMultiLineString,
+  isGeoArrowMultiPoint: () => isGeoArrowMultiPoint,
+  isGeoArrowMultiPolygon: () => isGeoArrowMultiPolygon,
+  isGeoArrowPoint: () => isGeoArrowPoint,
+  isGeoArrowPolygon: () => isGeoArrowPolygon,
+  unpackGeoMetadata: () => unpackGeoMetadata,
+  unpackJSONStringMetadata: () => unpackJSONStringMetadata,
+  updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/mesharrow/get-bounding-box.js
+var arrow = __toESM(require("apache-arrow"), 1);
+function getBoundingBoxFromArrowPositions(column) {
+  const mins = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE];
+  const maxs = [Number.MIN_VALUE, Number.MIN_VALUE, Number.MIN_VALUE];
+  const valueColumn = column.getChildAt(0);
+  for (const data of valueColumn.data) {
+    const pointSize = 3;
+    const pointData = data.buffers[arrow.BufferType.DATA];
+    const pointCount = pointData.length / pointSize;
+    for (let i = 0; i < pointCount; i += pointSize) {
+      const x = pointData[i];
+      const y = pointData[i + 1];
+      const z = pointData[i + 2];
+      if (x < mins[0])
+        mins[0] = x;
+      else if (x > maxs[0])
+        maxs[0] = x;
+      if (y < mins[1])
+        mins[1] = y;
+      else if (y > maxs[1])
+        maxs[1] = y;
+      if (z < mins[2])
+        mins[2] = z;
+      else if (z > maxs[2])
+        maxs[2] = z;
+    }
+  }
+  return [mins, maxs];
+}
+
+// dist/mesharrow/arrow-fixed-size-list-utils.js
+var arrow2 = __toESM(require("apache-arrow"), 1);
+var import_schema_utils = require("@loaders.gl/schema-utils");
+function getFixedSizeListSize(vector) {
+  return vector.type instanceof arrow2.FixedSizeList ? vector.type.listSize : 1;
+}
+
+// dist/mesharrow/mesh-accessors.js
+function getSizeAndValueFromMeshArrowVector(attributeVector) {
+  const size = getFixedSizeListSize(attributeVector);
+  const typedArrays = getTypedArraysFromMeshArrowVector(attributeVector);
+  return { size, value: typedArrays[0] };
+}
+function getTypedArraysFromMeshArrowVector(attributeVector) {
+  const typedArrays = [];
+  for (const attributeData of attributeVector.data) {
+    const valueData = attributeData == null ? void 0 : attributeData.children[0];
+    const typedArray = valueData.values;
+    typedArrays.push(typedArray);
+  }
+  return typedArrays;
+}
+
+// dist/mesharrow/get-deck-binary-data.js
+function getDeckBinaryDataFromArrowMesh(table) {
+  const positionVector = table.getChild("POSITION");
+  if (!positionVector) {
+    throw new Error("POSITION attribute not found");
+  }
+  const getPosition = getSizeAndValueFromMeshArrowVector(positionVector);
+  const deckAttributes = {
+    getPosition
+  };
+  const colorVector = table.getChild("COLOR_0");
+  if (colorVector) {
+    deckAttributes.getColor = getSizeAndValueFromMeshArrowVector(colorVector);
+  }
+  return {
+    length: table.numRows,
+    attributes: deckAttributes
+  };
+}
+
+// dist/geoarrow-functions.js
+var import_type = require("apache-arrow/type");
+function isGeoArrowPoint(type) {
+  if (import_type.DataType.isFixedSizeList(type)) {
+    if (![2, 3, 4].includes(type.listSize)) {
+      return false;
+    }
+    if (!import_type.DataType.isFloat(type.children[0])) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isGeoArrowLineString(type) {
+  if (!import_type.DataType.isList(type)) {
+    return false;
+  }
+  if (!isGeoArrowPoint(type.children[0].type)) {
+    return false;
+  }
+  return true;
+}
+function isGeoArrowPolygon(type) {
+  if (!import_type.DataType.isList(type)) {
+    return false;
+  }
+  if (!isGeoArrowLineString(type.children[0].type)) {
+    return false;
+  }
+  return true;
+}
+function isGeoArrowMultiPoint(type) {
+  if (!import_type.DataType.isList(type)) {
+    return false;
+  }
+  if (!isGeoArrowPoint(type.children[0].type)) {
+    return false;
+  }
+  return true;
+}
+function isGeoArrowMultiLineString(type) {
+  if (!import_type.DataType.isList(type)) {
+    return false;
+  }
+  if (!isGeoArrowLineString(type.children[0].type)) {
+    return false;
+  }
+  return true;
+}
+function isGeoArrowMultiPolygon(type) {
+  if (!import_type.DataType.isList(type)) {
+    return false;
+  }
+  if (!isGeoArrowPolygon(type.children[0].type)) {
+    return false;
+  }
+  return true;
+}
+function isGeoArrowGeometry(type) {
+  return isGeoArrowPoint(type) || isGeoArrowLineString(type) || isGeoArrowPolygon(type) || isGeoArrowMultiPoint(type) || isGeoArrowMultiLineString(type) || isGeoArrowMultiPolygon(type);
+}
+
+// dist/metadata/metadata-utils.js
+function getMetadataValue(metadata, key) {
+  return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
+}
+function setMetadataValue(metadata, key, value) {
+  if (metadata instanceof Map) {
+    metadata.set("key", key);
+  } else {
+    metadata.key = key;
+  }
+}
+
+// dist/metadata/geoarrow-metadata.js
+var GEOARROW_ENCODINGS = [
+  "geoarrow.multipolygon",
+  "geoarrow.polygon",
+  "geoarrow.multilinestring",
+  "geoarrow.linestring",
+  "geoarrow.multipoint",
+  "geoarrow.point",
+  "geoarrow.wkb",
+  "geoarrow.wkt"
+];
+var GEOARROW_ENCODING = "ARROW:extension:name";
+var GEOARROW_METADATA = "ARROW:extension:metadata";
+function getGeometryColumnsFromSchema(schema) {
+  const geometryColumns = {};
+  for (const field of schema.fields || []) {
+    const metadata = getGeometryMetadataForField((field == null ? void 0 : field.metadata) || {});
+    if (metadata) {
+      geometryColumns[field.name] = metadata;
+    }
+  }
+  return geometryColumns;
+}
+function getGeometryMetadataForField(fieldMetadata) {
+  let metadata = null;
+  let geoEncoding = getMetadataValue(fieldMetadata, GEOARROW_ENCODING);
+  if (geoEncoding) {
+    geoEncoding = geoEncoding.toLowerCase();
+    if (geoEncoding === "wkb") {
+      geoEncoding = "geoarrow.wkb";
+    }
+    if (geoEncoding === "wkt") {
+      geoEncoding = "geoarrow.wkt";
+    }
+    if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+      console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+    } else {
+      metadata ||= {};
+      metadata.encoding = geoEncoding;
+    }
+  }
+  const columnMetadata = getMetadataValue(fieldMetadata, GEOARROW_METADATA);
+  if (columnMetadata) {
+    try {
+      metadata = JSON.parse(columnMetadata);
+    } catch (error) {
+      console.warn("Failed to parse GeoArrow metadata", error);
+    }
+  }
+  return metadata || null;
+}
+
+// dist/metadata/geoparquet-metadata.js
+function getGeoMetadata(metadata) {
+  const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  if (!geoMetadata) {
+    return null;
+  }
+  for (const column of Object.values(geoMetadata.columns || {})) {
+    if (column.encoding) {
+      column.encoding = column.encoding.toLowerCase();
+    }
+  }
+  return geoMetadata;
+}
+function unpackGeoMetadata(metadata) {
+  const geoMetadata = getGeoMetadata(metadata);
+  if (!geoMetadata) {
+    return;
+  }
+  const { version, primary_column, columns } = geoMetadata;
+  if (version) {
+    setMetadataValue(metadata, "geo.version", version);
+  }
+  if (primary_column) {
+    setMetadataValue(metadata, "geo.primary_column", primary_column);
+  }
+  setMetadataValue(metadata, "geo.columns", Object.keys(columns || {}).join(""));
+}
+function unpackJSONStringMetadata(metadata, metadataKey) {
+  const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
+  const json = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  for (const [key, value] of Object.entries(json || {})) {
+    setMetadataValue(metadata, `${metadataKey}.${key}`, typeof value === "string" ? value : JSON.stringify(value));
+  }
+}
+function parseJSONStringMetadata(stringifiedMetadata) {
+  if (!stringifiedMetadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(stringifiedMetadata);
+    if (!metadata || typeof metadata !== "object") {
+      return null;
+    }
+    return metadata;
+  } catch {
+    return null;
+  }
+}
+
+// dist/get-geoarrow-geometry-info.js
+var arrow3 = __toESM(require("apache-arrow"), 1);
+function getGeoArrowGeometryInfo(arrowField) {
+  if (arrowField.type instanceof arrow3.Utf8) {
+    return {
+      compatibleEncodings: ["geoarrow.wkt"],
+      nesting: 0,
+      /** @note: Dimension encoded in WKT */
+      dimension: 2,
+      coordinates: "interleaved",
+      valueType: "double"
+    };
+  }
+  if (arrowField.type instanceof arrow3.Binary || arrowField.type instanceof arrow3.LargeBinary) {
+    return {
+      compatibleEncodings: ["geoarrow.wkb"],
+      nesting: 0,
+      /** @note: Dimension encoded in WKB */
+      dimension: 2,
+      coordinates: "interleaved",
+      valueType: "double"
+    };
+  }
+  let coordinateInfo = getCoordinateFieldInfo(arrowField);
+  if (coordinateInfo) {
+    return {
+      compatibleEncodings: ["geoarrow.point"],
+      nesting: 0,
+      ...coordinateInfo
+    };
+  }
+  if (!(arrowField.type instanceof arrow3.List)) {
+    return null;
+  }
+  arrowField = arrowField.type.children[0];
+  coordinateInfo = getCoordinateFieldInfo(arrowField);
+  if (coordinateInfo) {
+    return {
+      compatibleEncodings: ["geoarrow.linestring", "geoarrow.multipoint"],
+      nesting: 1,
+      ...coordinateInfo
+    };
+  }
+  if (!(arrowField.type instanceof arrow3.List)) {
+    return null;
+  }
+  arrowField = arrowField.type.children[0];
+  coordinateInfo = getCoordinateFieldInfo(arrowField);
+  if (coordinateInfo) {
+    return {
+      compatibleEncodings: ["geoarrow.polygon", "geoarrow.multilinestring"],
+      nesting: 2,
+      ...coordinateInfo
+    };
+  }
+  if (!(arrowField.type instanceof arrow3.List)) {
+    return null;
+  }
+  arrowField = arrowField.type.children[0];
+  coordinateInfo = getCoordinateFieldInfo(arrowField);
+  if (coordinateInfo) {
+    return {
+      compatibleEncodings: ["geoarrow.multipolygon"],
+      nesting: 3,
+      ...coordinateInfo
+    };
+  }
+  return null;
+}
+function getCoordinateFieldInfo(arrowField) {
+  if (arrowField.type instanceof arrow3.FixedSizeList) {
+    const dimension = arrowField.type.listSize;
+    if (dimension < 2 || dimension > 4) {
+      return null;
+    }
+    const child = arrowField.type.children[0];
+    if (!(child.type instanceof arrow3.Float)) {
+      return null;
+    }
+    return {
+      coordinates: "interleaved",
+      dimension,
+      valueType: "double"
+    };
+  }
+  if (arrowField.type instanceof arrow3.Struct) {
+    const children = arrowField.type.children;
+    const dimension = children.length;
+    if (dimension < 2 || dimension > 4) {
+      return null;
+    }
+    for (const child of children) {
+      if (!(child.type instanceof arrow3.Float)) {
+        return null;
+      }
+    }
+    return {
+      coordinates: "separated",
+      dimension,
+      valueType: "double"
+    };
+  }
+  return null;
+}
+
+// dist/get-arrow-bounds.js
+function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+  const numberOfFeatures = flatCoords.length / nDim;
+  const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+  const newBounds = [...bounds];
+  for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+    const lng = flatCoords[i * nDim];
+    const lat = flatCoords[i * nDim + 1];
+    if (lng < newBounds[0]) {
+      newBounds[0] = lng;
+    }
+    if (lat < newBounds[1]) {
+      newBounds[1] = lat;
+    }
+    if (lng > newBounds[2]) {
+      newBounds[2] = lng;
+    }
+    if (lat > newBounds[3]) {
+      newBounds[3] = lat;
+    }
+  }
+  return newBounds;
+}
+//# sourceMappingURL=index.cjs.map