@loaders.gl/gis 3.1.0 → 3.1.1

package/src/lib/geojson-to-binary.ts

@@ -1,471 +1,36 @@
-import {Feature, GeoJsonProperties} from '@loaders.gl/schema';
+import type {Feature} from '@loaders.gl/schema';
 import type {BinaryFeatures} from '@loaders.gl/schema';
 
+import {extractGeometryInfo} from './extract-geometry-info';
+import {geojsonToFlatGeojson} from './geojson-to-flat-geojson';
+import {flatGeojsonToBinary} from './flat-geojson-to-binary';
+
+/**
+ * Options for `geojsonToBinary`
+ */
 export type GeojsonToBinaryOptions = {
-  coordLength?: number;
+  fixRingWinding: boolean;
   numericPropKeys?: string[];
-  PositionDataType?: Function;
+  PositionDataType?: Float32ArrayConstructor | Float64ArrayConstructor;
 };
 
-/** Convert GeoJSON features to flat binary arrays */
+/**
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
+ */
 export function geojsonToBinary(
   features: Feature[],
-  options: GeojsonToBinaryOptions = {}
+  options: GeojsonToBinaryOptions = {fixRingWinding: true}
 ): BinaryFeatures {
-  const firstPassData = firstPass(features);
-  return secondPass(features, firstPassData, {
-    coordLength: options.coordLength || firstPassData.coordLength,
-    numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,
+  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
   });
 }
-
-export const TEST_EXPORTS = {
-  firstPass,
-  secondPass
-};
-
-type PropArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor | ArrayConstructor;
-
-type FirstPassData = {
-  coordLength: number;
-  numericPropKeys: string[];
-  propArrayTypes: {[key: string]: PropArrayConstructor};
-
-  pointPositionsCount: number;
-  pointFeaturesCount: number;
-  linePositionsCount: number;
-  linePathsCount: number;
-  lineFeaturesCount: number;
-  polygonPositionsCount: number;
-  polygonObjectsCount: number;
-  polygonRingsCount: number;
-  polygonFeaturesCount: number;
-};
-
-/**
- *  Initial scan over GeoJSON features
- *  Counts number of coordinates of each geometry type and
- *  keeps track of the max coordinate dimensions
- */
-// eslint-disable-next-line complexity, max-statements
-function firstPass(features: Feature[]): FirstPassData {
-  // Counts the number of _positions_, so [x, y, z] counts as one
-  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<number>();
-  const propArrayTypes = {};
-
-  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++;
-
-          // eslint-disable-next-line max-depth
-          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;
-
-          // eslint-disable-next-line max-depth
-          for (const coord of flatten(polygon)) {
-            coordLengths.add(coord.length);
-          }
-        }
-        break;
-      default:
-        throw new Error(`Unsupported geometry type: ${geometry.type}`);
-    }
-
-    if (feature.properties) {
-      for (const key in feature.properties) {
-        const val = feature.properties[key];
-
-        // If property has not been seen before, or if property has been numeric
-        // in all previous features, check if numeric in this feature
-        // If not numeric, Array is stored to prevent rechecking in the future
-        // Additionally, detects if 64 bit precision is required
-        propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
-      }
-    }
-  }
-
-  return {
-    coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
-
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    polygonFeaturesCount,
-
-    // Array of keys whose values are always numeric
-    numericPropKeys: Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array),
-    propArrayTypes
-  };
-}
-
-/**
- * Second scan over GeoJSON features
- * Fills coordinates into pre-allocated typed arrays
- */
-// eslint-disable-next-line complexity
-function secondPass(
-  features,
-  firstPassData: FirstPassData,
-  options: Required<GeojsonToBinaryOptions>
-) {
-  const {
-    pointPositionsCount,
-    pointFeaturesCount,
-    linePositionsCount,
-    linePathsCount,
-    lineFeaturesCount,
-    polygonPositionsCount,
-    polygonObjectsCount,
-    polygonRingsCount,
-    propArrayTypes,
-    polygonFeaturesCount
-  } = firstPassData;
-  const {coordLength, numericPropKeys, PositionDataType = Float32Array} = options;
-  const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-  const points = {
-    // @ts-ignore Typescript doesn't like dynamic constructors
-    positions: new PositionDataType(pointPositionsCount * coordLength),
-    globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-    featureIds:
-      pointFeaturesCount > 65535
-        ? new Uint32Array(pointPositionsCount)
-        : new Uint16Array(pointPositionsCount),
-    numericProps: {},
-    properties: Array<any>(),
-    fields: Array<any>()
-  };
-  const lines = {
-    // @ts-ignore Typescript doesn't like dynamic constructors
-    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<any>(),
-    fields: Array<any>()
-  };
-  const polygons = {
-    // @ts-ignore Typescript doesn't like dynamic constructors
-    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<any>(),
-    fields: Array<any>()
-  };
-
-  // Instantiate numeric properties arrays; one value per vertex
-  for (const object of [points, lines, polygons]) {
-    for (const propName of numericPropKeys || []) {
-      // If property has been numeric in all previous features in which the property existed, check
-      // if numeric in this feature
-      const TypedArray = propArrayTypes[propName];
-      object.numericProps[propName] = new TypedArray(object.positions.length / coordLength);
-    }
-  }
-
-  // Set last element of path/polygon indices as positions length
-  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: GeoJsonProperties = 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++;
-  }
-
-  // Wrap each array in an accessor object with value and size keys
-  return makeAccessorObjects(points, lines, polygons, coordLength);
-}
-
-/** Fills Point coordinates into points object of arrays */
-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++;
-}
-
-/** Fills MultiPoint coordinates into points object of arrays */
-function handleMultiPoint(coords, points, indexMap, coordLength, properties) {
-  for (const point of coords) {
-    handlePoint(point, points, indexMap, coordLength, properties);
-  }
-}
-
-/** Fills LineString coordinates into lines object of arrays */
-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;
-}
-
-/** Fills MultiLineString coordinates into lines object of arrays */
-function handleMultiLineString(coords, lines, indexMap, coordLength, properties) {
-  for (const line of coords) {
-    handleLineString(line, lines, indexMap, coordLength, properties);
-  }
-}
-
-/** Fills Polygon coordinates into polygons object of arrays */
-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;
-  }
-}
-
-/** Fills MultiPolygon coordinates into polygons object of arrays */
-function handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {
-  for (const polygon of coords) {
-    handlePolygon(polygon, polygons, indexMap, coordLength, properties);
-  }
-}
-
-/** Wrap each array in an accessor object with value and size keys */
-function makeAccessorObjects(points, lines, polygons, coordLength): BinaryFeatures {
-  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 as unknown as BinaryFeatures;
-}
-
-/** Add numeric properties to object */
-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
-      );
-    }
-  }
-}
-
-/** Keep string properties in object */
-function keepStringProperties(properties, numericKeys: string[]): GeoJsonProperties {
-  const props = {};
-  for (const key in properties) {
-    if (!numericKeys.includes(key)) {
-      props[key] = properties[key];
-    }
-  }
-  return props;
-}
-
-/** @param coords is expected to be a list of arrays, each with length 2-3 */
-function fillCoords(array, coords, startVertex, coordLength): void {
-  let index = startVertex * coordLength;
-  for (const coord of coords) {
-    array.set(coord, index);
-    index += coordLength;
-  }
-}
-
-// TODO - how does this work? Different `coordinates` have different nesting
-function flatten(arrays): number[][] {
-  return [].concat(...arrays);
-}
-
-function deduceArrayType(x: any, constructor: PropArrayConstructor): PropArrayConstructor {
-  if (constructor === Array || !Number.isFinite(x)) {
-    return Array;
-  }
-
-  // If this or previous value required 64bits use Float64Array
-  return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
-}

