Skip to content

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

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

import test from 'tape';
import moment from 'moment';

import {
  testCreateCases,
  testFormatLayerDataCases,
  testRenderLayerCases,
  preparedDataset,
  dataId,
  testRows,
  preparedFilterDomain0
} from 'test/helpers/layer-utils';
import {s2DefaultElevation as defaultElevation, KeplerGlLayers} from '@kepler.gl/layers';
import {copyTableAndUpdate, getGpuFilterProps, KeplerTable} from '@kepler.gl/table';
import {processCsvData} from '@kepler.gl/processors';
import {createDataContainer} from '@kepler.gl/utils';
import {INITIAL_MAP_STATE, INITIAL_VIS_STATE} from '@kepler.gl/reducers';

const {S2GeometryLayer} = KeplerGlLayers;

test('#S2Geometry -> constructor', t => {
  const TEST_CASES = [
    {
      props: {
        dataId: 'smoothie',
        isVisible: true,
        label: 'text s2geometry layer'
      },
      test: layer => {
        t.ok(layer.config.dataId === 'smoothie', 'S2GeometryLayer dataId should be correct');
        t.ok(layer.type === 's2', 'type should be s2');
        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, S2GeometryLayer, TEST_CASES);
  t.end();
});

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

  const TEST_CASES = [
    {
      name: 's2 layer',
      layer: {
        type: 's2',
        id: 'test_layer_1',
        config: {
          dataId,
          label: 'S2',
          color: [2, 3, 4],
          columns: {
            token: 's2x'
          },
          isVisible: true
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData, layer} = result;
        const expectedLayerData = {
          data: [
            {index: 0, token: '80858004'},
            {index: 4, token: '8085801c'}
          ],
          getElevation: () => {},
          getFillColor: () => {},
          getFilterValue: () => {},
          getS2Token: () => {},
          getLineColor: () => {},
          getLineWidth: () => {}
        };

        // test layer.meta
        t.deepEqual(
          layer.meta,
          {
            bounds: [-122.38442501650697, 37.79109908631398, -122.3617617587711, 37.81968456730113]
          },
          'should format correct S2 layer meta'
        );

        t.deepEqual(
          layerData.data,
          expectedLayerData.data,
          'should format correct s2-geometry layerData'
        );

        t.deepEqual(
          Object.keys(layerData).sort(),
          Object.keys(expectedLayerData).sort(),
          `layerData should have ${expectedLayerData.length} keys`
        );

        t.deepEqual(layerData.getFillColor, [2, 3, 4], 'getFillColor should be a constant');
        t.deepEqual(layerData.getElevation, defaultElevation, 'getElevation should be a constant');
        t.deepEqual(
          layerData.data.map(layerData.getS2Token),
          ['80858004', '8085801c'],
          'getS2Token should return correct token'
        );
        // getFilterValue
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [Number.MIN_SAFE_INTEGER, 0, 0, 0],
            [moment.utc(testRows[4][0]).valueOf() - preparedFilterDomain0, 0, 0, 0]
          ],
          'getFilterValue should return [value, 0, 0, 0]'
        );
      }
    },
    {
      name: 's2 layer',
      layer: {
        type: 's2',
        id: 'test_layer_1',
        config: {
          dataId,
          label: 'S2',
          color: [2, 3, 4],
          columns: {
            token: 's2x'
          },
          isVisible: true,
          // color by types(string)
          colorField: {
            type: 'string',
            name: 'types'
          },
          // size by id(integer)
          heightField: {
            type: 'real',
            name: 'trip_distance'
          },
          sizeField: {
            type: 'real',
            name: 'trip_distance'
          },
          visConfig: {
            colorRange: {
              colors: ['#010101', '#020202', '#030303']
            },
            elevationRange: [10, 20],
            sizeRange: [10, 20],
            enable3d: true
          }
        }
      },
      datasets: {
        [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
      },
      assert: result => {
        const {layerData} = result;
        // getFillColor
        // domain: ['driver_analytics', 'driver_analytics_0', 'driver_gps']
        // range ['#010101', '#020202', '#030303']
        t.deepEqual(
          layerData.data.map(layerData.getFillColor),
          [
            [2, 2, 2],
            [1, 1, 1]
          ],
          'getFillColor should be correct'
        );

        // getElevation
        // domain: [1.59, 11]
        // range: [0, 500]
        // value [1.59, 2.37]
        t.deepEqual(
          layerData.data.map(layerData.getElevation),
          [0, 41.445270988310305],
          'getElevation should correct'
        );

        // getLineWidth
        // domain: [1.59, 11]
        // range: [10, 20]
        // value [1.59, 2.37]
        t.deepEqual(
          layerData.data.map(layerData.getLineWidth),
          [10, (2.37 - 1.59) * (10 / 9.41) + 10],
          'getLineWidth should be correct'
        );

        // getFilterValue
        t.deepEqual(
          layerData.data.map(layerData.getFilterValue),
          [
            [Number.MIN_SAFE_INTEGER, 0, 0, 0],
            [moment.utc(testRows[4][0]).valueOf() - preparedFilterDomain0, 0, 0, 0]
          ],
          'getFilterValue should return [value, 0, 0, 0]'
        );
      }
    }
  ];

  testFormatLayerDataCases(t, S2GeometryLayer, TEST_CASES);

  t.end();
});

