Skip to content

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

22.9 KB
Raw Blame
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

import test from 'tape';
import {defaultElevation, defaultLineWidth, defaultRadius, KeplerGlLayers} from '@kepler.gl/layers';
import {copyTableAndUpdate} from '@kepler.gl/table';

const {GeojsonLayer} = KeplerGlLayers;

import {updatedLayerV2} from 'test/fixtures/test-csv-data';
import {
  dataId,
  preparedGeoDataset,
  testCreateCases,
  testFormatLayerDataCases,
  testRenderLayerCases,
  prepareGeojsonDataset,
  prepareTripTableDataset,
  speedFilterDomain0,
  geoFilterDomain0,
  geojsonFilterDomain0
} from 'test/helpers/layer-utils';
import {createNewDataEntryMock} from 'test/helpers/table-utils';
import {
  updatedGeoJsonLayer,
  geoJsonWithStyle,
  geoStyleDataToFeature,
  geoStyleMeta
} from 'test/fixtures/geojson';
import {processGeojson} from '@kepler.gl/processors';

test('#GeojsonLayer -> constructor', t => {
  const TEST_CASES = {
    CREATE: [
      {
        props: {
          dataId: 'smoothie',
          isVisible: true,
          label: 'test geojson layer'
        },
        test: layer => {
          t.ok(layer.config.dataId === 'smoothie', 'geojsonLayer dataId should be correct');
          t.ok(layer.type === 'geojson', 'type should be geojson');
          t.ok(layer.isAggregated === false, 'geojsonLayer is not aggregated');
        }
      }
    ]
  };

  testCreateCases(t, GeojsonLayer, TEST_CASES.CREATE);
  t.end();
});

