@loaders.gl/gis 4.0.0-alpha.4 → 4.0.0-alpha.6

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

@@ -1,407 +1,24 @@
-export function geojsonToBinary(features, options = {}) {
-  const firstPassData = firstPass(features);
-  return secondPass(features, firstPassData, {
-    coordLength: options.coordLength || firstPassData.coordLength,
-    numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,
-    PositionDataType: options.PositionDataType || Float32Array
-  });
-}
-export const TEST_EXPORTS = {
-  firstPass,
-  secondPass
-};
-
-function firstPass(features) {
-  let pointPositionsCount = 0;
-  let pointFeaturesCount = 0;
-  let linePositionsCount = 0;
-  let linePathsCount = 0;
-  let lineFeaturesCount = 0;
-  let polygonPositionsCount = 0;
-  let polygonObjectsCount = 0;
-  let polygonRingsCount = 0;
-  let polygonFeaturesCount = 0;
-  const coordLengths = new Set();
-  const numericPropKeys = {};
-
-  for (const feature of features) {
-    const geometry = feature.geometry;
-
-    switch (geometry.type) {
-      case 'Point':
-        pointFeaturesCount++;
-        pointPositionsCount++;
-        coordLengths.add(geometry.coordinates.length);
-        break;
-
-      case 'MultiPoint':
-        pointFeaturesCount++;
-        pointPositionsCount += geometry.coordinates.length;
-
-        for (const point of geometry.coordinates) {
-          coordLengths.add(point.length);
-        }
-
-        break;
-
-      case 'LineString':
-        lineFeaturesCount++;
-        linePositionsCount += geometry.coordinates.length;
-        linePathsCount++;
-
-        for (const coord of geometry.coordinates) {
-          coordLengths.add(coord.length);
-        }
-
-        break;
-
-      case 'MultiLineString':
-        lineFeaturesCount++;
-
-        for (const line of geometry.coordinates) {
-          linePositionsCount += line.length;
-          linePathsCount++;
-
-          for (const coord of line) {
-            coordLengths.add(coord.length);
-          }
-        }
-
-        break;
-
-      case 'Polygon':
-        polygonFeaturesCount++;
-        polygonObjectsCount++;
-        polygonRingsCount += geometry.coordinates.length;
-        polygonPositionsCount += flatten(geometry.coordinates).length;
-
-        for (const coord of flatten(geometry.coordinates)) {
-          coordLengths.add(coord.length);
-        }
-
-        break;
-
-      case 'MultiPolygon':
-        polygonFeaturesCount++;
-
-        for (const polygon of geometry.coordinates) {
-          polygonObjectsCount++;
-          polygonRingsCount += polygon.length;
-          polygonPositionsCount += flatten(polygon).length;
-
-          for (const coord of flatten(polygon)) {
-            coordLengths.add(coord.length);
-          }
-        }
-
-        break;
-
-      default:
-        throw new Error("Unsupported geometry type: ".concat(geometry.type));
-    }
-
-    if (feature.properties) {
-      for (const key in feature.properties) {
-        const val = feature.properties[key];
-        numericPropKeys[key] = numericPropKeys[key] || numericPropKeys[key] === undefined ? isNumeric(val) : numericPropKeys[key];
-      }
-    }
-  }
-
-  return {
-    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    polygonFeaturesCount,
-    numericPropKeys: Object.keys(numericPropKeys).filter(k => numericPropKeys[k])
-  };
-}
-
-function secondPass(features, firstPassData, options) {
-  const {
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    polygonFeaturesCount
-  } = firstPassData;
-  const {
-    coordLength,
-    numericPropKeys,
-    PositionDataType = Float32Array
-  } = options;
-  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-  const points = {
-    positions: new PositionDataType(pointPositionsCount * coordLength),
-    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-    featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
-    numericProps: {},
-    properties: Array(),
-    fields: Array()
-  };
-  const lines = {
-    positions: new PositionDataType(linePositionsCount * coordLength),
-    pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
-    globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-    featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
-    numericProps: {},
-    properties: Array(),
-    fields: Array()
-  };
-  const polygons = {
-    positions: new PositionDataType(polygonPositionsCount * coordLength),
-    polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
-    primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
-    globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-    featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
-    numericProps: {},
-    properties: Array(),
-    fields: Array()
-  };
-
-  for (const object of [points, lines, polygons]) {
-    for (const propName of numericPropKeys || []) {
-      object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
-    }
-  }
-
-  lines.pathIndices[linePathsCount] = linePositionsCount;
-  polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-  polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-  const indexMap = {
-    pointPosition: 0,
-    pointFeature: 0,
-    linePosition: 0,
-    linePath: 0,
-    lineFeature: 0,
-    polygonPosition: 0,
-    polygonObject: 0,
-    polygonRing: 0,
-    polygonFeature: 0,
-    feature: 0
-  };
-
-  for (const feature of features) {
-    const geometry = feature.geometry;
-    const properties = feature.properties || {};
-
-    switch (geometry.type) {
-      case 'Point':
-        handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);
-        points.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.pointFeature++;
-        break;
-
-      case 'MultiPoint':
-        handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);
-        points.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.pointFeature++;
-        break;
-
-      case 'LineString':
-        handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-        lines.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.lineFeature++;
-        break;
-
-      case 'MultiLineString':
-        handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-        lines.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.lineFeature++;
-        break;
-
-      case 'Polygon':
-        handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.polygonFeature++;
-        break;
-
-      case 'MultiPolygon':
-        handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-        polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-        indexMap.polygonFeature++;
-        break;
-
-      default:
-        throw new Error('Invalid geometry type');
-    }
-
-    indexMap.feature++;
-  }
-
-  return makeAccessorObjects(points, lines, polygons, coordLength);
-}
-
-function handlePoint(coords, points, indexMap, coordLength, properties) {
-  points.positions.set(coords, indexMap.pointPosition * coordLength);
-  points.globalFeatureIds[indexMap.pointPosition] = indexMap.feature;
-  points.featureIds[indexMap.pointPosition] = indexMap.pointFeature;
-  fillNumericProperties(points, properties, indexMap.pointPosition, 1);
-  indexMap.pointPosition++;
-}
-
-function handleMultiPoint(coords, points, indexMap, coordLength, properties) {
-  for (const point of coords) {
-    handlePoint(point, points, indexMap, coordLength, properties);
-  }
-}
-
-function handleLineString(coords, lines, indexMap, coordLength, properties) {
-  lines.pathIndices[indexMap.linePath] = indexMap.linePosition;
-  indexMap.linePath++;
-  fillCoords(lines.positions, coords, indexMap.linePosition, coordLength);
-  const nPositions = coords.length;
-  fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-  lines.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.linePosition);
-  lines.featureIds.set(new Uint32Array(nPositions).fill(indexMap.lineFeature), indexMap.linePosition);
-  indexMap.linePosition += nPositions;
-}
-
-function handleMultiLineString(coords, lines, indexMap, coordLength, properties) {
-  for (const line of coords) {
-    handleLineString(line, lines, indexMap, coordLength, properties);
-  }
-}
-
-function handlePolygon(coords, polygons, indexMap, coordLength, properties) {
-  polygons.polygonIndices[indexMap.polygonObject] = indexMap.polygonPosition;
-  indexMap.polygonObject++;
-
-  for (const ring of coords) {
-    polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;
-    indexMap.polygonRing++;
-    fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);
-    const nPositions = ring.length;
-    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-    polygons.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.polygonPosition);
-    polygons.featureIds.set(new Uint32Array(nPositions).fill(indexMap.polygonFeature), indexMap.polygonPosition);
-    indexMap.polygonPosition += nPositions;
-  }
-}
-
-function handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {
-  for (const polygon of coords) {
-    handlePolygon(polygon, polygons, indexMap, coordLength, properties);
-  }
-}
-
-function makeAccessorObjects(points, lines, polygons, coordLength) {
-  const returnObj = {
-    points: { ...points,
-      positions: {
-        value: points.positions,
-        size: coordLength
-      },
-      globalFeatureIds: {
-        value: points.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: points.featureIds,
-        size: 1
-      },
-      type: 'Point'
-    },
-    lines: { ...lines,
-      pathIndices: {
-        value: lines.pathIndices,
-        size: 1
-      },
-      positions: {
-        value: lines.positions,
-        size: coordLength
-      },
-      globalFeatureIds: {
-        value: lines.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: lines.featureIds,
-        size: 1
-      },
-      type: 'LineString'
-    },
-    polygons: { ...polygons,
-      polygonIndices: {
-        value: polygons.polygonIndices,
-        size: 1
-      },
-      primitivePolygonIndices: {
-        value: polygons.primitivePolygonIndices,
-        size: 1
-      },
-      positions: {
-        value: polygons.positions,
-        size: coordLength
-      },
-      globalFeatureIds: {
-        value: polygons.globalFeatureIds,
-        size: 1
-      },
-      featureIds: {
-        value: polygons.featureIds,
-        size: 1
-      },
-      type: 'Polygon'
-    }
-  };
-
-  for (const geomType in returnObj) {
-    for (const numericProp in returnObj[geomType].numericProps) {
-      returnObj[geomType].numericProps[numericProp] = {
-        value: returnObj[geomType].numericProps[numericProp],
-        size: 1
-      };
-    }
-  }
-
-  return returnObj;
-}
-
-function fillNumericProperties(object, properties, index, length) {
-  for (const numericPropName in object.numericProps) {
-    if (numericPropName in properties) {
-      object.numericProps[numericPropName].set(new Array(length).fill(properties[numericPropName]), index);
-    }
-  }
-}
-
-function keepStringProperties(properties, numericKeys) {
-  const props = {};
-
-  for (const key in properties) {
-    if (!numericKeys.includes(key)) {
-      props[key] = properties[key];
-    }
-  }
-
-  return props;
-}
-
-function fillCoords(array, coords, startVertex, coordLength) {
-  let index = startVertex * coordLength;
-
-  for (const coord of coords) {
-    array.set(coord, index);
-    index += coordLength;
-  }
-}
-
-function flatten(arrays) {
-  return [].concat(...arrays);
-}
-
-function isNumeric(x) {
-  return Number.isFinite(x);
-}
-//# sourceMappingURL=geojson-to-binary.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geojsonToBinary = void 0;
+const extract_geometry_info_1 = require("./extract-geometry-info");
+const geojson_to_flat_geojson_1 = require("./geojson-to-flat-geojson");
+const flat_geojson_to_binary_1 = require("./flat-geojson-to-binary");
+/**
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
+ */
+function geojsonToBinary(features, options = { fixRingWinding: true }) {
+    const geometryInfo = (0, extract_geometry_info_1.extractGeometryInfo)(features);
+    const coordLength = geometryInfo.coordLength;
+    const { fixRingWinding } = options;
+    const flatFeatures = (0, geojson_to_flat_geojson_1.geojsonToFlatGeojson)(features, { coordLength, fixRingWinding });
+    return (0, flat_geojson_to_binary_1.flatGeojsonToBinary)(flatFeatures, geometryInfo, {
+        numericPropKeys: options.numericPropKeys,
+        PositionDataType: options.PositionDataType || Float32Array
+    });
+}
+exports.geojsonToBinary = geojsonToBinary;