test('#S2Geometry -> renderLayer', t => {
  const filteredIndex = [0, 2, 4];

  const TEST_CASES = [
    {
      name: 's2 layer',
      layer: {
        type: 's2',
        id: 'test_layer_1',
        config: {
          dataId,
          label: 'S2',
          color: [2, 3, 4],
          columns: {
            token: 's2x'
          },
          isVisible: true
        }
      },
      datasets: {
        [dataId]: {
          ...preparedDataset,
          filteredIndex
        }
      },
      assert: (deckLayers, layer) => {
        t.equal(layer.type, 's2', 'should create 1 s2 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 1 composite, 1 hexagon-cell layer'
        );

        const {props: layerProps} = deckLayers[0];

        const expectedProps = {
          opacity: layer.config.visConfig.opacity,
          filterRange: preparedDataset.gpuFilter.filterRange,
          filled: true,
          wrapLongitude: false,
          autoHighlight: false,
          highlightColor: [255, 255, 255, 60],
          extruded: false,
          elevationScale: 5
        };

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

  testRenderLayerCases(t, S2GeometryLayer, TEST_CASES);

  t.end();
});

test('#S2Geometry -> fixed height uses source values', t => {
  const dataset = new KeplerTable({info: {id: dataId}, color: [255, 0, 0]});
  dataset.importData({
    data: processCsvData(`token,height
8085801c,0
8085801c,10
8085801c,20
8085801c,
`)
  });
  dataset.gpuFilter = getGpuFilterProps([], dataId, dataset.fields);
  const datasets = {[dataId]: dataset};

  testFormatLayerDataCases(t, S2GeometryLayer, [
    {
      name: 'fixed height',
      layer: {
        type: 's2',
        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();
});

test('#S2Geometry -> invalid non-hex tokens never reach polygon generation', t => {
  const valid = ['80858004', "'80858004'", '"8085801c"', '8085801c'];
  const invalid = ['zz', 'unknown', '8085800g', "'zz'", '"unknown"', '', null, undefined, 80858004];
  const field = preparedDataset.fields.find(candidate => candidate.name === 's2x');
  const makeDataset = tokens =>
    copyTableAndUpdate(preparedDataset, {
      dataContainer: createDataContainer(
        tokens.map(token => {
          const row = [...testRows[0]];
          row[field.fieldIdx] = token;
          return row;
        })
      ),
      filteredIndex: tokens.map((_, index) => index)
    });
  const formatAndRender = tokens => {
    const dataset = makeDataset(tokens);
    const layer = new S2GeometryLayer({id: 's2-token-validation', dataId});
    layer.updateLayerConfig({columns: {token: {value: field.name, fieldIdx: field.fieldIdx}}});
    const data = layer.formatLayerData({[dataId]: dataset});
    const [rendered] = layer.renderLayer({
      data,
      gpuFilter: dataset.gpuFilter,
      interactionConfig: INITIAL_VIS_STATE.interactionConfig,
      mapState: INITIAL_MAP_STATE,
      visible: true
    });
    // This invokes deck.gl's actual S2 token-to-polygon conversion, without a WebGL draw.
    const {getPolygon} = rendered.indexToBounds();
    const polygons = rendered.props.data.map((row, index) => Array.from(getPolygon(row, {index})));
    return {layer, data, polygons};
  };

  const baseline = formatAndRender(valid);
  t.equal(baseline.polygons.length, valid.length, 'valid and quoted tokens generate polygons');
  t.deepEqual(
    baseline.polygons[0],
    baseline.polygons[1],
    'single-quoted token preserves its geometry'
  );
  t.deepEqual(
    baseline.polygons[2],
    baseline.polygons[3],
    'double-quoted token preserves its geometry'
  );
  t.ok(
    baseline.polygons.every(polygon => polygon.length >= 10 && polygon.every(Number.isFinite)),
    'valid geometry has finite coordinates'
  );

  const mixed = formatAndRender([...valid, ...invalid]);
  t.deepEqual(
    mixed.data.data.map(row => row.index),
    [0, 1, 2, 3],
    'invalid and missing tokens are filtered out'
  );
  t.deepEqual(mixed.polygons, baseline.polygons, 'invalid tokens produce no extra polygons');
  t.deepEqual(
    mixed.layer.meta.bounds,
    baseline.layer.meta.bounds,
    'invalid tokens cannot distort map bounds'
  );

  const empty = formatAndRender(invalid);
  t.deepEqual(empty.data.data, [], 'an invalid-only dataset has no renderable cells');
  t.deepEqual(empty.polygons, [], 'an invalid-only dataset creates no polygons');
  t.deepEqual(formatAndRender([]).polygons, [], 'an empty dataset creates no polygons');
  t.end();
});