test('#GeojsonLayer -> formatLayerData', async t => {
  const filteredIndex = [0, 2, 4];

  const TEST_CASES = [
    {
      name: 'Geojson wkt polygon.1',
      layer: {
        type: 'geojson',
        id: 'test_geojson_layer_1',
        config: {
          color: [1, 2, 3],
          dataId,
          label: 'some geometry file',
          columns: {
            geojson: 'simplified_shape_v2'
          }
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedGeoDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;
        const expectedLayerData = {
          data: [updatedLayerV2.dataToFeature[2], updatedLayerV2.dataToFeature[4]]
        };
        const expectedDataKeys = [
          'data',
          'getElevation',
          'getElevationOffset',
          'getFillColor',
          'getFilterValue',
          'getFiltered',
          'getLineColor',
          'getLineWidth',
          'getPointRadius',
          'getPosition',
          'textLabelData',
          'textLabelFilterValue',
          'textLabelFiltered',
          'textLabels'
        ];
        const expectedLayerMeta = updatedLayerV2.meta;
        const expectedDataToFeature = updatedLayerV2.dataToFeature;

        t.deepEqual(
          Object.keys(layerData).sort(),
          expectedDataKeys,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        t.deepEqual(
          layerData.data.map(layerData.getElevation),
          [defaultElevation, defaultElevation],
          'getElevation should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getElevationOffset),
          [0, 0],
          'getElevationOffset should default to 0'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFillColor),
          [
            [1, 2, 3],
            [1, 2, 3]
          ],
          'getFillColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [Number.MIN_SAFE_INTEGER, 0, 0, 0],
            [11.8 - geoFilterDomain0, 0, 0, 0]
          ],
          'getFilterValue should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineColor),
          [
            [1, 2, 3],
            [1, 2, 3]
          ],
          'getLineColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineWidth),
          [defaultLineWidth, defaultLineWidth],
          'getLineWidth should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getPointRadius),
          [defaultRadius, defaultRadius],
          'getPointRadius should return correct value'
        );
        // meta
        t.deepEqual(layer.meta, expectedLayerMeta, 'should format correct geojson layer meta');
        // dataToFeature
        t.equal(
          layer.dataToFeature.length,
          expectedDataToFeature.length,
          'should format correct geojson dataToFeature length'
        );

        layer.dataToFeature.forEach((feature, i) => {
          t.deepEqual(
            feature,
            expectedDataToFeature[i],
            `should format correct geojson dataToFeature[${i}]`
          );
        });
      }
    },
    {
      name: 'Geojson wkt polygon.2',
      layer: {
        type: 'geojson',
        id: 'test_geojson_layer_2',
        config: {
          dataId,
          label: 'some geometry file',
          columns: {
            geojson: 'simplified_shape'
          },
          visConfig: {
            stroked: true,
            enable3d: true,
            colorRange: {
              colors: ['#010101', '#020202', '#030303']
            },
            strokeColorRange: {
              colors: ['#040404', '#050505', '#060606']
            }
          },
          // color by c_zip_type(string)
          colorField: preparedGeoDataset.fields.find(f => f.name === 'c_zip_type'),
          strokeColorField: preparedGeoDataset.fields.find(f => f.name === 'c_zip_type'),

          // stroke by c_number(real)
          sizeField: preparedGeoDataset.fields.find(f => f.name === 'c_number'),
          // stroke by a_zip(int)
          heightField: preparedGeoDataset.fields.find(f => f.name === 'a_zip')
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedGeoDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;
        const expectedLayerData = {
          data: [updatedLayerV2.dataToFeature[2], updatedLayerV2.dataToFeature[4]]
        };
        const expectedDataKeys = [
          'data',
          'getElevation',
          'getElevationOffset',
          'getFillColor',
          'getFilterValue',
          'getFiltered',
          'getLineColor',
          'getLineWidth',
          'getPointRadius',
          'getPosition',
          'textLabelData',
          'textLabelFilterValue',
          'textLabelFiltered',
          'textLabels'
        ];
        const expectedLayerMeta = updatedLayerV2.meta;
        const expectedDataToFeature = updatedLayerV2.dataToFeature;

        t.deepEqual(
          Object.keys(layerData).sort(),
          expectedDataKeys,
          'layerData should have 7 keys'
        );
        // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        t.deepEqual(
          // by a_zip
          // domain [7014, 7416]
          // [7016, 7029] -> [0, 500]
          layerData.data.map(layerData.getElevation),
          [(2 / 402) * 500, (15 / 402) * 500],
          'getElevation should return correct value'
        );
        t.deepEqual(
          // by c_zip_type
          // 'C_Medium_High' null  'A_Low_Rural',
          layerData.data.map(layerData.getFillColor),
          [
            [2, 2, 2],
            [2, 2, 2]
          ],
          'getFillColor should return correct value'
        );

        t.deepEqual(
          // by m_rate
          // 7.5 null 10
          layerData.data.map(layerData.getFilterValue),
          [
            [Number.MIN_SAFE_INTEGER, 0, 0, 0],
            [11.8 - geoFilterDomain0, 0, 0, 0]
          ],
          'getFilterValue should return correct value'
        );
        t.deepEqual(
          // by c_zip_type
          // 'C_Medium_High' null  'A_Low_Rural',
          layerData.data.map(layerData.getLineColor),
          [
            [5, 5, 5],
            [5, 5, 5]
          ],
          'getLineColor should return correct value'
        );
        t.deepEqual(
          // c_number
          // domain [13.8, 29.2]
          // range [0, 10]
          // 27.6, 39.1 -> [0, 10]
          layerData.data.map(layerData.getLineWidth),
          [8.961038961038962, 16.42857142857143],
          'getLineWidth should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getPointRadius),
          [1, 1],
          'getPointRadius should return correct value'
        );
        // meta
        t.deepEqual(layer.meta, expectedLayerMeta, 'should format correct geojson layerData');
        // dataToFeature
        t.deepEqual(
          layer.dataToFeature,
          expectedDataToFeature,
          'should format correct geojson layerData'
        );
      }
    },
    {
      name: 'Geojson wkt polygon.3',
      layer: {
        type: 'geojson',
        id: 'test_geojson_layer_3',
        config: {
          dataId,
          label: 'some geometry file',
          columns: {
            geojson: '_geojson'
          },
          color: [5, 5, 5]
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(prepareGeojsonDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;

        const expectedLayerData = {
          data: [
            updatedGeoJsonLayer.dataToFeature[0],
            updatedGeoJsonLayer.dataToFeature[2],
            updatedGeoJsonLayer.dataToFeature[4]
          ]
        };
        const expectedDataKeys = [
          'data',
          'getElevation',
          'getElevationOffset',
          'getFillColor',
          'getFilterValue',
          'getFiltered',
          'getLineColor',
          'getLineWidth',
          'getPointRadius',
          'getPosition',
          'textLabelData',
          'textLabelFilterValue',
          'textLabelFiltered',
          'textLabels'
        ];
        const expectedLayerMeta = updatedGeoJsonLayer.meta;
        const expectedDataToFeature = updatedGeoJsonLayer.dataToFeature;

        t.deepEqual(
          Object.keys(layerData).sort(),
          expectedDataKeys,
          'layerData should have 7 keys'
        );
        // // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        t.deepEqual(
          layerData.data.map(layerData.getElevation),
          [defaultElevation, defaultElevation, defaultElevation],
          'getElevation should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFillColor),
          [
            [5, 5, 5],
            [5, 5, 5],
            [5, 5, 5]
          ],
          'getFillColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [11 - geojsonFilterDomain0, 0, 0, 0],
            [20 - geojsonFilterDomain0, 0, 0, 0],
            [Number.MIN_SAFE_INTEGER, 0, 0, 0]
          ],
          'getFilterValue should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineColor),
          [
            [5, 5, 5],
            [5, 5, 5],
            [5, 5, 5]
          ],
          'getLineColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineWidth),
          [1, 1, 1],
          'getLineWidth should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getPointRadius),
          [defaultLineWidth, defaultLineWidth, defaultLineWidth],
          'getPointRadius should return correct value'
        );

        // meta
        t.deepEqual(layer.meta, expectedLayerMeta, 'should format correct geojson layer meta');
        // dataToFeature
        t.deepEqual(
          layer.dataToFeature,
          expectedDataToFeature,
          'should format correct geojson layer dataToFeature'
        );
      }
    },
    // test case 3
    {
      name: 'Geojson with style properties',
      layer: {
        type: 'geojson',
        id: 'test_geojson_layer_4',
        config: {
          dataId,
          label: 'some geometry file',
          columns: {
            geojson: '_geojson'
          },
          color: [5, 5, 5]
        }
      },
      datasets: await createNewDataEntryMock({
        info: {id: dataId},
        data: processGeojson(geoJsonWithStyle)
      }),
      assert: result => {
        const {layerData, layer} = result;

        const expectedLayerData = {
          data: geoStyleDataToFeature
        };
        const expectedDataKeys = [
          'data',
          'getElevation',
          'getElevationOffset',
          'getFillColor',
          'getFilterValue',
          'getFiltered',
          'getLineColor',
          'getLineWidth',
          'getPointRadius',
          'getPosition',
          'textLabelData',
          'textLabelFilterValue',
          'textLabelFiltered',
          'textLabels'
        ];
        const expectedLayerMeta = geoStyleMeta;

        const expectedDataToFeature = geoStyleDataToFeature;

        t.deepEqual(
          Object.keys(layerData).sort(),
          expectedDataKeys,
          'layerData should have 7 keys'
        );
        // // data
        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct geojson layerData'
        );
        t.deepEqual(
          layerData.data.map(layerData.getElevation),
          [10, 10, 10],
          'getElevation should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFillColor),
          [
            [1, 2, 3],
            [7, 8, 9],
            [1, 2, 3]
          ],
          'getFillColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0]
          ],
          'getFilterValue should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineColor),
          [
            [4, 5, 6],
            [4, 5, 6],
            [4, 5, 6]
          ],
          'getLineColor should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getLineWidth),
          [1, 3, 4],
          'getLineWidth should return correct value'
        );
        t.deepEqual(
          layerData.data.map(layerData.getPointRadius),
          [5, 5, 5],
          'getPointRadius should return correct value'
        );

        // meta
        t.deepEqual(layer.meta, expectedLayerMeta, 'should format correct geojson layer meta');
        // dataToFeature
        t.deepEqual(
          layer.dataToFeature,
          expectedDataToFeature,
          'should format correct geojson layer dataToFeature'
        );
      }
    }
  ];

  testFormatLayerDataCases(t, GeojsonLayer, TEST_CASES);
  t.end();
});