package/dist/lib/geojson-to-flat-geojson.d.ts

@@ -0,0 +1,17 @@
+import { Feature, FlatFeature } from '@loaders.gl/schema';
+/**
+ * Options for `geojsonToFlatGeojson`
+ */
+export type GeojsonToFlatGeojsonOptions = {
+    coordLength: number;
+    fixRingWinding: boolean;
+};
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+export declare function geojsonToFlatGeojson(features: Feature[], options?: GeojsonToFlatGeojsonOptions): FlatFeature[];
+//# sourceMappingURL=geojson-to-flat-geojson.d.ts.map

package/dist/lib/geojson-to-flat-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson-to-flat-geojson.d.ts","sourceRoot":"","sources":["../../src/lib/geojson-to-flat-geojson.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,OAAO,EAAY,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AASF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,2BAAoE,GAC5E,WAAW,EAAE,CAEf"}

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geojsonToFlatGeojson = void 0;
+const polygon_1 = require("@math.gl/polygon");
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+    return features.map((feature) => flattenFeature(feature, options));
+}
+exports.geojsonToFlatGeojson = geojsonToFlatGeojson;
+/**
+ * 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);
+    // 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);
+        // 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 = (0, polygon_1.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);
+    }
+}
+/**
+ * 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 } };
+}

package/dist/lib/transform.d.ts

@@ -0,0 +1,19 @@
+import type { BinaryFeatures } from '@loaders.gl/schema';
+type TransformCoordinate = (coord: number[]) => number[];
+/**
+ * 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 declare function transformBinaryCoords(binaryFeatures: BinaryFeatures, transformCoordinate: TransformCoordinate): BinaryFeatures;
+/**
+ * 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 declare function transformGeoJsonCoords(features: object[], fn: (coord: number[]) => number[]): object[];
+export {};
+//# sourceMappingURL=transform.d.ts.map

package/dist/lib/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../src/lib/transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,cAAc,EAAiB,MAAM,oBAAoB,CAAC;AAEvE,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,cAAc,EAC9B,mBAAmB,EAAE,mBAAmB,GACvC,cAAc,CAWhB;AAcD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAAE,EAClB,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAChC,MAAM,EAAE,CAMV"}