@loaders.gl/gis 4.3.2 → 4.4.0-alpha.1

package/dist/lib/feature-collection-converters/convert-geoarrow-to-binary-features.js

@@ -0,0 +1,377 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { earcut } from '@math.gl/polygon';
+import { updateBoundsFromGeoArrowSamples } from '@loaders.gl/geoarrow';
+/**
+ * Binary geometry type
+ */
+var BinaryGeometryType;
+(function (BinaryGeometryType) {
+    BinaryGeometryType["points"] = "points";
+    BinaryGeometryType["lines"] = "lines";
+    BinaryGeometryType["polygons"] = "polygons";
+})(BinaryGeometryType || (BinaryGeometryType = {}));
+/**
+ * get binary geometries from geoarrow column
+ *
+ * @param geoColumn the geoarrow column, e.g. arrowTable.getChildAt(geoColumnIndex)
+ * @param geoEncoding the geo encoding of the geoarrow column, e.g. getGeoArrowEncoding(arrowTable.schema, geoColumnName)
+ * @param options options for getting binary geometries {meanCenter: boolean}
+ * @returns BinaryDataFromGeoArrow
+ */
+export function convertGeoArrowToBinaryFeatureCollection(geoColumn, geoEncoding, options) {
+    const featureTypes = {
+        polygon: geoEncoding === 'geoarrow.multipolygon' || geoEncoding === 'geoarrow.polygon',
+        point: geoEncoding === 'geoarrow.multipoint' || geoEncoding === 'geoarrow.point',
+        line: geoEncoding === 'geoarrow.multilinestring' || geoEncoding === 'geoarrow.linestring'
+    };
+    const chunks = options?.chunkIndex !== undefined && options?.chunkIndex >= 0
+        ? [geoColumn.data[options?.chunkIndex]]
+        : geoColumn.data;
+    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    let globalFeatureIdOffset = options?.chunkOffset || 0;
+    const binaryGeometries = [];
+    chunks.forEach((chunk) => {
+        const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
+        const globalFeatureIds = new Uint32Array(featureIds.length);
+        for (let i = 0; i < featureIds.length; i++) {
+            globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
+        }
+        const binaryContent = {
+            globalFeatureIds: { value: globalFeatureIds, size: 1 },
+            positions: {
+                value: flatCoordinateArray,
+                size: nDim
+            },
+            featureIds: { value: featureIds, size: 1 },
+            // eslint-disable-next-line no-loop-func
+            properties: [...Array(chunk.length).keys()].map((i) => ({
+                index: i + globalFeatureIdOffset
+            }))
+        };
+        // TODO: check if chunks are sequentially accessed
+        globalFeatureIdOffset += chunk.length;
+        // NOTE: deck.gl defines the BinaryFeatureCollection structure must have points, lines, polygons even if they are empty
+        binaryGeometries.push({
+            shape: 'binary-feature-collection',
+            points: {
+                type: 'Point',
+                ...getBinaryGeometryTemplate(),
+                ...(featureTypes.point ? binaryContent : {})
+            },
+            lines: {
+                type: 'LineString',
+                ...getBinaryGeometryTemplate(),
+                ...(featureTypes.line ? binaryContent : {}),
+                pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
+            },
+            polygons: {
+                type: 'Polygon',
+                ...getBinaryGeometryTemplate(),
+                ...(featureTypes.polygon ? binaryContent : {}),
+                polygonIndices: {
+                    // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
+                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+                    size: 1
+                },
+                primitivePolygonIndices: {
+                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+                    size: 1
+                },
+                ...(triangles ? { triangles: { value: triangles, size: 1 } } : {})
+            }
+        });
+        bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+    });
+    return {
+        binaryGeometries,
+        bounds,
+        featureTypes,
+        ...(options?.calculateMeanCenters
+            ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) }
+            : {})
+    };
+}
+/**
+ * binary geometry template, see deck.gl BinaryGeometry
+ */
+export function getBinaryGeometryTemplate() {
+    return {
+        globalFeatureIds: { value: new Uint32Array(0), size: 1 },
+        positions: { value: new Float32Array(0), size: 2 },
+        properties: [],
+        numericProps: {},
+        featureIds: { value: new Uint32Array(0), size: 1 }
+    };
+}
+/**
+ * Get mean centers from binary geometries
+ * @param binaryGeometries binary geometries from geoarrow column, an array of BinaryFeatureCollection
+ * @returns mean centers of the binary geometries
+ */
+export function getMeanCentersFromBinaryGeometries(binaryGeometries) {
+    const globalMeanCenters = [];
+    binaryGeometries.forEach((binaryGeometry) => {
+        let binaryGeometryType = null;
+        if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
+            binaryGeometryType = BinaryGeometryType.points;
+        }
+        else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
+            binaryGeometryType = BinaryGeometryType.lines;
+        }
+        else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
+            binaryGeometryType = BinaryGeometryType.polygons;
+        }
+        const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
+        if (binaryContent && binaryGeometryType !== null) {
+            const featureIds = binaryContent.featureIds.value;
+            const flatCoordinateArray = binaryContent.positions.value;
+            const nDim = binaryContent.positions.size;
+            const primitivePolygonIndices = binaryContent.type === 'Polygon' ? binaryContent.primitivePolygonIndices?.value : undefined;
+            const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
+            meanCenters.forEach((center) => {
+                globalMeanCenters.push(center);
+            });
+        }
+    });
+    return globalMeanCenters;
+}
+/**
+ * Get mean centers from raw coordinates and feature ids
+ * @param featureIds Array of feature ids indexes by vertex
+ * @param flatCoordinateArray  Array of vertex, e.g. x, y or x, y, z, positions
+ * @param nDim number of dimensions per position
+ * @returns - mean centers of each polygon
+ */
+function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
+    const meanCenters = [];
+    const vertexCount = flatCoordinateArray.length;
+    let vertexIndex = 0;
+    let coordIdx = 0;
+    let primitiveIdx = 0;
+    while (vertexIndex < vertexCount) {
+        const featureId = featureIds[vertexIndex / nDim];
+        const center = [0, 0];
+        let vertexCountInFeature = 0;
+        while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
+            if (geometryType === BinaryGeometryType.polygons &&
+                primitivePolygonIndices?.[primitiveIdx] === coordIdx) {
+                // skip the first point since it is the same as the last point in each ring for polygons
+                vertexIndex += nDim;
+                primitiveIdx++;
+            }
+            else {
+                center[0] += flatCoordinateArray[vertexIndex];
+                center[1] += flatCoordinateArray[vertexIndex + 1];
+                vertexIndex += nDim;
+                vertexCountInFeature++;
+            }
+            coordIdx += 1;
+        }
+        center[0] /= vertexCountInFeature;
+        center[1] /= vertexCountInFeature;
+        meanCenters.push(center);
+    }
+    return meanCenters;
+}
+/**
+ * get binary geometries from geoarrow column
+ * @param chunk one chunk/batch of geoarrow column
+ * @param geoEncoding geo encoding of the geoarrow column
+ * @param options options for getting binary geometries
+ * @returns BinaryGeometryContent
+ */
+function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
+    switch (geoEncoding) {
+        case 'geoarrow.point':
+        case 'geoarrow.multipoint':
+            return getBinaryPointsFromChunk(chunk, geoEncoding);
+        case 'geoarrow.linestring':
+        case 'geoarrow.multilinestring':
+            return getBinaryLinesFromChunk(chunk, geoEncoding);
+        case 'geoarrow.polygon':
+        case 'geoarrow.multipolygon':
+            return getBinaryPolygonsFromChunk(chunk, geoEncoding, options);
+        default:
+            throw Error('invalid geoarrow encoding');
+    }
+}
+/**
+ * get triangle indices. Allows deck.gl to skip performing costly triangulation on main thread.
+ * @param polygonIndices Indices within positions of the start of each simple Polygon
+ * @param primitivePolygonIndices Indices within positions of the start of each primitive Polygon/ring
+ * @param flatCoordinateArray Array of x, y or x, y, z positions
+ * @param nDim - number of dimensions per position
+ * @returns triangle indices or null if invalid polygon and earcut fails
+ */
+export function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
+    try {
+        let primitiveIndex = 0;
+        const triangles = [];
+        // loop polygonIndices to get triangles
+        for (let i = 0; i < polygonIndices.length - 1; i++) {
+            const startIdx = polygonIndices[i];
+            const endIdx = polygonIndices[i + 1];
+            // get subarray of flatCoordinateArray
+            const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
+            // get holeIndices for earcut
+            const holeIndices = [];
+            while (primitivePolygonIndices[primitiveIndex] < endIdx) {
+                if (primitivePolygonIndices[primitiveIndex] > startIdx) {
+                    holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+                }
+                primitiveIndex++;
+            }
+            // TODO check if each ring is closed
+            const triangleIndices = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : undefined, nDim);
+            if (triangleIndices.length === 0) {
+                throw Error('earcut failed e.g. invalid polygon');
+            }
+            for (let j = 0; j < triangleIndices.length; j++) {
+                triangles.push(triangleIndices[j] + startIdx);
+            }
+        }
+        // convert traingles to Uint32Array
+        const trianglesUint32 = new Uint32Array(triangles.length);
+        for (let i = 0; i < triangles.length; i++) {
+            trianglesUint32[i] = triangles[i];
+        }
+        return trianglesUint32;
+    }
+    catch (error) {
+        // if earcut fails, return null
+        return null;
+    }
+}
+/**
+ * get binary polygons from geoarrow polygon column
+ * @param chunk one chunk of geoarrow polygon column
+ * @param geoEncoding the geo encoding of the geoarrow polygon column
+ * @param options options for getting binary geometries
+ * @returns BinaryGeometryContent
+ */
+function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
+    const isMultiPolygon = geoEncoding === 'geoarrow.multipolygon';
+    const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+    const polygonOffset = polygonData.valueOffsets;
+    const partData = isMultiPolygon
+        ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i)
+        : chunk.valueOffsets;
+    const ringData = polygonData.children[0];
+    const pointData = ringData.children[0];
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const geomOffset = ringData.valueOffsets;
+    const flatCoordinateArray = coordData.values;
+    const geometryIndexes = new Uint16Array(polygonOffset.length);
+    for (let i = 0; i < polygonOffset.length; i++) {
+        geometryIndexes[i] = geomOffset[polygonOffset[i]];
+    }
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    for (let i = 0; i < partData.length - 1; i++) {
+        const startIdx = geomOffset[partData[i]];
+        const endIdx = geomOffset[partData[i + 1]];
+        for (let j = startIdx; j < endIdx; j++) {
+            featureIds[j] = i;
+        }
+    }
+    const triangles = options?.triangulate
+        ? getTriangleIndices(geometryIndexes, geomOffset, flatCoordinateArray, nDim)
+        : null;
+    return {
+        featureIds,
+        nDim,
+        flatCoordinateArray,
+        geomOffset,
+        geometryIndexes,
+        ...(options?.triangulate && triangles ? { triangles } : {})
+    };
+}
+/**
+ * get binary lines from geoarrow line column
+ * @param chunk one chunk/batch of geoarrow column
+ * @param geoEncoding the geo encoding of the geoarrow column
+ * @returns BinaryGeometryContent
+ */
+function getBinaryLinesFromChunk(chunk, geoEncoding) {
+    const isMultiLineString = geoEncoding === 'geoarrow.multilinestring';
+    const lineData = isMultiLineString ? chunk.children[0] : chunk;
+    const pointData = lineData.children[0];
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const geomOffset = lineData.valueOffsets;
+    const flatCoordinateArray = coordData.values;
+    // geometryIndexes is not needed for line string
+    const geometryIndexes = new Uint16Array(0);
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    if (isMultiLineString) {
+        const partData = chunk.valueOffsets;
+        for (let i = 0; i < partData.length - 1; i++) {
+            const startIdx = geomOffset[partData[i]];
+            const endIdx = geomOffset[partData[i + 1]];
+            for (let j = startIdx; j < endIdx; j++) {
+                featureIds[j] = i;
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < chunk.length; i++) {
+            const startIdx = geomOffset[i];
+            const endIdx = geomOffset[i + 1];
+            for (let j = startIdx; j < endIdx; j++) {
+                featureIds[j] = i;
+            }
+        }
+    }
+    return {
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        geomOffset,
+        geometryIndexes
+    };
+}
+/**
+ * get binary points from geoarrow point column
+ * @param chunk one chunk/batch of geoarrow column
+ * @param geoEncoding  geo encoding of the geoarrow column
+ * @returns BinaryGeometryContent
+ */
+function getBinaryPointsFromChunk(chunk, geoEncoding) {
+    const isMultiPoint = geoEncoding === 'geoarrow.multipoint';
+    const pointData = isMultiPoint ? chunk.children[0] : chunk;
+    const coordData = pointData.children[0];
+    const nDim = pointData.stride;
+    const flatCoordinateArray = coordData.values;
+    // geometryIndices is not needed for point
+    const geometryIndexes = new Uint16Array(0);
+    // geomOffset is not needed for point
+    const geomOffset = new Int32Array(0);
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const featureIds = new Uint32Array(numOfVertices);
+    if (isMultiPoint) {
+        const partData = chunk.valueOffsets;
+        for (let i = 0; i < partData.length - 1; i++) {
+            const startIdx = partData[i];
+            const endIdx = partData[i + 1];
+            for (let j = startIdx; j < endIdx; j++) {
+                featureIds[j] = i;
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < chunk.length; i++) {
+            featureIds[i] = i;
+        }
+    }
+    return {
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        geomOffset,
+        geometryIndexes
+    };
+}

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

@@ -15,5 +15,5 @@ export type GeojsonToBinaryOptions = {
  * @param options
  * @returns features in binary format, grouped by geometry type
  */
-export declare function geojsonToBinary(features: Feature[], options?: GeojsonToBinaryOptions): BinaryFeatureCollection;
-//# sourceMappingURL=geojson-to-binary.d.ts.map
+export declare function convertGeojsonToBinaryFeatureCollection(features: Feature[], options?: GeojsonToBinaryOptions): BinaryFeatureCollection;
+//# sourceMappingURL=convert-geojson-to-binary-features.d.ts.map

package/dist/lib/feature-collection-converters/convert-geojson-to-binary-features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geojson-to-binary-features.d.ts","sourceRoot":"","sources":["../../../src/lib/feature-collection-converters/convert-geojson-to-binary-features.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAE,uBAAuB,EAAC,MAAM,oBAAoB,CAAC;AAMzE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,sBAAkE,GAC1E,uBAAuB,CAUzB"}

package/dist/lib/feature-collection-converters/convert-geojson-to-binary-features.js

@@ -0,0 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getGeometryInfo } from "../geometry-api/geometry-info.js";
+import { convertGeojsonToFlatGeojson } from "./convert-geojson-to-flat-geojson.js";
+import { convertFlatGeojsonToBinaryFeatureCollection } from "./convert-flat-geojson-to-binary-features.js";
+/**
+ * Convert GeoJSON features to flat binary arrays
+ *
+ * @param features
+ * @param options
+ * @returns features in binary format, grouped by geometry type
+ */
+export function convertGeojsonToBinaryFeatureCollection(features, options = { fixRingWinding: true, triangulate: true }) {
+    const geometryInfo = getGeometryInfo(features);
+    const coordLength = geometryInfo.coordLength;
+    const { fixRingWinding } = options;
+    const flatFeatures = convertGeojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+    return convertFlatGeojsonToBinaryFeatureCollection(flatFeatures, geometryInfo, {
+        numericPropKeys: options.numericPropKeys,
+        PositionDataType: options.PositionDataType || Float32Array,
+        triangulate: options.triangulate
+    });
+}

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

@@ -13,5 +13,5 @@ export type GeojsonToFlatGeojsonOptions = {
  * @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
+export declare function convertGeojsonToFlatGeojson(features: Feature[], options?: GeojsonToFlatGeojsonOptions): FlatFeature[];
+//# sourceMappingURL=convert-geojson-to-flat-geojson.d.ts.map

package/dist/lib/feature-collection-converters/convert-geojson-to-flat-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geojson-to-flat-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/feature-collection-converters/convert-geojson-to-flat-geojson.ts"],"names":[],"mappings":"AAMA,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,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,2BAAoE,GAC5E,WAAW,EAAE,CAEf"}

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

@@ -1,3 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { getPolygonSignedArea } from '@math.gl/polygon';
 /**
  * Convert GeoJSON features to Flat GeoJSON features
@@ -6,7 +9,7 @@ import { getPolygonSignedArea } from '@math.gl/polygon';
  * @param options
  * @returns an Array of Flat GeoJSON features
  */
-export function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+export function convertGeojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
     return features.map((feature) => flattenFeature(feature, options));
 }
 /**

package/dist/lib/feature-collection-converters/helpers/flat-geojson-to-binary-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flat-geojson-to-binary-types.d.ts","sourceRoot":"","sources":["../../../../src/lib/feature-collection-converters/helpers/flat-geojson-to-binary-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,gBAAgB,CAAC;AAErB;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,uBAAuB,EAAE,WAAW,GAAG,WAAW,CAAC;IACnD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC"}

package/dist/lib/feature-collection-converters/helpers/flat-geojson-to-binary-types.js

@@ -0,0 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};

package/dist/lib/geometry-api/geometry-info.d.ts

@@ -0,0 +1,21 @@
+import type { Feature } from '@loaders.gl/schema';
+/** Aggregate information for converting GeoJSON into other formats */
+export type GeojsonGeometryInfo = {
+    coordLength: number;
+    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
+ */
+export declare function getGeometryInfo(features: Feature[]): GeojsonGeometryInfo;
+//# sourceMappingURL=geometry-info.d.ts.map

package/dist/lib/geometry-api/geometry-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-info.d.ts","sourceRoot":"","sources":["../../../src/lib/geometry-api/geometry-info.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAEhD,sEAAsE;AACtE,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AAEH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CA4FxE"}

package/dist/lib/{binary-features/extract-geometry-info.js → geometry-api/geometry-info.js}

@@ -1,10 +1,13 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 /**
  *  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
-export function extractGeometryInfo(features) {
+export function getGeometryInfo(features) {
     // Counts the number of _positions_, so [x, y, z] counts as one
     let pointPositionsCount = 0;
     let pointFeaturesCount = 0;

package/dist/lib/geometry-converters/convert-binary-geometry-to-geojson.d.ts

@@ -0,0 +1,4 @@
+import type { BinaryGeometry, Geometry } from '@loaders.gl/schema';
+/** Parse input binary data and return a valid GeoJSON geometry object */
+export declare function convertBinaryGeometryToGeometry(data: BinaryGeometry, startIndex?: number, endIndex?: number): Geometry;
+//# sourceMappingURL=convert-binary-geometry-to-geojson.d.ts.map

package/dist/lib/geometry-converters/convert-binary-geometry-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-binary-geometry-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/geometry-converters/convert-binary-geometry-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EAKd,QAAQ,EAQT,MAAM,oBAAoB,CAAC;AAE5B,yEAAyE;AACzE,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,cAAc,EACpB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAYV"}

package/dist/lib/geometry-converters/convert-binary-geometry-to-geojson.js

@@ -0,0 +1,91 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Parse input binary data and return a valid GeoJSON geometry object */
+export function convertBinaryGeometryToGeometry(data, startIndex, endIndex) {
+    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 = data;
+            throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+    }
+}
+/** Parse binary data of type Polygon */
+function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    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 = [];
+        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 = [];
+    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);
+    }
+    return { type: 'MultiPolygon', coordinates };
+}
+/** Parse binary data of type LineString */
+function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    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 = [];
+    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, startIndex, endIndex) {
+    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, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+        const coord = Array();
+        for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+            coord.push(Number(positions.value[k]));
+        }
+        ringCoordinates.push(coord);
+    }
+    return ringCoordinates;
+}

package/dist/lib/geometry-converters/convert-geoarrow-to-geojson.d.ts

@@ -0,0 +1,13 @@
+import type { Geometry } from '@loaders.gl/schema';
+import type { GeoArrowEncoding } from '@loaders.gl/geoarrow';
+/**
+ * parse geometry from arrow data that is returned from processArrowData()
+ * NOTE: this function could be deduplicated with the binaryToGeometry() in deck.gl,
+ * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
+ *
+ * @param data data extraced from arrow vector representing a geometry
+ * @param encoding the geoarrow encoding of the geometry column
+ * @returns Feature or null
+ */
+export declare function convertGeoArrowGeometryToGeoJSON(arrowCellValue: any, encoding?: GeoArrowEncoding): Geometry | null;
+//# sourceMappingURL=convert-geoarrow-to-geojson.d.ts.map

package/dist/lib/geometry-converters/convert-geoarrow-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geoarrow-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/geometry-converters/convert-geoarrow-to-geojson.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAQV,QAAQ,EACT,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAI3D;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAC9C,cAAc,EAAE,GAAG,EACnB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,QAAQ,GAAG,IAAI,CA4BjB"}