test('#GeojsonLayer -> formatLayerData -> table column mode with gpu filter', t => {
  // The GPU filter reads a layer's values through the accessor the layer hands
  // it, called as getData(dataContainer, feature, fieldIndex). Table column mode
  // groups rows by id, so the value of each channel is an array, one entry per
  // point of the grouped feature.
  const TEST_CASES = [
    {
      name: 'Geojson Table.1',
      layer: {
        type: 'geojson',
        id: 'test_geojson_table_layer',
        config: {
          dataId,
          label: 'gps tracks',
          columnMode: 'table',
          columns: {
            id: 'name',
            lat: 'location-lat',
            lng: 'location-lng',
            altitude: 'location-alt'
          }
        }
      },
      datasets: {
        [dataId]: prepareTripTableDataset
      },
      assert: result => {
        const {layerData} = result;

        let filterValues;
        t.doesNotThrow(() => {
          filterValues = layerData.data.map(layerData.getFilterValue);
        }, 'getFilterValue should not throw in table column mode');

        // The first feature groups the 8 rows named Thuub that carry a
        // coordinate; the row with an empty location is dropped.
        const round = v => Math.round(v * 100) / 100;
        const groundSpeeds = [0.22, 0.27, 0.32, 0.46, 0.51, 0.3, 0.33, 0.43];

        t.deepEqual(
          (filterValues?.[0] ?? []).map(point => round(point[0])),
          groundSpeeds.map(speed => round(speed - speedFilterDomain0)),
          'getFilterValue should return one filter value per point of the feature'
        );
      }
    }
  ];

  testFormatLayerDataCases(t, GeojsonLayer, TEST_CASES);
  t.end();
});

