@loaders.gl/gis 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/lib/binary-features/geojson-to-binary.js

@@ -1,24 +1,21 @@
 import { extractGeometryInfo } from "./extract-geometry-info.js";
 import { geojsonToFlatGeojson } from "./geojson-to-flat-geojson.js";
 import { flatGeojsonToBinary } from "./flat-geojson-to-binary.js";
-export function geojsonToBinary(features) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-    fixRingWinding: true,
-    triangulate: true
-  };
-  const geometryInfo = extractGeometryInfo(features);
-  const coordLength = geometryInfo.coordLength;
-  const {
-    fixRingWinding
-  } = options;
-  const flatFeatures = geojsonToFlatGeojson(features, {
-    coordLength,
-    fixRingWinding
-  });
-  return flatGeojsonToBinary(flatFeatures, geometryInfo, {
-    numericPropKeys: options.numericPropKeys,
-    PositionDataType: options.PositionDataType || Float32Array,
-    triangulate: options.triangulate
-  });
+/**
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
+ */
+export function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
+    const geometryInfo = extractGeometryInfo(features);
+    const coordLength = geometryInfo.coordLength;
+    const { fixRingWinding } = options;
+    const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+    return flatGeojsonToBinary(flatFeatures, geometryInfo, {
+        numericPropKeys: options.numericPropKeys,
+        PositionDataType: options.PositionDataType || Float32Array,
+        triangulate: options.triangulate
+    });
 }
-//# sourceMappingURL=geojson-to-binary.js.map

package/dist/lib/binary-features/geojson-to-flat-geojson.js

@@ -1,97 +1,124 @@
 import { getPolygonSignedArea } from '@math.gl/polygon';
-export function geojsonToFlatGeojson(features) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-    coordLength: 2,
-    fixRingWinding: true
-  };
-  return features.map(feature => flattenFeature(feature, options));
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+export function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+    return features.map((feature) => flattenFeature(feature, options));
 }
+/**
+ * Helper function to copy Point values from `coordinates` into `data` & `indices`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param options
+ */
 function flattenPoint(coordinates, data, indices, options) {
-  indices.push(data.length);
-  data.push(...coordinates);
-  for (let i = coordinates.length; i < options.coordLength; i++) {
-    data.push(0);
-  }
+    indices.push(data.length);
+    data.push(...coordinates);
+    // Pad up to coordLength
+    for (let i = coordinates.length; i < options.coordLength; i++) {
+        data.push(0);
+    }
 }
