@loaders.gl/gis 4.3.4 → 4.4.0-alpha.10

package/src/lib/{binary-features/binary-to-geojson.ts → feature-collection-converters/convert-binary-features-to-geojson.ts}

@@ -3,30 +3,18 @@
 // Copyright (c) vis.gl contributors
 
 import type {
-  BinaryGeometry,
   BinaryGeometryType,
-  BinaryPointGeometry,
-  BinaryLineGeometry,
-  BinaryPolygonGeometry,
   BinaryFeatureCollection,
   BinaryFeature,
   // BinaryPointFeature,
   // BinaryLineFeature,
   // BinaryPolygonFeature,
-  BinaryAttribute,
   Feature,
-  Geometry,
-  Position,
-  GeoJsonProperties,
-  Point,
-  MultiPoint,
-  LineString,
-  MultiLineString,
-  Polygon,
-  MultiPolygon
+  GeoJsonProperties
 } from '@loaders.gl/schema';
+import {convertBinaryGeometryToGeometry} from '../geometry-converters/convert-binary-geometry-to-geojson';
 
-// Note:L We do not handle GeometryCollection, define a limited Geometry type that always has coordinates.
+// Note: We do not handle GeometryCollection, define a limited Geometry type that always has coordinates.
 // type FeatureGeometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon;
 
 type BinaryToGeoJsonOptions = {
@@ -42,7 +30,7 @@ type BinaryToGeoJsonOptions = {
  * @param options.featureId  Global feature id. If specified, only a single feature is extracted
  * @return GeoJSON objects
  */
-export function binaryToGeojson(
+export function convertBinaryFeatureCollectionToGeojson(
   data: BinaryFeatureCollection,
   options?: BinaryToGeoJsonOptions
 ): Feature[] | Feature {
@@ -91,25 +79,6 @@ function parseFeatures(data: BinaryFeatureCollection, type?: BinaryGeometryType)
   return parseFeatureCollection(dataArray);
 }
 
-/** Parse input binary data and return a valid GeoJSON geometry object */
-export function binaryToGeometry(
-  data: BinaryGeometry,
-  startIndex?: number,
-  endIndex?: number
-): Geometry {
-  switch (data.type) {
-    case 'Point':
-      return pointToGeoJson(data, startIndex, endIndex);
-    case 'LineString':
-      return lineStringToGeoJson(data, startIndex, endIndex);
-    case 'Polygon':
-      return polygonToGeoJson(data, startIndex, endIndex);
-    default:
-      const unexpectedInput: never = data;
-      throw new Error(`Unsupported geometry type: ${(unexpectedInput as any)?.type}`);
-  }
-}
-
 // Normalize features
 // Return an array of data objects, each of which have a type key
 function normalizeInput(data: BinaryFeatureCollection, type?: BinaryGeometryType): BinaryFeature[] {
@@ -162,7 +131,7 @@ function parseFeatureCollection(dataArray: BinaryFeature[]): Feature[] {
 
 /** Parse input binary data and return a single GeoJSON Feature */
 function parseFeature(data: BinaryFeature, startIndex?: number, endIndex?: number): Feature {
-  const geometry = binaryToGeometry(data, startIndex, endIndex);
+  const geometry = convertBinaryGeometryToGeometry(data, startIndex, endIndex);
   const properties = parseProperties(data, startIndex, endIndex);
   const fields = parseFields(data, startIndex, endIndex);
   return {type: 'Feature', geometry, properties, ...fields};
@@ -181,109 +150,3 @@ function parseProperties(data, startIndex: number = 0, endIndex?: number): GeoJs
   }
   return properties;
 }
-
-/** Parse binary data of type Polygon */
-function polygonToGeoJson(
-  data: BinaryPolygonGeometry,
-  startIndex: number = -Infinity,
-  endIndex: number = Infinity
-): Polygon | MultiPolygon {
-  const {positions} = data;
-  const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-  const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
-    (x) => x >= startIndex && x <= endIndex
-  );
-  const multi = polygonIndices.length > 2;
-
-  // Polygon
-  if (!multi) {
-    const coordinates: Position[][] = [];
-    for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-      const startRingIndex = primitivePolygonIndices[i];
-      const endRingIndex = primitivePolygonIndices[i + 1];
-      const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-      coordinates.push(ringCoordinates);
-    }
-
-    return {type: 'Polygon', coordinates};
-  }
-
-  // MultiPolygon
-  const coordinates: Position[][][] = [];
-  for (let i = 0; i < polygonIndices.length - 1; i++) {
-    const startPolygonIndex = polygonIndices[i];
-    const endPolygonIndex = polygonIndices[i + 1];
-    const polygonCoordinates = polygonToGeoJson(
-      data,
-      startPolygonIndex,
-      endPolygonIndex
-    ).coordinates;
-    coordinates.push(polygonCoordinates as Position[][]);
-  }
-
-  return {type: 'MultiPolygon', coordinates};
-}
-
-/** Parse binary data of type LineString */
-function lineStringToGeoJson(
-  data: BinaryLineGeometry,
-  startIndex: number = -Infinity,
-  endIndex: number = Infinity
-): LineString | MultiLineString {
-  const {positions} = data;
-  const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-  const multi = pathIndices.length > 2;
-
-  if (!multi) {
-    const coordinates = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-    return {type: 'LineString', coordinates};
-  }
-
-  const coordinates: Position[][] = [];
-  for (let i = 0; i < pathIndices.length - 1; i++) {
-    const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-    coordinates.push(ringCoordinates);
-  }
-
-  return {type: 'MultiLineString', coordinates};
-}
-
-/** Parse binary data of type Point */
-function pointToGeoJson(data: BinaryPointGeometry, startIndex, endIndex): Point | MultiPoint {
-  const {positions} = data;
-  const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-  const multi = coordinates.length > 1;
-
-  if (multi) {
-    return {type: 'MultiPoint', coordinates};
-  }
-
-  return {type: 'Point', coordinates: coordinates[0]};
-}
-
-/**
- * Parse a linear ring of positions to a GeoJSON linear ring
- *
- * @param positions Positions TypedArray
- * @param startIndex Start index to include in ring
- * @param endIndex End index to include in ring
- * @returns GeoJSON ring
- */
-function ringToGeoJson(
-  positions: BinaryAttribute,
-  startIndex?: number,
-  endIndex?: number
-): Position[] {
-  startIndex = startIndex || 0;
-  endIndex = endIndex || positions.value.length / positions.size;
-
-  const ringCoordinates: Position[] = [];
-  for (let j = startIndex; j < endIndex; j++) {
-    const coord = Array<number>();
-    for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-      coord.push(Number(positions.value[k]));
-    }
-    ringCoordinates.push(coord);
-  }
-  return ringCoordinates;
-}

package/src/lib/{binary-features/flat-geojson-to-binary.ts → feature-collection-converters/convert-flat-geojson-to-binary-features.ts}

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 /* eslint-disable indent */
 import {earcut} from '@math.gl/polygon';
 import type {
@@ -8,10 +12,15 @@ import type {
   FlatPoint,
   FlatLineString,
   FlatPolygon,
-  GeojsonGeometryInfo,
   TypedArray
 } from '@loaders.gl/schema';
-import {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-binary-types';
+import {GeojsonGeometryInfo} from '../geometry-api/geometry-info';
+import {
+  PropArrayConstructor,
+  Lines,
+  Points,
+  Polygons
+} from './helpers/flat-geojson-to-binary-types';
 
 /**
  * Convert binary features to flat binary arrays. Similar to
@@ -26,11 +35,11 @@ import {PropArrayConstructor, Lines, Points, Polygons} from './flat-geojson-to-b
  * @param options
  * @returns filled arrays
  */
-export function flatGeojsonToBinary(
+export function convertFlatGeojsonToBinaryFeatureCollection(
   features: FlatFeature[],
   geometryInfo: GeojsonGeometryInfo,
   options?: FlatGeojsonToBinaryOptions
-) {
+): BinaryFeatureCollection {
   const propArrayTypes = extractNumericPropTypes(features);
   const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
   return fillArrays(
@@ -56,17 +65,13 @@ export type FlatGeojsonToBinaryOptions = {
   triangulate?: boolean;
 };
 
-export const TEST_EXPORTS = {
-  extractNumericPropTypes
-};
-
 /**
  * Extracts properties that are always numeric
  *
  * @param features
  * @returns object with numeric types
  */
-function extractNumericPropTypes(features: FlatFeature[]): {
+export function extractNumericPropTypes(features: FlatFeature[]): {
   [key: string]: PropArrayConstructor;
 } {
   const propArrayTypes = {};