test('#GeojsonLayer -> renderLayer', t => {
  const filteredIndex = [0, 2, 4];
  const TEST_CASES = [
    {
      name: 'Test render geojson.1',
      layer: {
        id: 'test_layer_1',
        type: 'geojson',
        config: {
          dataId,
          color: [1, 2, 3],
          label: 'gps point',
          columns: {
            geojson: '_geojson'
          },
          isVisible: true,
          visConfig: {
            strokeColor: [4, 5, 6],
            strokeOpacity: 0.1
          }
        }
      },
      datasets: {
        [dataId]: {
          ...prepareGeojsonDataset,
          filteredIndex
        }
      },
      assert: deckLayers => {
        const ids = ['test_layer_1', 'test_layer_1-polygons-fill', 'test_layer_1-polygons-stroke'];
        t.deepEqual(
          deckLayers.map(l => l.id),
          ids,
          'Should render 3 deck layers'
        );
        t.equal(
          deckLayers[1].constructor.layerName,
          'OffsetSolidPolygonLayer',
          'polygon fill should use OffsetSolidPolygonLayer so elevation offset is applied'
        );
        // polygon fill attributes;
        const {attributes} = deckLayers[1].state.attributeManager;
        const indices = attributes.indices.value;

        const {props: fillLayerProp} = deckLayers[1];
        const {props: strokeLayerProp} = deckLayers[2];

        const expectedFillLayerProp = {
          extruded: false,
          elevationScale: 1,
          filled: false,
          wireframe: false,
          opacity: 0.8,
          parameters: {depthTest: true, depthMask: false},
          visible: true,
          autoHighlight: false,
          wrapLongitude: false,
          id: 'test_layer_1-polygons-fill',
          filterRange: [
            [0, 8],
            [0, 0],
            [0, 0],
            [0, 0]
          ]
        };

        const expectedStrokeLayerProp = {
          widthScale: 128,
          jointRounded: false,
          capRounded: false,
          miterLimit: 2,
          opacity: 0.1,
          visible: true,
          wrapLongitude: false,
          id: 'test_layer_1-polygons-stroke'
        };

        Object.keys(expectedFillLayerProp).forEach(key => {
          t.deepEqual(
            fillLayerProp[key],
            expectedFillLayerProp[key],
            `should have correct fillLayerProp.${key}`
          );
        });

        Object.keys(expectedStrokeLayerProp).forEach(key => {
          t.deepEqual(
            strokeLayerProp[key],
            expectedStrokeLayerProp[key],
            `should have correct strokeLayerProp.${key}`
          );
        });

        // test instanceFilterValues
        const expectedFilterValues = new Float32Array([
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 0
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 4
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 8
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 12
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 16
          11 - geojsonFilterDomain0,
          0,
          0,
          0, // 20
          20 - geojsonFilterDomain0,
          0,
          0,
          0, // 24
          20 - geojsonFilterDomain0,
          0,
          0,
          0, // 28
          20 - geojsonFilterDomain0,
          0,
          0,
          0, // 32
          20 - geojsonFilterDomain0,
          0,
          0,
          0, // 36
          Number.MIN_SAFE_INTEGER,
          0,
          0,
          0, // 40
          Number.MIN_SAFE_INTEGER,
          0,
          0,
          0, // 44
          Number.MIN_SAFE_INTEGER,
          0,
          0,
          0, // 48
          Number.MIN_SAFE_INTEGER,
          0,
          0,
          0 // 52
        ]);
        t.deepEqual(
          attributes.filterValues.value.slice(0, (indices.length - 1) * 4),
          expectedFilterValues,
          'Should have correct filterValues'
        );
      }
    }
  ];

  testRenderLayerCases(t, GeojsonLayer, TEST_CASES);
  t.end();
});

