Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
import test from 'tape';
import {
testCreateCases,
testFormatLayerDataCases,
testRenderLayerCases
} from 'test/helpers/layer-utils';
import {a5DefaultElevation as defaultElevation, KeplerGlLayers} from '@kepler.gl/layers';
import {getGpuFilterProps, KeplerTable} from '@kepler.gl/table';
import {processCsvData} from '@kepler.gl/processors';
import {getA5Center} from '@kepler.gl/layers';
import {a5TokenToPolygonGeo} from '../../../src/layers/src/a5-layer/a5-utils';
const {A5GeometryLayer} = KeplerGlLayers;
const dataId = 'a5-test-data';
const a5Csv = `a5,value,types
9ca4cf8000000000,0.5,type_a
1ae2968000000000,1.5,type_b
1adebc8000000000,2.5,type_a
1ae2978000000000,3.5,type_c
1ae2988000000000,4.5,type_b
100,5.5,type_a
0,6.5,type_b
`;
const {rows, fields} = processCsvData(a5Csv);
function createA5Dataset(filteredIndex) {
const dataset = new KeplerTable({
info: {id: dataId, label: 'a5-data'},
color: [255, 0, 0]
});
dataset.importData({
data: {fields, rows}
});
if (filteredIndex) {
dataset.filteredIndex = filteredIndex;
dataset.filteredIndexForDomain = filteredIndex;
}
dataset.gpuFilter = getGpuFilterProps([], dataId, dataset.fields);
return dataset;
}
test('#A5Geometry -> constructor', t => {
const TEST_CASES = [
{
props: {
dataId: 'smoothie',
isVisible: true,
label: 'test a5 layer'
},
test: layer => {
t.ok(layer.config.dataId === 'smoothie', 'A5GeometryLayer dataId should be correct');
t.ok(layer.type === 'a5', 'type should be a5');
t.deepEqual(
Object.keys(layer.visConfigSettings),
[
'opacity',
'colorRange',
'filled',
'thickness',
'strokeColor',
'strokeColorRange',
'sizeRange',
'stroked',
'enable3d',
'elevationScale',
'enableElevationZoomFactor',
'fixedHeight',
'heightRange',
'wireframe'
],
'should provide the correct visConfigSettings properties'
);
}
}
];
testCreateCases(t, A5GeometryLayer, TEST_CASES);
t.end();
});
test('#A5Geometry -> formatLayerData', t => {
const filteredIndex = [0, 2, 4, 5, 6];
const dataset = createA5Dataset(filteredIndex);
const TEST_CASES = [
{
name: 'a5 layer',
layer: {
type: 'a5',
id: 'test_layer_1',
config: {
dataId,
label: 'A5',
color: [2, 3, 4],
columns: {
token: 'a5'
},
isVisible: true
}
},
datasets: {
[dataId]: dataset
},
assert: result => {
const {layerData, layer} = result;
const expectedData = [
{index: 0, token: '9ca4cf8000000000'},
{index: 2, token: '1adebc8000000000'},
{index: 4, token: '1ae2988000000000'}
];
t.deepEqual(layerData.data, expectedData, 'should omit malformed and world cells');
t.deepEqual(layerData.getFillColor, [2, 3, 4], 'getFillColor should be a constant');
t.deepEqual(layerData.getElevation, defaultElevation, 'getElevation should be a constant');
const expectedBounds = expectedData.reduce(
(acc, d) => {
const center = getA5Center(d.token);
return [
Math.min(acc[0], center[0]),
Math.min(acc[1], center[1]),
Math.max(acc[2], center[0]),
Math.max(acc[3], center[1])
];
},
[Infinity, Infinity, -Infinity, -Infinity]
);
// Bounds are computed from all rows in updateLayerMeta, not filtered ones
t.ok(layer.meta.bounds, 'should have bounds in meta');
t.ok(layer.meta.bounds[0] <= expectedBounds[0], 'west bound');
t.ok(layer.meta.bounds[1] <= expectedBounds[1], 'south bound');
t.ok(layer.meta.bounds[2] >= expectedBounds[2], 'east bound');
t.ok(layer.meta.bounds[3] >= expectedBounds[3], 'north bound');
}
}
];
testFormatLayerDataCases(t, A5GeometryLayer, TEST_CASES);
t.end();
});
test('#A5Geometry -> renderLayer', t => {
const filteredIndex = [0, 2, 4, 5, 6];
const dataset = createA5Dataset(filteredIndex);
const TEST_CASES = [
{
name: 'a5 layer',
layer: {
type: 'a5',
id: 'test_layer_1',
config: {
dataId,
label: 'A5',
color: [2, 3, 4],
columns: {
token: 'a5'
},
isVisible: true
}
},
datasets: {
[dataId]: dataset
},
assert: (deckLayers, layer, layerData) => {
t.equal(layer.type, 'a5', 'should create 1 a5 layer');
t.equal(deckLayers.length, 4, 'Should create 4 deck.gl layers');
const expectedLayerIds = [
'test_layer_1',
'test_layer_1-cell',
'test_layer_1-cell-fill',
'test_layer_1-cell-stroke'
];
t.deepEqual(
deckLayers.map(l => l.id),
expectedLayerIds,
'should create composite A5 cell layers'
);
const sydneyCell = layerData.data[0];
const cellLayer = deckLayers.find(l => l.id === 'test_layer_1-cell');
const renderedBoundary = cellLayer.props.getPolygon(sydneyCell);
const outline = a5TokenToPolygonGeo(sydneyCell);
t.deepEqual(
Array.from(renderedBoundary),
outline.geometry.coordinates.flat(),
'rendered A5 1.0 cell matches the hover outline'
);
t.ok(
Math.abs(renderedBoundary[0] - 151.176) < 0.1 &&
Math.abs(renderedBoundary[1] + 33.878) < 0.1,
'renders the 1.0 cell in Sydney'
);
const {props: layerProps} = deckLayers[0];
const expectedProps = {
opacity: layer.config.visConfig.opacity,
filled: true,
wrapLongitude: false,
autoHighlight: false,
highlightColor: [255, 255, 255, 60],
extruded: false
};
Object.keys(expectedProps).forEach(key => {
t.deepEqual(layerProps[key], expectedProps[key], `should have correct props.${key}`);
});
}
}
];
testRenderLayerCases(t, A5GeometryLayer, TEST_CASES);
t.end();
});
test('#A5Geometry -> findDefaultLayerProps', t => {
const dataset = createA5Dataset();
const {props} = A5GeometryLayer.findDefaultLayerProps(dataset);
t.equal(props.length, 1, 'should find one A5 layer prop');
t.equal(props[0].columns.token.value, 'a5', 'should auto-detect a5 column');
t.end();
});
test('#A5Geometry -> fixed height uses source values', t => {
const dataset = new KeplerTable({info: {id: dataId}, color: [255, 0, 0]});
dataset.importData({
data: processCsvData(`token,height
1ae2958000000000,0
1ae2958000000000,10
1ae2958000000000,20
1ae2958000000000,
`)
});
dataset.gpuFilter = getGpuFilterProps([], dataId, dataset.fields);
const datasets = {[dataId]: dataset};
testFormatLayerDataCases(t, A5GeometryLayer, [
{
name: 'fixed height',
layer: {
type: 'a5',
config: {
dataId,
columns: {token: 'token'},
heightField: {name: 'height', type: 'integer'},
visConfig: {
enable3d: true,
heightRange: [0, 100],
elevationScale: 1,
enableElevationZoomFactor: false
}
}
},
datasets,
assert: ({layer, layerData}) => {
for (const globe of [false, true]) {
let previousTriggers;
for (const fixedHeight of [false, true, false]) {
layer.updateLayerVisConfig({fixedHeight});
const data = layer.formatLayerData(datasets, layerData);
const [rendered] = layer.renderLayer({
data,
idx: 0,
mapState: {zoom: 10, globe: {enabled: globe}},
gpuFilter: dataset.gpuFilter,
interactionConfig: {},
visible: true
});
t.deepEqual(
rendered.props.data.map(rendered.props.getElevation),
fixedHeight ? [0, 10, 20, 0] : [0, 50, 100, 0],
`rendered elevations ${
fixedHeight ? 'preserve source values' : 'use height range'
} (globe=${globe})`
);
const triggers = rendered.props.updateTriggers.getElevation;
if (previousTriggers) {
t.notDeepEqual(
triggers,
previousTriggers,
'toggling fixed height invalidates elevations'
);
}
previousTriggers = triggers;
}
}
layer.updateLayerVisConfig({fixedHeight: true});
layer.updateLayerConfig({heightField: null});
t.equal(
layer.formatLayerData(datasets).getElevation,
defaultElevation,
'missing height field retains the default elevation'
);
}
}
]);
t.end();
});