@loaders.gl/arrow 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/geoarrow/convert-geoarrow-to-binary-geometry.js

@@ -1,320 +1,377 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { earcut } from '@math.gl/polygon';
 import { updateBoundsFromGeoArrowSamples } from "./get-arrow-bounds.js";
-var BinaryGeometryType = function (BinaryGeometryType) {
-  BinaryGeometryType["points"] = "points";
-  BinaryGeometryType["lines"] = "lines";
-  BinaryGeometryType["polygons"] = "polygons";
-  return BinaryGeometryType;
-}(BinaryGeometryType || {});
+/**
+ * Binary geometry type
+ */
+var BinaryGeometryType;
+(function (BinaryGeometryType) {
+    BinaryGeometryType["points"] = "points";
+    BinaryGeometryType["lines"] = "lines";
+    BinaryGeometryType["polygons"] = "polygons";
+})(BinaryGeometryType || (BinaryGeometryType = {}));
+/**
+ * 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
-    }
-  };
+    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 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 getBinaryGeometriesFromArrow(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 === null || options === void 0 ? void 0 : options.chunkIndex) !== undefined && (options === null || options === void 0 ? void 0 : options.chunkIndex) >= 0 ? [geoColumn.data[options === null || options === void 0 ? void 0 : options.chunkIndex]] : geoColumn.data;
-  let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-  let globalFeatureIdOffset = (options === null || options === void 0 ? void 0 : 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
-      },
-      properties: [...Array(chunk.length).keys()].map(i => ({
-        index: i + globalFeatureIdOffset
-      }))
+    const featureTypes = {
+        polygon: geoEncoding === 'geoarrow.multipolygon' || geoEncoding === 'geoarrow.polygon',
+        point: geoEncoding === 'geoarrow.multipoint' || geoEncoding === 'geoarrow.point',
+        line: geoEncoding === 'geoarrow.multilinestring' || geoEncoding === 'geoarrow.linestring'
     };
-    globalFeatureIdOffset += chunk.length;
-    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
+    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;
         }
-      },
-      polygons: {
-        type: 'Polygon',
-        ...getBinaryGeometryTemplate(),
-        ...(featureTypes.polygon ? binaryContent : {}),
-        polygonIndices: {
-          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
-          }
-        } : {})
-      }
+        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 BinaryFeatures 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);
     });
-    bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-  });
-  return {
-    binaryGeometries,
-    bounds,
-    featureTypes,
-    ...(options !== null && options !== void 0 && options.calculateMeanCenters ? {
-      meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)
-    } : {})
-  };
+    return {
+        binaryGeometries,
+        bounds,
+        featureTypes,
+        ...(options?.calculateMeanCenters
+            ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) }
+            : {})
+    };
 }
+/**
+ * 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) {
-      var _binaryContent$primit;
-      const featureIds = binaryContent.featureIds.value;
-      const flatCoordinateArray = binaryContent.positions.value;
-      const nDim = binaryContent.positions.size;
-      const primitivePolygonIndices = binaryContent.type === 'Polygon' ? (_binaryContent$primit = binaryContent.primitivePolygonIndices) === null || _binaryContent$primit === void 0 ? void 0 : _binaryContent$primit.value : undefined;
-      const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
-      meanCenters.forEach(center => {
-        globalMeanCenters.push(center);
-      });
-    }
-  });
-  return globalMeanCenters;
+    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 === null || primitivePolygonIndices === void 0 ? void 0 : primitivePolygonIndices[primitiveIdx]) === coordIdx) {
-        vertexIndex += nDim;
-        primitiveIdx++;
-      } else {
-        center[0] += flatCoordinateArray[vertexIndex];
-        center[1] += flatCoordinateArray[vertexIndex + 1];
-        vertexIndex += nDim;
-        vertexCountInFeature++;
-      }
-      coordIdx += 1;
+    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);
     }
-    center[0] /= vertexCountInFeature;
-    center[1] /= vertexCountInFeature;
-    meanCenters.push(center);
-  }
-  return meanCenters;
+    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');
-  }
+    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 = [];
-    for (let i = 0; i < polygonIndices.length - 1; i++) {
-      const startIdx = polygonIndices[i];
-      const endIdx = polygonIndices[i + 1];
-      const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
-      const holeIndices = [];
-      while (primitivePolygonIndices[primitiveIndex] < endIdx) {
-        if (primitivePolygonIndices[primitiveIndex] > startIdx) {
-          holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
+    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);
+            }
         }
-        primitiveIndex++;
-      }
-      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;
     }
-    const trianglesUint32 = new Uint32Array(triangles.length);
-    for (let i = 0; i < triangles.length; i++) {
-      trianglesUint32[i] = triangles[i];
+    catch (error) {
+        // if earcut fails, return null
+        return null;
     }
-    return trianglesUint32;
-  } catch (error) {
-    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 geometryIndicies = new Uint16Array(polygonOffset.length);
-  for (let i = 0; i < polygonOffset.length; i++) {
-    geometryIndicies[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 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 geometryIndicies = new Uint16Array(polygonOffset.length);
+    for (let i = 0; i < polygonOffset.length; i++) {
+        geometryIndicies[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 !== null && options !== void 0 && options.triangulate ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim) : null;
-  return {
-    featureIds,
-    nDim,
-    flatCoordinateArray,
-    geomOffset,
-    geometryIndicies,
-    ...(options !== null && options !== void 0 && options.triangulate && triangles ? {
-      triangles
-    } : {})
-  };
+    const triangles = options?.triangulate
+        ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim)
+        : null;
+    return {
+        featureIds,
+        nDim,
+        flatCoordinateArray,
+        geomOffset,
+        geometryIndicies,
+        ...(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;
-  const geometryIndicies = 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;
-      }
+    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;
+    // geometryIndicies is not needed for line string
+    const geometryIndicies = 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;
-      }
+    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,
-    geometryIndicies
-  };
+    return {
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        geomOffset,
+        geometryIndicies
+    };
 }
+/**
+ * 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;
-  const geometryIndicies = new Uint16Array(0);
-  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;
-      }
+    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 geometryIndicies = 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;
+    else {
+        for (let i = 0; i < chunk.length; i++) {
+            featureIds[i] = i;
+        }
     }
-  }
-  return {
-    featureIds,
-    flatCoordinateArray,
-    nDim,
-    geomOffset,
-    geometryIndicies
-  };
+    return {
+        featureIds,
+        flatCoordinateArray,
+        nDim,
+        geomOffset,
+        geometryIndicies
+    };
 }
-//# sourceMappingURL=convert-geoarrow-to-binary-geometry.js.map