test('#GeojsonLayer -> hover overlay caches outline data', t => {
  const layer = new GeojsonLayer({id: 'hover_geojson'});
  const polygonFeature = {
    type: 'Feature',
    properties: {index: 0},
    geometry: {
      type: 'Polygon',
      coordinates: [
        [
          [0, 0],
          [1, 0],
          [1, 1],
          [0, 0]
        ]
      ]
    }
  };
  const objectHovered = {
    picked: true,
    index: 0,
    layer: {props: {id: 'hover_geojson'}},
    object: polygonFeature
  };

  const first = layer._getHoverOverlayData(objectHovered);
  const second = layer._getHoverOverlayData({...objectHovered});

  t.ok(first, 'should create hover overlay data');
  t.equal(first, second, 'should reuse hover overlay data for the same feature across redraws');
  t.equal(
    first[0].geometry.type,
    'MultiLineString',
    'should stroke polygons as lines so hover overlay skips fill tessellation'
  );
  t.deepEqual(
    first[0].geometry.coordinates,
    polygonFeature.geometry.coordinates,
    'should keep polygon rings as line coordinates'
  );

  const other = layer._getHoverOverlayData({
    ...objectHovered,
    index: 1,
    object: {...polygonFeature, properties: {index: 1}}
  });
  t.notEqual(first, other, 'should rebuild hover overlay data when the hovered feature changes');

  const multi = layer._getHoverOverlayData({
    picked: true,
    index: 2,
    layer: {props: {id: 'hover_geojson'}},
    object: {
      type: 'Feature',
      properties: {index: 2},
      geometry: {
        type: 'MultiPolygon',
        coordinates: [
          [
            [
              [0, 0],
              [1, 0],
              [1, 1],
              [0, 0]
            ]
          ],
          [
            [
              [2, 2],
              [3, 2],
              [3, 3],
              [2, 2]
            ]
          ]
        ]
      }
    }
  });
  t.equal(
    multi[0].geometry.type,
    'MultiLineString',
    'should flatten MultiPolygon rings into lines'
  );
  t.equal(multi[0].geometry.coordinates.length, 2, 'should keep one line per polygon ring');

  t.equal(
    layer._getHoverOverlayData({...objectHovered, picked: false}),
    null,
    'should clear hover overlay data when nothing is picked'
  );
  t.end();
});