package/src/lib/geojson-to-flat-geojson.ts

@@ -0,0 +1,171 @@
+import {getPolygonSignedArea} from '@math.gl/polygon';
+
+import {Feature, Position, FlatFeature} from '@loaders.gl/schema';
+
+/**
+ * Options for `geojsonToFlatGeojson`
+ */
+export type GeojsonToFlatGeojsonOptions = {
+  coordLength: number;
+  fixRingWinding: boolean;
+};
+
+// Coordinates defining a Point
+type PointCoordinates = Position;
+// Coordinates defining a LineString
+type LineStringCoordinates = Position[];
+// Coordinates defining a Polygon
+type PolygonCoordinates = Position[][];
+
+/**
+ * Convert GeoJSON features to Flat GeoJSON features
+ *
+ * @param features
+ * @param options
+ * @returns an Array of Flat GeoJSON features
+ */
+export function geojsonToFlatGeojson(
+  features: Feature[],
+  options: GeojsonToFlatGeojsonOptions = {coordLength: 2, fixRingWinding: true}
+): FlatFeature[] {
+  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: PointCoordinates,
+  data: number[],
+  indices: number[],
+  options: GeojsonToFlatGeojsonOptions
+) {
+  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: LineStringCoordinates,
+  data: number[],
+  indices: number[],
+  options: GeojsonToFlatGeojsonOptions
+) {
+  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: PolygonCoordinates,
+  data: number[],
+  indices: number[][],
+  areas: number[][],
+  options: GeojsonToFlatGeojsonOptions
+) {
+  let count = 0;
+  const ringAreas: number[] = [];
+  const polygons: number[] = [];
+  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);
+  }
+}
+
+/**
+ * Flatten single GeoJSON feature into Flat GeoJSON
+ *
+ * @param feature
+ * @param options
+ * @returns A Flat GeoJSON feature
+ */
+function flattenFeature(feature: Feature, options: GeojsonToFlatGeojsonOptions): FlatFeature {
+  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}};
+}