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 moment from 'moment';
import * as arrow from 'apache-arrow';
import {ArcLayer as DeckArcLayer} from '@deck.gl/layers';
import {GeoArrowArcLayer} from '@kepler.gl/deckgl-arrow-layers';
import {EnhancedLineLayer, FilterArrowExtension} from '@kepler.gl/deckgl-layers';
import {
testCreateCases,
testFormatLayerDataCases,
testRenderLayerCases,
dataId,
testRows,
preparedDataset,
arcLayerMeta
} from 'test/helpers/layer-utils';
import {PROJECTED_PIXEL_SIZE_MULTIPLIER} from '@kepler.gl/constants';
import {KeplerGlLayers} from '@kepler.gl/layers';
import {INITIAL_MAP_STATE, INITIAL_VIS_STATE} from '@kepler.gl/reducers';
import {KeplerTable, copyTable, copyTableAndUpdate} from '@kepler.gl/table';
const {LineLayer} = KeplerGlLayers;
const columns = {
lat0: 'lat',
lng0: 'lng',
lat1: 'lat_1',
lng1: 'lng_1'
};
test('#LineLayer -> constructor', t => {
const TEST_CASES = {
CREATE: [
{
props: {
dataId: 'smoothie',
isVisible: true,
label: 'test line layer'
},
test: layer => {
t.ok(layer.config.dataId === 'smoothie', 'LineLayer dataId should be correct');
t.ok(layer.type === 'line', 'type should be line');
t.ok(layer.isAggregated === false, 'LineLayer is not aggregated');
t.ok(layer.config.label === 'test line layer', 'label should be correct');
t.ok(Object.keys(layer.columnPairs).length, 'should have columnPairs');
t.equal(layer.config.visConfig.targetArrowEnabled, false, 'target arrow is off');
t.equal(
layer.visConfigSettings.targetArrowSize.allowCustomValue,
false,
'arrow size has no custom input'
);
}
}
]
};
testCreateCases(t, LineLayer, TEST_CASES.CREATE);
t.end();
});
test('#LineLayer -> formatLayerData', t => {
const filteredIndex = [0, 2, 4];
const filterDomain0 = 1474071056000;
const TEST_CASES = [
{
name: 'Line trip data.1',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10]
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
},
assert: result => {
const {layerData, layer} = result;
const expectedLayerData = {
data: [
{
index: 0,
sourcePosition: [testRows[0][2], testRows[0][1], 0],
targetPosition: [testRows[0][4], testRows[0][3], 0]
},
{
index: 4,
sourcePosition: [testRows[4][2], testRows[4][1], 0],
targetPosition: [testRows[4][4], testRows[4][3], 0]
}
],
getFilterValue: () => {},
getFiltered: () => {},
getColor: () => {},
getTargetColor: () => {},
getWidth: () => {}
};
const expectedDataKeys = Object.keys(expectedLayerData).sort();
t.deepEqual(
Object.keys(layerData).sort(),
expectedDataKeys,
'layerData should have 6 keys'
);
t.deepEqual(layerData.data, expectedLayerData.data, 'should format correct line layerData');
// getColor
t.deepEqual(layerData.getColor, layer.config.color, 'getColor should be a constant');
// getTargetColor
t.deepEqual(
layerData.getTargetColor,
layer.config.color,
'getTargetColors should be a constant'
);
// getWidth
t.equal(layerData.getWidth, 1, 'getWidth should be a constant');
// getFilterValue
t.deepEqual(
layerData.data.map(layerData.getFilterValue),
[
[Number.MIN_SAFE_INTEGER, 0, 0, 0],
[moment.utc(testRows[4][0]).valueOf() - filterDomain0, 0, 0, 0]
],
'getFilterValue should return [value, 0, 0, 0]'
);
// layerMeta
t.deepEqual(layer.meta, arcLayerMeta, 'should format correct arc layer meta');
}
},
{
name: 'Lind trip data.2 targetColor',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
visConfig: {
targetColor: [1, 2, 3]
}
},
type: 'line',
id: 'test_layer_2'
},
datasets: {
[dataId]: copyTable(preparedDataset)
},
assert: result => {
const {layerData, layer} = result;
const expectedLayerData = {
data: [],
getFilterValue: () => {},
getFiltered: () => {},
getColor: () => {},
getTargetColor: () => {},
getWidth: () => {}
};
const expectedDataKeys = Object.keys(expectedLayerData).sort();
t.deepEqual(
Object.keys(layerData).sort(),
expectedDataKeys,
'layerData should have 6 keys'
);
// getColor
t.deepEqual(layerData.getColor, layer.config.color, 'getColor should be a constant');
// getColor
t.deepEqual(layerData.getTargetColor, [1, 2, 3], 'getTargetColors should be a constant');
}
},
{
name: 'Line trip data. with colorField and sizeField',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
// color by id(integer)
colorField: {
type: 'string',
name: 'types'
},
// size by id(integer)
sizeField: {
type: 'real',
name: 'trip_distance'
},
visConfig: {
colorRange: {
colors: ['#010101', '#020202', '#030303']
},
sizeRange: [10, 20]
}
},
type: 'line',
id: 'test_layer_1'
},
datasets: {
[dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
},
assert: result => {
const {layerData} = result;
const expectedLayerData = {
data: [
{
index: 0,
sourcePosition: [testRows[0][2], testRows[0][1], 0],
targetPosition: [testRows[0][4], testRows[0][3], 0]
},
{
index: 4,
sourcePosition: [testRows[4][2], testRows[4][1], 0],
targetPosition: [testRows[4][4], testRows[4][3], 0]
}
],
getFilterValue: () => {},
getFiltered: () => {},
getColor: () => {},
getTargetColor: () => {},
getWidth: () => {}
};
const expectedDataKeys = Object.keys(expectedLayerData).sort();
t.deepEqual(
Object.keys(layerData).sort(),
expectedDataKeys,
'layerData should have 6 keys'
);
t.deepEqual(
layerData.data,
expectedLayerData.data,
'should format correct line layerData data'
);
// getColor
// domain: ['driver_analytics', 'driver_analytics_0', 'driver_gps']
// range ['#010101', '#020202', '#030303']
t.deepEqual(
layerData.data.map(layerData.getColor),
[
[2, 2, 2],
[1, 1, 1]
],
'getColor should be correct'
);
// getTargetColor
// domain: ['driver_analytics', 'driver_analytics_0', 'driver_gps']
// range ['#010101', '#020202', '#030303']
t.deepEqual(
layerData.data.map(layerData.getTargetColor),
[
[2, 2, 2],
[1, 1, 1]
],
'getTargetColors be correct'
);
// getWidth
// domain: [1.59, 11]
// range: [10, 20]
// value [1.59, 2.37]
t.deepEqual(
layerData.data.map(layerData.getWidth),
[10, (2.37 - 1.59) * (10 / 9.41) + 10],
'getWidth should be a constant'
);
// getFilterValue
t.deepEqual(
layerData.data.map(layerData.getFilterValue),
[
[Number.MIN_SAFE_INTEGER, 0, 0, 0],
[moment.utc(testRows[4][0]).valueOf() - filterDomain0, 0, 0, 0]
],
'getFilterValue should return [value, 0, 0, 0]'
);
}
}
];
testFormatLayerDataCases(t, LineLayer, TEST_CASES);
t.end();
});
test('#LineLayer -> renderLayer', t => {
const filteredIndex = [0, 2, 4];
const TEST_CASES = [
{
name: 'Line render layer.1',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10]
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
assert: (deckLayers, layer) => {
t.equal(deckLayers.length, 1, 'Should create 1 deck.gl layer');
const {props} = deckLayers[0];
// test instancePositions
t.equal(props.opacity, layer.config.visConfig.opacity, 'should calculate correct opacity');
t.equal(
props.widthScale,
layer.config.visConfig.thickness * PROJECTED_PIXEL_SIZE_MULTIPLIER,
'should apply correct widthScale'
);
t.equal(
props.filterRange,
preparedDataset.gpuFilter.filterRange,
'should supply correct filterRange'
);
}
},
{
name: 'Line render layer.2 brushing',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10]
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
renderArgs: {
interactionConfig: {
brush: {
enabled: true,
config: {
size: 2.5
}
}
}
},
assert: deckLayers => {
t.equal(deckLayers.length, 1, 'Should create 1 deck.gl layer');
const {props} = deckLayers[0];
// test instancePositions
t.equal(props.brushingRadius, 2500, 'should supply brushingRadius');
t.equal(props.brushingEnabled, true, 'should have brushingEnabled: true');
t.equal(props.brushingTarget, 'source_target', 'brushingTarget: should be source');
}
},
{
name: 'Line render layer.3 target arrow',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
visConfig: {
targetArrowEnabled: true,
targetArrowShape: 'triangle',
targetArrowSize: 20,
targetColor: [200, 30, 30]
}
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
assert: deckLayers => {
t.equal(deckLayers.length, 2, 'Should create the line and an arrow head');
const arrowLayer = deckLayers[deckLayers.length - 1];
t.equal(arrowLayer.id, 'test_layer_0-arrow-head-triangle', 'arrow layer id');
t.equal(arrowLayer.props.pickable, false, 'arrow head does not take the line hover');
const radius =
typeof arrowLayer.props.getRadius === 'function'
? arrowLayer.props.getRadius(arrowLayer.props.data[0])
: arrowLayer.props.getRadius;
t.equal(radius, 20, 'arrow size is the vis config value in pixels');
t.equal(arrowLayer.props.iconGeometry.length, 9, 'triangle is one triangle');
t.ok(
Number.isFinite(arrowLayer.props.getAngle(arrowLayer.props.data[0])),
'arrow angle is finite'
);
const fill =
typeof arrowLayer.props.getFillColor === 'function'
? arrowLayer.props.getFillColor(arrowLayer.props.data[0])
: arrowLayer.props.getFillColor;
t.deepEqual(fill, [200, 30, 30], 'arrow uses the target color');
}
},
{
name: 'Line render layer.4 target arrow hover',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
visConfig: {
targetArrowEnabled: true,
targetArrowShape: 'triangle',
targetArrowSize: 20
}
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
renderArgs: {
objectHovered: {
picked: true,
object: {
index: 0,
sourcePosition: [-122.4, 37.8, 0],
targetPosition: [-122.3, 37.9, 0]
},
layer: {props: {id: 'test_layer_0'}}
}
},
assert: deckLayers => {
t.equal(deckLayers.length, 4, 'Should add a highlight stroke and a highlight arrow');
const arrowLayer = deckLayers[deckLayers.length - 1];
t.equal(arrowLayer.id, 'test_layer_0-arrow-head-triangle-hovered', 'highlight arrow id');
t.equal(arrowLayer.props.data.length, 1, 'highlight arrow is only the hovered stroke');
const color =
typeof arrowLayer.props.getFillColor === 'function'
? arrowLayer.props.getFillColor(arrowLayer.props.data[0])
: arrowLayer.props.getFillColor;
t.deepEqual(color, [252, 242, 26, 255], 'highlight arrow uses the layer highlight color');
}
},
{
name: 'Line render layer.5 target arrow hover on globe',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
visConfig: {
targetArrowEnabled: true,
targetArrowShape: 'triangle',
targetArrowSize: 20
}
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
renderArgs: {
mapState: {...INITIAL_MAP_STATE, globe: {enabled: true}},
objectHovered: {
picked: true,
object: {
index: 0,
sourcePosition: [-122.4, 37.8, 0],
targetPosition: [-122.3, 37.9, 0]
},
layer: {props: {id: 'test_layer_0-globe'}}
}
},
assert: deckLayers => {
t.equal(deckLayers.length, 4, 'Should add globe highlight stroke and arrow');
t.equal(deckLayers[1].id, 'test_layer_0-globe-hovered', 'globe highlight stroke id');
t.equal(
deckLayers[3].id,
'test_layer_0-arrow-head-triangle-hovered',
'globe highlight arrow id'
);
}
},
{
name: 'Line render layer.6 preserves globe behavior with target arrow disabled',
layer: {
config: {
dataId,
label: 'trip lines',
columns,
color: [10, 10, 10],
visConfig: {
targetArrowEnabled: false,
targetColor: [200, 30, 30]
}
},
type: 'line',
id: 'test_layer_0'
},
datasets: {
[dataId]: {
...preparedDataset,
filteredIndex
}
},
renderArgs: {
mapState: {...INITIAL_MAP_STATE, globe: {enabled: true}},
objectHovered: {
picked: true,
object: {
index: 0,
sourcePosition: [-122.4, 37.8, 0],
targetPosition: [-122.3, 37.9, 0]
},
layer: {props: {id: 'test_layer_0-globe'}}
}
},
assert: deckLayers => {
t.equal(deckLayers.length, 1, 'Should keep the original globe stroke only');
t.deepEqual(
deckLayers[0].props.getTargetColor,
[10, 10, 10],
'disabled arrow keeps the original solid line color'
);
}
}
];
testRenderLayerCases(t, LineLayer, TEST_CASES);
t.end();
});
test('#LineLayer -> Arrow positions, accessors and picking on map and globe', t => {
const positions = [
[
[20, 10, 0],
[40, 30, 0]
],
[
[0, 0, 0],
[50, 40, 0]
],
[
[60, 50, 0],
[80, 70, 0]
]
];
const pointType = new arrow.FixedSizeList(3, new arrow.Field('xyz', new arrow.Float64()));
for (const columnMode of ['points', 'geoarrow']) {
const chunks = [positions.slice(0, 2), positions.slice(2)].map(rows =>
columnMode === 'geoarrow'
? new arrow.Table({
source: arrow.vectorFromArray(
rows.map(row => row[0]),
pointType
),
target: arrow.vectorFromArray(
rows.map(row => row[1]),
pointType
),
weight: arrow.vectorFromArray(rows.map(row => positions.indexOf(row) + 1))
})
: arrow.tableFromArrays({
lat0: rows.map(row => row[0][1]),
lng0: rows.map(row => row[0][0]),
lat1: rows.map(row => row[1][1]),
lng1: rows.map(row => row[1][0]),
weight: rows.map(row => positions.indexOf(row) + 1)
})
);
const table = new arrow.Table(chunks.flatMap(chunk => chunk.batches));
const dataset = new KeplerTable({info: {id: 'arrow-lines'}, color: [0, 0, 0]});
dataset.updateSchema({
fields: table.schema.fields.map(field => ({name: field.name, type: 'real'})),
cols: table.schema.fields.map((field, index) => table.getChildAt(index)),
arrowTable: table
});
if (columnMode === 'geoarrow') {
// Progressive loads retain batches until compaction when loading completes.
dataset.dataContainer.update(table);
}
dataset.filteredIndex = [0, 2];
const layer = new LineLayer({dataId: dataset.id, columnMode});
layer.updateLayerConfig({
columns: Object.fromEntries(
(columnMode === 'geoarrow'
? [
['geoarrow0', 'source'],
['geoarrow1', 'target']
]
: ['lat0', 'lng0', 'lat1', 'lng1'].map(name => [name, name])
).map(([key, name], fieldIdx) => [key, {value: name, fieldIdx}])
)
});
layer.updateLayerConfig({
sizeField: dataset.fields[dataset.fields.length - 1],
sizeDomain: [1, 3]
});
layer.updateLayerVisConfig({sizeRange: [2, 6]});
const data = layer.formatLayerData({[dataset.id]: dataset});
t.equal(data.data.numRows, 3, `${columnMode}: format preserves all Arrow rows`);
for (const globeEnabled of [false, true]) {
const label = `${columnMode}, globe=${globeEnabled}`;
const [rendered] = layer.renderLayer({
data,
dataset,
gpuFilter: dataset.gpuFilter,
interactionConfig: INITIAL_VIS_STATE.interactionConfig,
mapState: {...INITIAL_MAP_STATE, globe: {enabled: globeEnabled}},
layerCallbacks: {},
visible: true,
idx: 0
});
const actualSource =
rendered.props.getSourcePosition instanceof arrow.Vector
? Array.from(rendered.props.getSourcePosition.get(0))
: rendered.props.getSourcePosition(data.data.get(0));
t.deepEqual(actualSource, positions[0][0], `${label}: valid source reaches renderer`);
t.ok(rendered instanceof GeoArrowArcLayer, `${label}: uses Arrow renderer`);
if (!(rendered instanceof GeoArrowArcLayer)) {
continue;
}
t.ok(
rendered.props.extensions.some(extension => extension instanceof FilterArrowExtension),
`${label}: applies Arrow CPU filtering`
);
const sublayers = rendered.renderLayers();
t.equal(sublayers.length, columnMode === 'geoarrow' ? 2 : 1, `${label}: renders every batch`);
let offset = 0;
sublayers.forEach(sublayer => {
t.ok(
sublayer instanceof (globeEnabled ? DeckArcLayer : EnhancedLineLayer),
`${label}: preserves projection-specific stroke`
);
if (globeEnabled) {
t.equal(sublayer.props.getHeight, 0, 'globe stroke stays on the sphere');
t.equal(sublayer.props.parameters.cull, false, 'globe stroke disables backface culling');
}
const {data: batchData} = sublayer.props;
for (let index = 0; index < batchData.length; index++) {
const globalIndex = offset + index;
for (const [accessor, endpoint] of [
['getSourcePosition', 0],
['getTargetPosition', 1]
]) {
const attribute = batchData.attributes[accessor];
t.deepEqual(
Array.from(
attribute.value.slice(index * attribute.size, (index + 1) * attribute.size)
),
positions[globalIndex][endpoint],
`${label}: ${accessor} at row ${globalIndex}`
);
}
t.equal(
sublayer.props.getFiltered(null, {index, data: batchData}),
globalIndex === 1 ? 0 : 1,
`${label}: filter accessor uses global row ${globalIndex}`
);
t.equal(
sublayer.props.getWidth(null, {index, data: batchData}),
(globalIndex + 1) * 2,
`${label}: width accessor uses global row ${globalIndex}`
);
const picked = rendered.getPickingInfo({
info: {index, picked: true},
sourceLayer: sublayer
});
t.equal(picked.index, globalIndex, `${label}: picking uses global row ${globalIndex}`);
t.deepEqual(
layer.getHoverData(picked.object, dataset.dataContainer, dataset.fields, {}, picked),
dataset.dataContainer.row(globalIndex),
`${label}: hover data matches picked row`
);
}
offset += batchData.length;
});
}
}
t.end();
});