+/**
+ * Helper function to copy LineString values from `coordinates` into `data` & `indices`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param options
+ */
 function flattenLineString(coordinates, data, indices, options) {
-  indices.push(data.length);
-  for (const c of coordinates) {
-    data.push(...c);
-    for (let i = c.length; i < options.coordLength; i++) {
-      data.push(0);
+    indices.push(data.length);
+    for (const c of coordinates) {
+        data.push(...c);
+        // Pad up to coordLength
+        for (let i = c.length; i < options.coordLength; i++) {
+            data.push(0);
+        }
     }
-  }
 }
+/**
+ * Helper function to copy Polygon values from `coordinates` into `data` & `indices` & `areas`
+ *
+ * @param coordinates
+ * @param data
+ * @param indices
+ * @param areas
+ * @param options
+ */
 function flattenPolygon(coordinates, data, indices, areas, options) {
-  let count = 0;
-  const ringAreas = [];
-  const polygons = [];
-  for (const lineString of coordinates) {
-    const lineString2d = lineString.map(p => p.slice(0, 2));
-    let area = getPolygonSignedArea(lineString2d.flat());
-    const ccw = area < 0;
-    if (options.fixRingWinding && (count === 0 && !ccw || count > 0 && ccw)) {
-      lineString.reverse();
-      area = -area;
+    let count = 0;
+    const ringAreas = [];
+    const polygons = [];
+    for (const lineString of coordinates) {
+        const lineString2d = lineString.map((p) => p.slice(0, 2));
+        let area = getPolygonSignedArea(lineString2d.flat());
+        const ccw = area < 0;
+        // Exterior ring must be CCW and interior rings CW
+        if (options.fixRingWinding && ((count === 0 && !ccw) || (count > 0 && ccw))) {
+            lineString.reverse();
+            area = -area;
+        }
+        ringAreas.push(area);
+        flattenLineString(lineString, data, polygons, options);
+        count++;
+    }
+    if (count > 0) {
+        areas.push(ringAreas);
+        indices.push(polygons);
     }
-    ringAreas.push(area);
-    flattenLineString(lineString, data, polygons, options);
-    count++;
-  }
-  if (count > 0) {
-    areas.push(ringAreas);
-    indices.push(polygons);
-  }
 }
+/**
+ * Flatten single GeoJSON feature into Flat GeoJSON
+ *
+ * @param feature
+ * @param options
+ * @returns A Flat GeoJSON feature
+ */
 function flattenFeature(feature, options) {
-  const {
-    geometry
-  } = feature;
-  if (geometry.type === 'GeometryCollection') {
-    throw new Error('GeometryCollection type not supported');
-  }
-  const data = [];
-  const indices = [];
-  let areas;
-  let type;
-  switch (geometry.type) {
-    case 'Point':
-      type = 'Point';
-      flattenPoint(geometry.coordinates, data, indices, options);
-      break;
-    case 'MultiPoint':
-      type = 'Point';
-      geometry.coordinates.map(c => flattenPoint(c, data, indices, options));
-      break;
-    case 'LineString':
-      type = 'LineString';
-      flattenLineString(geometry.coordinates, data, indices, options);
-      break;
-    case 'MultiLineString':
-      type = 'LineString';
-      geometry.coordinates.map(c => flattenLineString(c, data, indices, options));
-      break;
-    case 'Polygon':
-      type = 'Polygon';
-      areas = [];
-      flattenPolygon(geometry.coordinates, data, indices, areas, options);
-      break;
-    case 'MultiPolygon':
-      type = 'Polygon';
-      areas = [];
-      geometry.coordinates.map(c => flattenPolygon(c, data, indices, areas, options));
-      break;
-    default:
-      throw new Error(`Unknown type: ${type}`);
-  }
-  return {
-    ...feature,
-    geometry: {
-      type,
-      indices,
-      data,
-      areas
+    const { geometry } = feature;
+    if (geometry.type === 'GeometryCollection') {
+        throw new Error('GeometryCollection type not supported');
+    }
+    const data = [];
+    const indices = [];
+    let areas;
+    let type;
+    switch (geometry.type) {
+        case 'Point':
+            type = 'Point';
+            flattenPoint(geometry.coordinates, data, indices, options);
+            break;
+        case 'MultiPoint':
+            type = 'Point';
+            geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
+            break;
+        case 'LineString':
+            type = 'LineString';
+            flattenLineString(geometry.coordinates, data, indices, options);
+            break;
+        case 'MultiLineString':
+            type = 'LineString';
+            geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
+            break;
+        case 'Polygon':
+            type = 'Polygon';
+            areas = [];
+            flattenPolygon(geometry.coordinates, data, indices, areas, options);
+            break;
+        case 'MultiPolygon':
+            type = 'Polygon';
+            areas = [];
+            geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
+            break;
+        default:
+            throw new Error(`Unknown type: ${type}`);
     }
-  };
+    return { ...feature, geometry: { type, indices, data, areas } };
 }
-//# sourceMappingURL=geojson-to-flat-geojson.js.map

package/dist/lib/binary-features/transform.js

@@ -1,40 +1,54 @@
+/**
+ * Apply transformation to every coordinate of binary features
+ * @param  binaryFeatures binary features
+ * @param  transformCoordinate Function to call on each coordinate
+ * @return Transformed binary features
+ */
 export function transformBinaryCoords(binaryFeatures, transformCoordinate) {
-  if (binaryFeatures.points) {
-    transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
-  }
-  if (binaryFeatures.lines) {
-    transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
-  }
-  if (binaryFeatures.polygons) {
-    transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
-  }
-  return binaryFeatures;
+    if (binaryFeatures.points) {
+        transformBinaryGeometryPositions(binaryFeatures.points, transformCoordinate);
+    }
+    if (binaryFeatures.lines) {
+        transformBinaryGeometryPositions(binaryFeatures.lines, transformCoordinate);
+    }
+    if (binaryFeatures.polygons) {
+        transformBinaryGeometryPositions(binaryFeatures.polygons, transformCoordinate);
+    }
+    return binaryFeatures;
 }
+/** Transform one binary geometry */
 function transformBinaryGeometryPositions(binaryGeometry, fn) {
-  const {
-    positions
-  } = binaryGeometry;
-  for (let i = 0; i < positions.value.length; i += positions.size) {
-    const coord = Array.from(positions.value.subarray(i, i + positions.size));
-    const transformedCoord = fn(coord);
-    positions.value.set(transformedCoord, i);
-  }
+    const { positions } = binaryGeometry;
+    for (let i = 0; i < positions.value.length; i += positions.size) {
+        // @ts-ignore inclusion of bigint causes problems
+        const coord = Array.from(positions.value.subarray(i, i + positions.size));
+        const transformedCoord = fn(coord);
+        // @ts-ignore typescript typing for .set seems to require bigint?
+        positions.value.set(transformedCoord, i);
+    }
 }
+/**
+ * Apply transformation to every coordinate of GeoJSON features
+ *
+ * @param  features Array of GeoJSON features
+ * @param  fn       Function to call on each coordinate
+ * @return          Transformed GeoJSON features
+ */
 export function transformGeoJsonCoords(features, fn) {
-  for (const feature of features) {
-    feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
-  }
-  return features;
+    for (const feature of features) {
+        // @ts-ignore
+        feature.geometry.coordinates = coordMap(feature.geometry.coordinates, fn);
+    }
+    return features;
 }
 function coordMap(array, fn) {
-  if (isCoord(array)) {
-    return fn(array);
-  }
-  return array.map(item => {
-    return coordMap(item, fn);
-  });
+    if (isCoord(array)) {
+        return fn(array);
+    }
+    return array.map((item) => {
+        return coordMap(item, fn);
+    });
 }
 function isCoord(array) {
-  return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
+    return Array.isArray(array) && Number.isFinite(array[0]) && Number.isFinite(array[1]);
 }
-//# sourceMappingURL=transform.js.map

package/dist/lib/geo/geoarrow-metadata.js

@@ -1,43 +1,70 @@
-const GEOARROW_ENCODINGS = ['geoarrow.multipolygon', 'geoarrow.polygon', 'geoarrow.multilinestring', 'geoarrow.linestring', 'geoarrow.multipoint', 'geoarrow.point', 'geoarrow.wkb', 'geoarrow.wkt'];
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Array containing all encodings */
+const GEOARROW_ENCODINGS = [
+    'geoarrow.multipolygon',
+    'geoarrow.polygon',
+    'geoarrow.multilinestring',
+    'geoarrow.linestring',
+    'geoarrow.multipoint',
+    'geoarrow.point',
+    'geoarrow.wkb',
+    'geoarrow.wkt'
+];
 const GEOARROW_COLUMN_METADATA_ENCODING = 'ARROW:extension:name';
 const GEOARROW_COLUMN_METADATA_METADATA = 'ARROW:extension:metadata';
+/**
+ * get geometry columns from arrow table
+ */
 export function getGeometryColumnsFromSchema(schema) {
-  const geometryColumns = {};
-  for (const field of schema.fields) {
-    const metadata = getGeometryMetadataForField(field);
-    if (metadata) {
-      geometryColumns[field.name] = metadata;
+    const geometryColumns = {};
+    for (const field of schema.fields) {
+        const metadata = getGeometryMetadataForField(field);
+        if (metadata) {
+            geometryColumns[field.name] = metadata;
+        }
     }
-  }
-  return geometryColumns;
+    return geometryColumns;
 }
+/**
+ * Extracts GeoArrow metadata from a field
+ * @param field
+ * @returns
+ * @see https://github.com/geoarrow/geoarrow/blob/d2f56704414d9ae71e8a5170a8671343ed15eefe/extension-types.md
+ */
 export function getGeometryMetadataForField(field) {
-  var _field$metadata, _field$metadata2;
-  let metadata = null;
-  let geoEncoding = (_field$metadata = field.metadata) === null || _field$metadata === void 0 ? void 0 : _field$metadata[GEOARROW_COLUMN_METADATA_ENCODING];
-  if (geoEncoding) {
-    geoEncoding = geoEncoding.toLowerCase();
-    if (geoEncoding === 'wkb') {
-      geoEncoding = 'geoarrow.wkb';
+    let metadata = null;
+    // Check for GeoArrow column encoding
+    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
+    if (geoEncoding) {
+        geoEncoding = geoEncoding.toLowerCase();
+        // at time of testing, ogr2ogr uses WKB/WKT for encoding.
+        if (geoEncoding === 'wkb') {
+            geoEncoding = 'geoarrow.wkb';
+        }
+        if (geoEncoding === 'wkt') {
+            geoEncoding = 'geoarrow.wkt';
+        }
+        if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+            // eslint-disable-next-line no-console
+            console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+        }
+        else {
+            metadata = metadata || {};
+            metadata.encoding = geoEncoding;
+        }
     }
-    if (geoEncoding === 'wkt') {
-      geoEncoding = 'geoarrow.wkt';
+    // Check for GeoArrow metadata
+    const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
+    if (columnMetadata) {
+        try {
+            metadata = JSON.parse(columnMetadata);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('Failed to parse GeoArrow metadata', error);
+        }
     }
-    if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
-      console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
-    } else {
-      metadata = metadata || {};
-      metadata.encoding = geoEncoding;
-    }
-  }
-  const columnMetadata = (_field$metadata2 = field.metadata) === null || _field$metadata2 === void 0 ? void 0 : _field$metadata2[GEOARROW_COLUMN_METADATA_METADATA];
-  if (columnMetadata) {
-    try {
-      metadata = JSON.parse(columnMetadata);
-    } catch (error) {
-      console.warn('Failed to parse GeoArrow metadata', error);
-    }
-  }
-  return metadata || null;
+    return metadata || null;
 }
-//# sourceMappingURL=geoarrow-metadata.js.map

package/dist/lib/geo/geoparquet-metadata-schema.js

@@ -1,76 +1,69 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/* eslint-disable camelcase */
+/**
+ * Geoparquet JSON schema for geo metadata
+ * @see https://github.com/geoarrow/geoarrow/blob/main/metadata.md
+ * @see https://github.com/opengeospatial/geoparquet/blob/main/format-specs/geoparquet.md
+ */
 export const GEOPARQUET_METADATA_JSON_SCHEMA = {
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'GeoParquet',
-  description: 'Parquet metadata included in the geo field.',
-  type: 'object',
-  required: ['version', 'primary_column', 'columns'],
-  properties: {
-    version: {
-      type: 'string',
-      const: '1.0.0-beta.1'
-    },
-    primary_column: {
-      type: 'string',
-      minLength: 1
-    },
-    columns: {
-      type: 'object',
-      minProperties: 1,
-      patternProperties: {
-        '.+': {
-          type: 'object',
-          required: ['encoding', 'geometry_types'],
-          properties: {
-            encoding: {
-              type: 'string',
-              const: 'WKB'
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    title: 'GeoParquet',
+    description: 'Parquet metadata included in the geo field.',
+    type: 'object',
+    required: ['version', 'primary_column', 'columns'],
+    properties: {
+        version: { type: 'string', const: '1.0.0-beta.1' },
+        primary_column: { type: 'string', minLength: 1 },
+        columns: {
+            type: 'object',
+            minProperties: 1,
+            patternProperties: {
+                '.+': {
+                    type: 'object',
+                    required: ['encoding', 'geometry_types'],
+                    properties: {
+                        encoding: { type: 'string', const: 'WKB' },
+                        geometry_types: {
+                            type: 'array',
+                            uniqueItems: true,
+                            items: {
+                                type: 'string',
+                                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'
+                            }
+                        },
+                        crs: {
+                            oneOf: [
+                                {
+                                    $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'
+                                },
+                                { type: 'null' }
+                            ]
+                        },
+                        edges: { type: 'string', enum: ['planar', 'spherical'] },
+                        orientation: { type: 'string', const: 'counterclockwise' },
+                        bbox: {
+                            type: 'array',
+                            items: { type: 'number' },
+                            oneOf: [
+                                {
+                                    description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',
+                                    minItems: 4,
+                                    maxItems: 4
+                                },
+                                {
+                                    description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',
+                                    minItems: 6,
+                                    maxItems: 6
+                                }
+                            ]
+                        },
+                        epoch: { type: 'number' }
+                    }
+                }
             },
-            geometry_types: {
-              type: 'array',
-              uniqueItems: true,
-              items: {
-                type: 'string',
-                pattern: '^(GeometryCollection|(Multi)?(Point|LineString|Polygon))( Z)?$'
-              }
-            },
-            crs: {
-              oneOf: [{
-                $ref: 'https://proj.org/schemas/v0.5/projjson.schema.json'
-              }, {
-                type: 'null'
-              }]
-            },
-            edges: {
-              type: 'string',
-              enum: ['planar', 'spherical']
-            },
-            orientation: {
-              type: 'string',
-              const: 'counterclockwise'
-            },
-            bbox: {
-              type: 'array',
-              items: {
-                type: 'number'
-              },
-              oneOf: [{
-                description: '2D bbox consisting of (xmin, ymin, xmax, ymax)',
-                minItems: 4,
-                maxItems: 4
-              }, {
-                description: '3D bbox consisting of (xmin, ymin, zmin, xmax, ymax, zmax)',
-                minItems: 6,
-                maxItems: 6
-              }]
-            },
-            epoch: {
-              type: 'number'
-            }
-          }
+            additionalProperties: false
         }
-      },
-      additionalProperties: false
     }
-  }
 };
-//# sourceMappingURL=geoparquet-metadata-schema.js.map