Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
feat: add COLUMN_MODE_GEOJSON to heatmap layer (#3397)
Igor Dykhtacd5c077b00ef
diff --git a/src/components/src/filters/polygon-filter.tsx b/src/components/src/filters/polygon-filter.tsxindex 956a1d1ef..4421808ad 100644--- a/src/components/src/filters/polygon-filter.tsx+++ b/src/components/src/filters/polygon-filter.tsx@@ -8,7 +8,8 @@ import {LAYER_TYPES} from '@kepler.gl/constants';import {PolygonFilterProps} from './types';import {StyledFilterPanel} from './components';-const layerFilter = (layer: Layer) => layer.type === LAYER_TYPES.point;+const layerFilter = (layer: Layer) =>+ layer.type === LAYER_TYPES.point || layer.type === LAYER_TYPES.heatmap;const isAlreadySelected = (selectedLayers: Layer[], layerId: string) =>selectedLayers.findIndex(l => l.id === layerId) === -1;diff --git a/src/constants/src/layers.ts b/src/constants/src/layers.tsindex 73ae934d6..4d0add2fd 100644--- a/src/constants/src/layers.ts+++ b/src/constants/src/layers.ts@@ -567,5 +567,6 @@ export const EDITOR_AVAILABLE_LAYERS: string[] = [LAYER_TYPES.arc,LAYER_TYPES.line,LAYER_TYPES.hexagonId,- LAYER_TYPES.geojson+ LAYER_TYPES.geojson,+ LAYER_TYPES.heatmap];diff --git a/src/layers/src/heatmap-layer/heatmap-layer.ts b/src/layers/src/heatmap-layer/heatmap-layer.tsindex 8de280792..905f85d02 100644--- a/src/layers/src/heatmap-layer/heatmap-layer.ts+++ b/src/layers/src/heatmap-layer/heatmap-layer.ts@@ -2,7 +2,7 @@// Copyright contributors to the kepler.gl projectimport KeplerHeatmapLayer from './deck-heatmap-layer';-import {CHANNEL_SCALES, ALL_FIELD_TYPES} from '@kepler.gl/constants';+import {CHANNEL_SCALES, ALL_FIELD_TYPES, GEOJSON_FIELDS} from '@kepler.gl/constants';import Layer, {LayerBaseConfigPartial, LayerWeightConfig, VisualChannels} from '../base-layer';import HeatmapLayerIcon from './heatmap-layer-icon';import {@@ -20,9 +20,14 @@ import {import {hexToRgb, DataContainerInterface} from '@kepler.gl/utils';import {notNullorUndefined} from '@kepler.gl/common-utils';import {Datasets, KeplerTable} from '@kepler.gl/table';+import {DATA_TYPES} from 'type-analyzer';+import booleanWithin from '@turf/boolean-within';+import {point as turfPoint} from '@turf/helpers';+import {Feature, Polygon} from 'geojson';import {getGeoArrowPointLayerProps, FindDefaultLayerPropsReturnValue} from '../layer-utils';import {getFilterDataFunc} from '../aggregation-layer';+import {parseGeoJsonRawFeature} from '../geojson-layer/geojson-utils';export type HeatmapLayerVisConfigSettings = {opacity: VisConfigNumber;@@ -40,6 +45,9 @@ export type HeatmapLayerColumnsConfig = {// COLUMN_MODE_GEOARROWgeoarrow: LayerColumn;++ // COLUMN_MODE_GEOJSON+ geojson: LayerColumn;};export type HeatmapLayerVisConfig = {@@ -74,10 +82,70 @@ export const geoarrowPosAccessor =return [row.get(0), row.get(1)];};-export const pointColResolver = ({lat, lng, geoarrow}: HeatmapLayerColumnsConfig, columnMode) => {+export const geojsonAccessor =+ ({geojson}: HeatmapLayerColumnsConfig) =>+ (dc: DataContainerInterface) =>+ (d: {index: number}) =>+ dc.valueAt(d.index, geojson.fieldIdx);++/**+ * Compute the centroid [lng, lat] of a GeoJSON geometry.+ * For Point returns the coordinate directly; for complex geometries+ * averages all vertex positions into a single representative point.+ */+function getCentroidFromGeometry(geometry: any): number[] | null {+ if (!geometry) return null;+ const positions = getAllPositions(geometry);+ if (positions.length === 0) return null;+ if (positions.length === 1) return positions[0];++ let sumLng = 0;+ let sumLat = 0;+ let count = 0;+ for (const pos of positions) {+ if (Number.isFinite(pos[0]) && Number.isFinite(pos[1])) {+ sumLng += pos[0];+ sumLat += pos[1];+ count++;+ }+ }+ return count > 0 ? [sumLng / count, sumLat / count] : null;+}++/**+ * Extract all vertex [lng, lat] coordinates from a GeoJSON geometry.+ * Used internally for bounds computation and centroid calculation.+ */+function getAllPositions(geometry: any): number[][] {+ if (!geometry) return [];+ switch (geometry.type) {+ case 'Point':+ return [geometry.coordinates];+ case 'MultiPoint':+ case 'LineString':+ return geometry.coordinates;+ case 'MultiLineString':+ case 'Polygon':+ return geometry.coordinates.flat();+ case 'MultiPolygon':+ return geometry.coordinates.flat(2);+ case 'GeometryCollection':+ return (geometry.geometries || []).flatMap(getAllPositions);+ default:+ return [];+ }+}++export const pointColResolver = (+ {lat, lng, geoarrow, geojson}: HeatmapLayerColumnsConfig,+ columnMode+) => {if (columnMode === COLUMN_MODE_POINTS) {return `${lat.fieldIdx}-${lng.fieldIdx}`;}+ if (columnMode === COLUMN_MODE_GEOJSON) {+ return `geojson-${geojson.fieldIdx}`;+ }return `geoarrow-${geoarrow.fieldIdx}`;};@@ -126,15 +194,29 @@ export const heatmapVisConfigs: {export const pointRequiredColumns = ['lat', 'lng'];export const geoarrowRequiredColumns = ['geoarrow'];+export const geojsonRequiredColumns = ['geojson'];export const COLUMN_MODE_POINTS = 'points';export const COLUMN_MODE_GEOARROW = 'geoarrow';+export const COLUMN_MODE_GEOJSON = 'geojson';++const SUPPORTED_ANALYZER_TYPES = {+ [DATA_TYPES.GEOMETRY]: true,+ [DATA_TYPES.GEOMETRY_FROM_STRING]: true,+ [DATA_TYPES.PAIR_GEOMETRY_FROM_STRING]: true+};+const SUPPORTED_COLUMN_MODES = [{key: COLUMN_MODE_POINTS,label: 'Points',requiredColumns: pointRequiredColumns},+ {+ key: COLUMN_MODE_GEOJSON,+ label: 'GeoJSON',+ requiredColumns: geojsonRequiredColumns+ },{key: COLUMN_MODE_GEOARROW,label: 'Geoarrow Points',@@ -165,6 +247,11 @@ class HeatmapLayer extends Layer {declare visConfigSettings: HeatmapLayerVisConfigSettings;declare config: HeatmapLayerConfig;+ dataToFeature: any[] = [];+ centroids: Array<number[] | null> = [];+ private _geojsonFieldIdx = -1;+ private _geojsonBounds: [number, number, number, number] | null = null;+constructor(props) {super(props);this.registerVisConfig(heatmapVisConfigs);@@ -173,6 +260,8 @@ class HeatmapLayer extends Layer {switch (this.config.columnMode) {case COLUMN_MODE_GEOARROW:return geoarrowPosAccessor(this.config.columns)(dataContainer);+ case COLUMN_MODE_GEOJSON:+ return geojsonAccessor(this.config.columns)(dataContainer);default:return pointPosAccessor(this.config.columns)(dataContainer);}@@ -211,12 +300,40 @@ class HeatmapLayer extends Layer {if (columnMode === COLUMN_MODE_GEOARROW) {return this.hasColumnValue(columns.geoarrow);}+ if (columnMode === COLUMN_MODE_GEOJSON) {+ return this.hasColumnValue(columns.geojson);+ }return super.hasAllColumns();}static findDefaultLayerProps(dataset: KeplerTable): FindDefaultLayerPropsReturnValue {const altProps = getGeoArrowPointLayerProps(dataset);+ const geojsonColumns = dataset.fields+ .filter(+ f =>+ (f.type === 'geojson' || f.type === 'geoarrow') &&+ f.analyzerType &&+ SUPPORTED_ANALYZER_TYPES[f.analyzerType]+ )+ .map(f => f.name);++ const defaultColumns = {+ geojson: [...(GEOJSON_FIELDS.geojson || []), ...geojsonColumns]+ };+ const foundColumns = this.findDefaultColumnField(defaultColumns, dataset.fields);++ if (foundColumns?.length) {+ const {label} = dataset;+ altProps.push(+ ...foundColumns.map(columns => ({+ label: (typeof label === 'string' && label.replace(/\.[^/.]+$/, '')) || 'heatmap',+ columns,+ columnMode: COLUMN_MODE_GEOJSON+ }))+ );+ }+return {props: [],altProps@@ -247,6 +364,20 @@ class HeatmapLayer extends Layer {return null;}+ isInPolygon(data: DataContainerInterface, index: number, polygon: Feature<Polygon>): boolean {+ if (this.centroids.length === 0 || !this.centroids[index]) {+ return false;+ }+ const point = this.centroids[index];+ if (!point) return false;+ const isRectangleSearchBox = polygon.properties?.shape === 'Rectangle';+ if (isRectangleSearchBox && polygon.properties?.bbox) {+ const [minX, minY, maxX, maxY] = polygon.properties.bbox;+ return point[0] >= minX && point[0] <= maxX && point[1] >= minY && point[1] <= maxY;+ }+ return booleanWithin(turfPoint(point), polygon);+ }+getVisualChannelDescription(channel) {return channel === 'color'? {@@ -259,6 +390,16 @@ class HeatmapLayer extends Layer {};}+ getDataUpdateTriggers(dataset: KeplerTable): any {+ const triggers = super.getDataUpdateTriggers(dataset);+ const {columnMode} = this.config;+ return {+ ...triggers,+ getData: {...triggers.getData, columnMode},+ getMeta: {...triggers.getMeta, columnMode}+ };+ }+getDefaultLayerConfig(props: LayerBaseConfigPartial): HeatmapLayerConfig {// eslint-disable-next-line @typescript-eslint/no-unused-varsconst {colorField, colorDomain, colorScale, ...layerConfig} = {@@ -276,12 +417,72 @@ class HeatmapLayer extends Layer {updateLayerMeta(dataset: KeplerTable) {const {dataContainer} = dataset;- const getPosition = this.getPositionAccessor(dataContainer);- const bounds = this.getPointsBounds(dataContainer, getPosition);- this.updateMeta({bounds});++ if (this.config.columnMode === COLUMN_MODE_GEOJSON) {+ const getFeature = this.getPositionAccessor(dataContainer);+ this._buildGeojsonDataToFeature(dataContainer, getFeature);+ this.updateMeta({bounds: this._geojsonBounds});+ } else {+ this.dataToFeature = [];+ this.centroids = [];+ const getPosition = this.getPositionAccessor(dataContainer);+ const bounds = this.getPointsBounds(dataContainer, getPosition);+ this.updateMeta({bounds});+ }+ }++ /**+ * Parse raw GeoJSON values into Feature objects and store them.+ * Re-parses when the data container size changes (new data load or column switch).+ */+ private _buildGeojsonDataToFeature(dataContainer: DataContainerInterface, getFeature: any) {+ const fieldIdx = this.config.columns.geojson.fieldIdx;+ if (+ this.dataToFeature.length === dataContainer.numRows() &&+ this._geojsonFieldIdx === fieldIdx+ ) {+ return;+ }+ this._geojsonFieldIdx = fieldIdx;+ this.dataToFeature = [];+ this.centroids = [];++ let minLng = Infinity;+ let maxLng = -Infinity;+ let minLat = Infinity;+ let maxLat = -Infinity;+ let hasValid = false;++ for (let i = 0; i < dataContainer.numRows(); i++) {+ const rawFeature = getFeature({index: i});+ const feature = parseGeoJsonRawFeature(rawFeature);+ this.dataToFeature[i] = feature;+ this.centroids[i] = feature?.geometry ? getCentroidFromGeometry(feature.geometry) : null;++ if (feature?.geometry) {+ const positions = getAllPositions(feature.geometry);+ for (const pos of positions) {+ const lng = pos[0];+ const lat = pos[1];+ if (Number.isFinite(lng) && Number.isFinite(lat)) {+ hasValid = true;+ if (lng < minLng) minLng = lng;+ if (lng > maxLng) maxLng = lng;+ if (lat < minLat) minLat = lat;+ if (lat > maxLat) maxLat = lat;+ }+ }+ }+ }++ this._geojsonBounds = hasValid ? [minLng, minLat, maxLng, maxLat] : null;}calculateDataAttribute({filteredIndex}: KeplerTable, getPosition) {+ if (this.config.columnMode === COLUMN_MODE_GEOJSON) {+ return this._calculateGeojsonDataAttribute(filteredIndex);+ }+const data: {index: number}[] = [];for (let i = 0; i < filteredIndex.length; i++) {@@ -296,6 +497,27 @@ class HeatmapLayer extends Layer {return data;}+ /**+ * For GeoJSON mode, compute the centroid of each feature's geometry+ * and emit a single heatmap data entry per feature.+ */+ private _calculateGeojsonDataAttribute(filteredIndex: number[]) {+ const data: {index: number; position: number[]}[] = [];++ for (let i = 0; i < filteredIndex.length; i++) {+ const index = filteredIndex[i];+ const feature = this.dataToFeature[index];+ if (!feature?.geometry) continue;++ const centroid = getCentroidFromGeometry(feature.geometry);+ if (centroid) {+ data.push({index, position: centroid});+ }+ }++ return data;+ }+formatLayerData(datasets: Datasets, oldLayerData: unknown): Record<string, unknown> {const {dataId} = this.config;if (!notNullorUndefined(dataId)) {@@ -308,16 +530,18 @@ class HeatmapLayer extends Layer {};const {gpuFilter, dataContainer} = dataset;- // Pass oldLayerData with the unfiltered base data so updateData's caching works correctly.- // formatLayerData returns GPU-filtered `data`, so oldLayerData.data would be the filtered- // subset. We stash the unfiltered array in `_unfiltered` to feed back to updateData.const oldData = oldLayerData as any;const baseOldLayerData = oldData?._unfiltered? {...oldData, data: oldData._unfiltered}: oldLayerData;const {data = []} = this.updateData(datasets, baseOldLayerData);- const getPosition = this.getPositionAccessor(dataContainer);++ const isGeojsonMode = this.config.columnMode === COLUMN_MODE_GEOJSON;++ const getPosition = isGeojsonMode+ ? (d: {position: number[]}) => d.position+ : this.getPositionAccessor(dataContainer);const hasFilter = Object.values(gpuFilter.filterRange).some((arr: any) =>arr.some(v => v !== 0)@@ -386,7 +610,7 @@ class HeatmapLayer extends Layer {const radiusPixels = interpolateByZoom(mapState.zoom, 0, 2, MAX_ZOOM_LEVEL, visConfig.radius);const updateTriggers = {- getPosition: this.config.columns,+ getPosition: {columns: this.config.columns, columnMode: this.config.columnMode},getWeight: {weightField: this.config.weightField}diff --git a/src/layers/src/layer-utils.ts b/src/layers/src/layer-utils.tsindex 243e22223..f523a8828 100644--- a/src/layers/src/layer-utils.ts+++ b/src/layers/src/layer-utils.ts@@ -38,6 +38,7 @@ export type FindDefaultLayerProps = {color?: RGBColor;isVisible?: boolean;columns?: Record<string, LayerColumn>;+ columnMode?: string;};export type FindDefaultLayerPropsReturnValue = {diff --git a/src/utils/src/filter-utils.ts b/src/utils/src/filter-utils.tsindex 4b9531da3..023265367 100644--- a/src/utils/src/filter-utils.ts+++ b/src/utils/src/filter-utils.ts@@ -418,6 +418,17 @@ export const getPolygonFilterFunctor = (layer, filter, dataContainer) => {return data => {return layer.isInPolygon(data, data.index, filter.value);};+ case LAYER_TYPES.heatmap:+ if (layer.centroids?.length) {+ return data => {+ const centroid = layer.centroids[data.index];+ return centroid && isInPolygon(centroid, filter.value);+ };+ }+ return data => {+ const pos = getPosition(data);+ return pos.every(Number.isFinite) && isInPolygon(pos, filter.value);+ };default:return () => true;}