Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

fix(layers): handle WKB GeometryCollection imports (#3870)

Igor Dykhta5a72e13c809b
diff --git a/src/layers/src/geojson-layer/geojson-utils.spec.ts b/src/layers/src/geojson-layer/geojson-utils.spec.ts
index 95bc13dc3..00d6523c7 100644
--- a/src/layers/src/geojson-layer/geojson-utils.spec.ts
+++ b/src/layers/src/geojson-layer/geojson-utils.spec.ts
@@ -1,8 +1,363 @@
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
-import {Feature} from 'geojson';
-import {featureToHoverOutline} from './geojson-utils';
+import {Feature, Geometry} from 'geojson';
+import {convertGeometryToWKB} from '@loaders.gl/gis';
+import {GeoJsonLayer as DeckGLGeoJsonLayer} from '@deck.gl/layers';
+import {GEOARROW_EXTENSIONS} from '@kepler.gl/constants';
+import {GEOARROW_METADATA_KEY} from '@kepler.gl/constants';
+import {KeplerTable, copyTableAndUpdate} from '@kepler.gl/table';
+import {processFileData} from '@kepler.gl/processors';
+import * as arrow from 'apache-arrow';
+import GeoJsonLayer from './geojson-layer';
+import {
+ featureToHoverOutline,
+ parseGeoJsonRawFeature,
+ getGeojsonFeatureTypes,
+ getGeojsonBounds
+} from './geojson-utils';
+
+// Exercise deck.gl's real data conversion without creating a WebGL context.
+function renderGeojsonFeatures(data: Feature[]) {
+ const layer = new DeckGLGeoJsonLayer({data});
+ layer.initializeState();
+ jest.spyOn(layer, 'setState').mockImplementation(update => {
+ Object.assign(layer.state, update);
+ });
+ layer.updateState({
+ props: layer.props,
+ oldProps: layer.props,
+ context: layer.context,
+ changeFlags: {
+ dataChanged: 'initial data',
+ propsChanged: false,
+ updateTriggersChanged: false,
+ extensionsChanged: false,
+ viewportChanged: false,
+ stateChanged: false,
+ propsOrDataChanged: true,
+ somethingChanged: true
+ }
+ });
+ return layer.state.features;
+}
+
+describe('WKB GeometryCollection', () => {
+ test.each([null, {}, 'invalid'])(
+ 'ignores malformed collection members in geometry-type metadata (%j)',
+ geometries => {
+ expect(
+ getGeojsonFeatureTypes([
+ {
+ type: 'Feature',
+ properties: {},
+ geometry: {type: 'GeometryCollection', geometries}
+ } as any
+ ])
+ ).toEqual({});
+ }
+ );
+ const geometry: Geometry = {
+ type: 'GeometryCollection',
+ geometries: [
+ {type: 'Point', coordinates: [1, 2]},
+ {
+ type: 'GeometryCollection',
+ geometries: [
+ {
+ type: 'LineString',
+ coordinates: [
+ [3, 4],
+ [5, 6]
+ ]
+ },
+ {type: 'GeometryCollection', geometries: []}
+ ]
+ }
+ ]
+ };
+ const bytes = () => new Uint8Array(convertGeometryToWKB(geometry));
+
+ test.each(['bytes', 'buffer', 'hex', 'offset view', 'GeoArrow'])(
+ 'preserves nested and empty collections from %s',
+ format => {
+ const wkb = bytes();
+ const padded = new Uint8Array(wkb.length + 8);
+ padded.set(wkb, 4);
+ const value =
+ format === 'hex'
+ ? Buffer.from(wkb).toString('hex')
+ : format === 'buffer'
+ ? wkb.buffer
+ : format === 'offset view'
+ ? padded.subarray(4, -4)
+ : wkb;
+ expect(
+ parseGeoJsonRawFeature(value, format === 'GeoArrow' ? GEOARROW_EXTENSIONS.WKB : undefined)
+ ?.geometry
+ ).toEqual(geometry);
+ }
+ );
+
+ test('accepts a big-endian collection header and SRID metadata', () => {
+ const littleEndian = bytes();
+ const bigEndian = littleEndian.slice();
+ const view = new DataView(bigEndian.buffer);
+ view.setUint8(0, 0);
+ view.setUint32(1, 7, false);
+ view.setUint32(5, 2, false);
+ expect(parseGeoJsonRawFeature(bigEndian)?.geometry).toEqual(geometry);
+
+ const ewkb = new Uint8Array(littleEndian.length + 4);
+ ewkb.set(littleEndian.subarray(0, 5));
+ ewkb.set(littleEndian.subarray(5), 9);
+ const ewkbView = new DataView(ewkb.buffer);
+ ewkbView.setUint32(1, 0x20000007, true);
+ ewkbView.setUint32(5, 4326, true);
+ expect(parseGeoJsonRawFeature(ewkb)?.geometry).toEqual(geometry);
+ });
+
+ test('rejects malformed or excessively nested collections without throwing', () => {
+ const wkb = bytes();
+ const badOrder = wkb.slice();
+ badOrder[0] = 2;
+ const badCount = wkb.slice();
+ new DataView(badCount.buffer).setUint32(5, 0xffffffff, true);
+ const extra = new Uint8Array(wkb.length + 1);
+ extra.set(wkb);
+ let deep: Geometry = {type: 'Point', coordinates: [1, 2]};
+ for (let i = 0; i < 40; i++) deep = {type: 'GeometryCollection', geometries: [deep]};
+ for (const value of [
+ new Uint8Array(),
+ wkb.subarray(0, 8),
+ wkb.subarray(0, -1),
+ badOrder,
+ badCount,
+ extra,
+ new Uint8Array(convertGeometryToWKB(deep))
+ ]) {
+ expect(() => parseGeoJsonRawFeature(value)).not.toThrow();
+ expect(parseGeoJsonRawFeature(value)).toBeNull();
+ }
+ });
+
+ test.each(['Arrow hex', 'Arrow WKB', 'GeoParquet'])(
+ 'imports collections through %s with row IDs, hover, filters and cache reuse',
+ async format => {
+ const point: Geometry = {type: 'Point', coordinates: [50, 60]};
+ const values = [geometry, point].map(value => new Uint8Array(convertGeometryToWKB(value)));
+ let table = new arrow.Table({
+ _geojson:
+ format === 'Arrow hex'
+ ? arrow.vectorFromArray(
+ values.map(value => Buffer.from(value).toString('hex')),
+ new arrow.Utf8()
+ )
+ : arrow.vectorFromArray(values, new arrow.Binary()),
+ label: arrow.vectorFromArray(['collection', 'point'], new arrow.Utf8())
+ });
+ if (format === 'Arrow WKB')
+ table.schema.fields[0].metadata.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB);
+ if (format === 'GeoParquet') {
+ table.schema.metadata.set(
+ 'geo',
+ JSON.stringify({
+ version: '1.1.0',
+ primary_column: '_geojson',
+ columns: {_geojson: {encoding: 'WKB'}}
+ })
+ );
+ const specifier = 'parquet-wasm/node';
+ const imported = await import(specifier);
+ const wasm = imported.readParquet ? imported : imported.default;
+ const properties = new wasm.WriterPropertiesBuilder()
+ .setKeyValueMetadata(table.schema.metadata)
+ .build();
+ const parquet = wasm.writeParquet(
+ wasm.Table.fromIPCStream(arrow.tableToIPC(table, 'stream')),
+ properties
+ );
+ table = arrow.tableFromIPC(wasm.readParquet(parquet).intoIPCStream());
+ } else table = arrow.tableFromIPC(arrow.tableToIPC(table, 'stream'));
+ const [file] = await processFileData({
+ content: {
+ fileName: format === 'GeoParquet' ? 'collections.parquet' : 'collections.arrow',
+ data: table.batches
+ },
+ fileCache: []
+ } as any);
+ const dataset = new KeplerTable({info: file.info, color: [0, 0, 0]});
+ await dataset.importData({data: file.data as any});
+ const {props} = GeoJsonLayer.findDefaultLayerProps(dataset);
+ expect(props).toHaveLength(1);
+ const layer = new GeoJsonLayer({...props[0], id: 'wkb-collection', dataId: dataset.id});
+ layer.setInitialLayerConfig(dataset);
+ const data = layer.formatLayerData({[dataset.id]: dataset}, {}) as any;
+ expect(layer.centroids).toHaveLength(2);
+ expect(layer.meta).toMatchObject({bounds: [1, 2, 50, 60]});
+ expect(layer.meta.featureTypes).toMatchObject({point: true, line: true});
+ if (layer.geoArrowMode) {
+ expect(
+ [
+ ...new Set(
+ data.data.flatMap(batch =>
+ ['points', 'lines', 'polygons'].flatMap(type =>
+ Array.from(batch[type]?.globalFeatureIds?.value || [])
+ )
+ )
+ )
+ ].sort()
+ ).toEqual([0, 1]);
+ } else {
+ expect(data.data.map(feature => feature.properties.index)).toEqual([0, 1]);
+ const rendered = renderGeojsonFeatures(data.data);
+ expect(rendered.pointFeatures?.map(feature => feature.geometry.coordinates)).toEqual([
+ [1, 2],
+ [50, 60]
+ ]);
+ expect(rendered.lineFeatures?.map(feature => feature.geometry.coordinates)).toEqual([
+ [
+ [3, 4],
+ [5, 6]
+ ]
+ ]);
+ }
+ const hover = {
+ picked: true,
+ index: 0,
+ object: layer.geoArrowMode ? undefined : data.data[0],
+ layer: {props: {id: layer.id}}
+ };
+ const overlay = layer._getHoverOverlayData(hover);
+ expect(overlay?.[0]).toMatchObject({
+ properties: {index: 0},
+ geometry: {
+ type: 'GeometryCollection',
+ geometries: [
+ {type: 'Point', coordinates: [1, 2]},
+ {
+ type: 'LineString',
+ coordinates: [
+ [3, 4],
+ [5, 6]
+ ]
+ }
+ ]
+ }
+ });
+ const renderedOverlay = renderGeojsonFeatures(overlay!);
+ expect(renderedOverlay.pointFeatures).toHaveLength(1);
+ expect(renderedOverlay.lineFeatures).toHaveLength(1);
+ if (layer.geoArrowMode)
+ expect(layer.hasHoveredObject(hover)?.properties).toMatchObject({
+ label: 'collection',
+ index: 0
+ });
+ const parsed = layer.dataToFeature;
+ layer.updateLayerVisConfig({opacity: 0.37});
+ const updated = layer.formatLayerData(
+ {[dataset.id]: copyTableAndUpdate(dataset, {filteredIndex: [1]})},
+ data
+ ) as any;
+ expect(layer.dataToFeature).toBe(parsed);
+ expect(layer.config.visConfig.opacity).toBe(0.37);
+ if (layer.geoArrowMode) {
+ expect(updated.getFiltered({properties: {index: 0}})).toBe(0);
+ expect(updated.getFiltered({properties: {index: 1}})).toBe(1);
+ } else expect(updated.data.map(feature => feature.properties.index)).toEqual([1]);
+ }
+ );
+
+ test('skips invalid and empty WKB rows while preserving later Arrow row IDs', () => {
+ const point: Geometry = {type: 'Point', coordinates: [50, 60]};
+ const values = [
+ bytes(),
+ bytes().subarray(0, 8),
+ new Uint8Array(),
+ new Uint8Array(convertGeometryToWKB({type: 'GeometryCollection', geometries: []})),
+ new Uint8Array(convertGeometryToWKB(point))
+ ];
+ const dataset = new KeplerTable({
+ info: {id: 'invalid-collections'},
+ color: [0, 0, 0]
+ }).updateSchema({
+ fields: [
+ {
+ name: 'geometry',
+ type: 'geoarrow',
+ analyzerType: 'GEOMETRY',
+ metadata: new Map([[GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB]])
+ }
+ ],
+ cols: [arrow.vectorFromArray(values, new arrow.Binary())],
+ rows: []
+ });
+ const layer = new GeoJsonLayer({
+ id: 'invalid-wkb',
+ dataId: dataset.id,
+ columns: {geojson: {value: 'geometry', fieldIdx: 0}}
+ });
+ expect(() => layer.setInitialLayerConfig(dataset)).not.toThrow();
+ expect(layer.centroids).toEqual([[3, 4], null, null, null, [50, 60]]);
+ const data = layer.formatLayerData({[dataset.id]: dataset}, {}) as any;
+ expect(
+ [
+ ...new Set(
+ data.data.flatMap(batch =>
+ ['points', 'lines'].flatMap(type => Array.from(batch[type].globalFeatureIds.value))
+ )
+ )
+ ].sort()
+ ).toEqual([0, 4]);
+ expect(
+ layer._getHoverOverlayData({picked: true, index: 1, layer: {props: {id: layer.id}}})
+ ).toBeNull();
+ });
+});
+
+describe('getGeojsonBounds', () => {
+ test.each([
+ {type: 'Polygon'},
+ {type: 'GeometryCollection', geometries: null},
+ {type: 'GeometryCollection', geometries: [{type: 'Polygon'}]}
+ ])('preserves valid rows when a collection contains %j', malformed => {
+ const valid: Feature = {
+ type: 'Feature',
+ properties: {},
+ geometry: {type: 'Point', coordinates: [1, 2]}
+ };
+ const invalid = {
+ type: 'Feature',
+ properties: {},
+ geometry: {
+ type: 'GeometryCollection',
+ geometries: [{type: 'Point', coordinates: [50, 60]}, malformed]
+ }
+ } as Feature;
+ expect(getGeojsonBounds([valid, invalid])).toEqual([1, 2, 1, 2]);
+ });
+
+ test('includes valid nested collections alongside empty collections', () => {
+ expect(
+ getGeojsonBounds([
+ {
+ type: 'Feature',
+ properties: {},
+ geometry: {
+ type: 'GeometryCollection',
+ geometries: [
+ {type: 'GeometryCollection', geometries: []},
+ {
+ type: 'GeometryCollection',
+ geometries: [{type: 'Point', coordinates: [50, 60]}]
+ }
+ ]
+ }
+ }
+ ])
+ ).toEqual([50, 60, 50, 60]);
+ });
+});
describe('featureToHoverOutline', () => {
test('converts Polygon rings to MultiLineString so hover overlay skips fill tessellation', () => {
diff --git a/src/layers/src/geojson-layer/geojson-utils.ts b/src/layers/src/geojson-layer/geojson-utils.ts
index c413a5035..4e51e052f 100644
--- a/src/layers/src/geojson-layer/geojson-utils.ts
+++ b/src/layers/src/geojson-layer/geojson-utils.ts
@@ -2,7 +2,7 @@
// Copyright contributors to the kepler.gl project
import {Buffer} from 'buffer';
-import {Feature, Position, BBox} from 'geojson';
+import {Feature, Geometry, Position, BBox} from 'geojson';
import normalize from '@mapbox/geojson-normalize';
import {bbox} from '@turf/bbox';
import {ascending, extent} from 'd3-array';
@@ -130,6 +130,78 @@ function isBinaryGeometry(value: unknown): value is Uint8Array | ArrayBuffer {
return ArrayBuffer.isView(value) && (value as Uint8Array).BYTES_PER_ELEMENT === 1;
}
+/** Keep the existing decoder for ordinary WKB; decode collection envelopes here. */
+function parseWkbGeometry(buffer: ArrayBuffer): Geometry | null {
+ try {
+ return convertWKBToGeometry(buffer);
+ } catch {
+ // loaders.gl does not yet decode WKB GeometryCollection (type 7).
+ }
+ const view = new DataView(buffer);
+ const header = (offset: number) => {
+ const order = view.getUint8(offset);
+ if (order !== 0 && order !== 1) throw new Error('Invalid WKB byte order');
+ const littleEndian = order === 1;
+ const rawType = view.getUint32(offset + 1, littleEndian);
+ const type = rawType & 0x1fffffff;
+ const kind = type % 1000;
+ if (kind < 1 || kind > 7 || type >= 4000) throw new Error('Unsupported WKB type');
+ const dimensions =
+ 2 +
+ Number(Boolean(rawType & 0x80000000) || [1, 3].includes(Math.floor(type / 1000))) +
+ Number(Boolean(rawType & 0x40000000) || [2, 3].includes(Math.floor(type / 1000)));
+ return {kind, littleEndian, dimensions, start: offset + 5 + (rawType & 0x20000000 ? 4 : 0)};
+ };
+ const endOfGeometry = (offset: number, depth: number): number => {
+ if (depth > 32) throw new Error('WKB nesting limit exceeded');
+ const {kind, start, dimensions, littleEndian} = header(offset);
+ let cursor = start;
+ if (kind === 1) cursor += dimensions * 8;
+ else {
+ const count = view.getUint32(cursor, littleEndian);
+ cursor += 4;
+ if (kind === 2) cursor += count * dimensions * 8;
+ else {
+ if (count > (buffer.byteLength - cursor) / (kind === 3 ? 4 : 5))
+ throw new Error('Truncated WKB');
+ for (let i = 0; i < count; i++) {
+ if (kind === 3) {
+ const points = view.getUint32(cursor, littleEndian);
+ cursor += 4 + points * dimensions * 8;
+ } else cursor = endOfGeometry(cursor, depth + 1);
+ }
+ }
+ }
+ if (cursor > buffer.byteLength) throw new Error('Truncated WKB');
+ return cursor;
+ };
+ const readGeometry = (offset: number, depth: number): {geometry: Geometry; end: number} => {
+ if (depth > 32) throw new Error('WKB nesting limit exceeded');
+ const {kind, start, littleEndian} = header(offset);
+ if (kind !== 7) {
+ const end = endOfGeometry(offset, depth);
+ return {geometry: convertWKBToGeometry(buffer.slice(offset, end)), end};
+ }
+ const count = view.getUint32(start, littleEndian);
+ let cursor = start + 4;
+ if (count > (buffer.byteLength - cursor) / 5) throw new Error('Truncated WKB');
+ const geometries: Geometry[] = [];
+ for (let i = 0; i < count; i++) {
+ const child = readGeometry(cursor, depth + 1);
+ geometries.push(child.geometry);
+ cursor = child.end;
+ }
+ return {geometry: {type: 'GeometryCollection', geometries}, end: cursor};
+ };
+ try {
+ if (header(0).kind !== 7) return null;
+ const {geometry, end} = readGeometry(0, 0);
+ return end === buffer.byteLength ? geometry : null;
+ } catch {
+ return null;
+ }
+}
+
function isLngLat(pos: unknown): pos is number[] {
const values = pos as {length?: number; 0?: unknown; 1?: unknown} | null;
return (
@@ -198,6 +270,22 @@ function featureFromGeometry(parsedGeo: unknown, properties: null): Feature | nu
return {properties, ...normalized.features[0]};
}
+/** deck.gl accepts one collection level; keep one feature per source row. */
+function flattenGeometryCollection(geometry: Geometry): Geometry {
+ if (geometry?.type !== 'GeometryCollection' || !Array.isArray(geometry.geometries)) {
+ return geometry;
+ }
+ return {
+ ...geometry,
+ geometries: geometry.geometries.flatMap(child => {
+ const flattened = flattenGeometryCollection(child);
+ return flattened?.type === 'GeometryCollection' && Array.isArray(flattened.geometries)
+ ? flattened.geometries
+ : [flattened];
+ })
+ };
+}
+
/**
* Convert a hovered feature to outline-only geometry for the hover overlay.
* The overlay is stroked and not filled, so polygon tessellation (earcut) is wasted
@@ -227,6 +315,9 @@ export function featureToHoverOutline(feature: Feature): Feature {
}
};
}
+ if (geometry.type === 'GeometryCollection') {
+ return {...feature, geometry: flattenGeometryCollection(geometry)};
+ }
return feature;
}
@@ -263,8 +354,8 @@ export function parseGeoJsonRawFeature(
// Support WKB geometry provided as binary (e.g., from Parquet/GeoParquet/DuckDB)
if (isBinaryGeometry(rawFeature)) {
try {
- const parsedGeo = convertWKBToGeometry(toArrayBuffer(rawFeature));
- return featureFromGeometry(parsedGeo, properties);
+ const parsedGeo = parseWkbGeometry(toArrayBuffer(rawFeature));
+ return parsedGeo ? featureFromGeometry(parsedGeo, properties) : null;
} catch (e) {
return null;
}
@@ -381,6 +472,7 @@ export function getGeojsonDataMaps(
if (feature && feature.geometry && acceptableTypes.includes(feature.geometry.type)) {
const cleaned = Object.assign({}, feature);
+ cleaned.geometry = flattenGeometryCollection(feature.geometry);
// store index of the data in feature properties
cleaned.properties = Object.assign({}, feature.properties ?? {}, {index});
@@ -460,7 +552,7 @@ function parseGeometryFromString(geoString: string): Feature | null {
// try parse as WKB hex string
try {
const buffer = Buffer.from(geoString, 'hex');
- parsedGeo = convertWKBToGeometry(toArrayBuffer(buffer));
+ parsedGeo = parseWkbGeometry(toArrayBuffer(buffer));
} catch (e) {
return null;
}
@@ -492,12 +584,11 @@ export function getGeojsonBounds(features: GeojsonDataMaps = []): BBox | null {
const maxCount = 10000;
const samples = features.length > maxCount ? getSampleData(features, maxCount) : features;
- const validSingleGeometry = geom => geom.coordinates && geom.coordinates.length;
- const validGeometryCollection = geom =>
- geom.geometries && geom.geometries.length && geom.geometries.every(validSingleGeometry);
- const nonEmpty = samples.filter(
- d => d && d.geometry && (validSingleGeometry(d.geometry) || validGeometryCollection(d.geometry))
- );
+ const validGeometry = geom =>
+ geom?.type === 'GeometryCollection'
+ ? Array.isArray(geom.geometries) && geom.geometries.every(validGeometry)
+ : geom?.coordinates && geom.coordinates.length;
+ const nonEmpty = samples.filter(d => d && d.geometry && validGeometry(d.geometry));
try {
return bbox({
@@ -530,13 +621,18 @@ export type DeckGlGeoTypes = {
export function getGeojsonFeatureTypes(allFeatures: GeojsonDataMaps): DeckGlGeoTypes {
// @ts-expect-error some test cases only have 1 geotype
const featureTypes: DeckGlGeoTypes = {};
+ const addGeometry = geometry => {
+ if (geometry?.type === 'GeometryCollection') {
+ if (Array.isArray(geometry.geometries)) geometry.geometries.forEach(addGeometry);
+ } else {
+ const geoType = featureToDeckGlGeoType[geometry?.type];
+ if (geoType) featureTypes[geoType] = true;
+ }
+ };
for (let f = 0; f < allFeatures.length; f++) {
const feature = allFeatures[f];
if (feature && 'geometry' in feature) {
- const geoType = featureToDeckGlGeoType[feature.geometry && feature.geometry.type];
- if (geoType) {
- featureTypes[geoType] = true;
- }
+ addGeometry(feature.geometry);
}
}
diff --git a/src/layers/src/layer-utils.ts b/src/layers/src/layer-utils.ts
index a5db34cdf..550ee0f6e 100644
--- a/src/layers/src/layer-utils.ts
+++ b/src/layers/src/layer-utils.ts
@@ -19,10 +19,6 @@ import {
import {DataContainerInterface, ArrowDataContainer} from '@kepler.gl/utils';
import {getBinaryGeometriesFromArrow, BinaryGeometriesFromArrowOptions} from '@loaders.gl/gis';
import {updateBoundsFromGeoArrowSamples} from '@loaders.gl/geoarrow';
-import {convertGeoArrowGeometryToGeoJSON} from '@loaders.gl/gis';
-
-import {parseSync} from '@loaders.gl/core';
-import {WKBLoader} from '@loaders.gl/wkt';
import {geojsonToBinary} from '@loaders.gl/gis';
import {
Geometry,
@@ -34,7 +30,8 @@ import {
import {
DeckGlGeoTypes,
GeojsonDataMaps,
- getCentroidFromGeometry
+ getCentroidFromGeometry,
+ parseGeoJsonRawFeature
} from './geojson-layer/geojson-utils';
export type FindDefaultLayerProps = {
@@ -107,27 +104,25 @@ function getBinaryGeometriesFromWKBArrow(
let bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
const geojsonFeatures: Feature[] = [];
+ const addGeometry = (geometry: Geometry, index: number) => {
+ if (geometry.type === 'GeometryCollection') {
+ geometry.geometries.forEach(child => addGeometry(child, index));
+ } else {
+ geojsonFeatures.push({type: 'Feature', geometry, properties: {index}});
+ featureTypes.polygon ||= geometry.type === 'Polygon' || geometry.type === 'MultiPolygon';
+ featureTypes.point ||= geometry.type === 'Point' || geometry.type === 'MultiPoint';
+ featureTypes.line ||= geometry.type === 'LineString' || geometry.type === 'MultiLineString';
+ }
+ };
chunks.forEach(chunk => {
for (let i = 0; i < chunk.length; ++i) {
// ignore features without any geometry
if (chunk.valueOffsets[i + 1] - chunk.valueOffsets[i] > 0) {
const valuesSlice = chunk.values.slice(chunk.valueOffsets[i], chunk.valueOffsets[i + 1]);
- const geometry = parseSync(valuesSlice.buffer, WKBLoader, {
- wkb: {shape: 'geojson-geometry'}
- }) as Geometry;
- const feature: Feature = {
- type: 'Feature',
- geometry,
- properties: {index: featureIndex}
- };
- geojsonFeatures.push(feature);
- centroids.push(getCentroidFromGeometry(geometry));
-
- const {type} = geometry;
- featureTypes.polygon = type === 'Polygon' || type === 'MultiPolygon';
- featureTypes.point = type === 'Point' || type === 'MultiPoint';
- featureTypes.line = type === 'LineString' || type === 'MultiLineString';
+ const geometry = parseGeoJsonRawFeature(valuesSlice)?.geometry;
+ if (geometry) addGeometry(geometry, featureIndex);
+ centroids.push(geometry ? getCentroidFromGeometry(geometry) : null);
} else {
centroids.push(null);
}
@@ -266,7 +261,7 @@ export function getHoveredObjectFromArrow(
const field = fieldAccessor(dataContainer);
const encoding = field?.metadata?.get(GEOARROW_METADATA_KEY);
- const hoveredFeature = convertGeoArrowGeometryToGeoJSON(rawGeometry, encoding);
+ const hoveredFeature = parseGeoJsonRawFeature(rawGeometry, encoding)?.geometry;
const properties = dataContainer.rowAsArray(objectInfo.index).reduce((prev, cur, i) => {
const fieldName = dataContainer?.getField?.(i).name;