Skip to content

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.tsx
index 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.ts
index 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.ts
index 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 project
import 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_GEOARROW
geoarrow: 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-vars
const {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.ts
index 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.ts
index 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;
}