Skip to content

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

[FEAT] support domain.domainStops in layer color, render color legend based on zoom (#2815)

Igor Dykhtac4d1cfff02bb
diff --git a/src/components/src/common/color-legend.tsx b/src/components/src/common/color-legend.tsx
index 1cb94dbdc..f770218ab 100644
--- a/src/components/src/common/color-legend.tsx
+++ b/src/components/src/common/color-legend.tsx
@@ -16,7 +16,7 @@ import {Reset} from './icons';
import {InlineInput} from './styled-components';
const ROW_H = 15;
-const GAP = 4;
+const GAP = 2;
const RECT_W = 20;
const stopClickPropagation = e => e.stopPropagation();
@@ -224,15 +224,15 @@ function overrideByCustomLegend({colorLegends, currentLegends}: OverrideByCustom
}
export function useLayerColorLegends(
- layer,
- scaleType,
- domain,
- range,
- isFixed,
- fieldType,
- labelFormat,
- mapState
-) {
+ layer: ColorLegendProps['layer'],
+ scaleType: ColorLegendProps['scaleType'],
+ domain: ColorLegendProps['domain'],
+ range: ColorLegendProps['range'],
+ isFixed: ColorLegendProps['isFixed'],
+ fieldType: ColorLegendProps['fieldType'],
+ labelFormat: ColorLegendProps['labelFormat'],
+ mapState: ColorLegendProps['mapState']
+): Legend[] {
const scale = useMemo(
() => getLayerColorScale({range, domain, scaleType, isFixed, layer}),
[range, domain, scaleType, isFixed, layer]
@@ -260,7 +260,7 @@ export function useLayerColorLegends(
return LegendsWithCustomLegends;
}
-type ColorLegendProps = {
+export type ColorLegendProps = {
layer: Layer;
scaleType: string;
domain: number[] | string[];
@@ -274,6 +274,12 @@ type ColorLegendProps = {
onUpdateColorLegend?: (colorLegends: {[key: HexColor]: string}) => void;
};
+export type Legend = {
+ data: string;
+ label: string;
+ override?: boolean;
+};
+
ColorLegendFactory.deps = [LegendRowFactory];
function ColorLegendFactory(LegendRow: ReturnType<typeof LegendRowFactory>) {
const ColorLegend: React.FC<ColorLegendProps> = ({
diff --git a/src/components/src/map/layer-hover-info.tsx b/src/components/src/map/layer-hover-info.tsx
index cdf5cb632..01ecd9168 100644
--- a/src/components/src/map/layer-hover-info.tsx
+++ b/src/components/src/map/layer-hover-info.tsx
@@ -3,18 +3,21 @@
import React, {useMemo} from 'react';
import styled from 'styled-components';
-import {TooltipField} from '@kepler.gl/types';
+import {CompareType, Field, Merge, TooltipField} from '@kepler.gl/types';
import {CenterFlexbox} from '../common/styled-components';
import {Layers} from '../common/icons';
import PropTypes from 'prop-types';
import {notNullorUndefined} from '@kepler.gl/common-utils';
+import {DataRow} from '@kepler.gl/utils';
import {Layer} from '@kepler.gl/layers';
import {
AggregationLayerHoverData,
+ LayerHoverProp,
getTooltipDisplayDeltaValue,
getTooltipDisplayValue
} from '@kepler.gl/reducers';
import {useIntl} from 'react-intl';
+import {VisState} from '@kepler.gl/schemas';
import {capitalizeFirstLetter} from '@kepler.gl/utils';
export const StyledLayerName = styled(CenterFlexbox)`
@@ -99,36 +102,55 @@ const Row: React.FC<RowProps> = ({name, value, deltaValue, url}) => {
);
};
-const EntryInfo = ({fieldsToShow, fields, data, primaryData, compareType}) => (
+export type EntryInfoProps = Merge<LayerHoverProp, {fieldsToShow: TooltipField[]}>;
+
+const EntryInfo: React.FC<EntryInfoProps> = ({fieldsToShow, ...props}) => (
<tbody>
{fieldsToShow.map(item => (
- <EntryInfoRow
- key={item.name}
- item={item}
- fields={fields}
- data={data}
- primaryData={primaryData}
- compareType={compareType}
- />
+ <EntryInfoRow key={item.name} item={item} {...props} />
))}
</tbody>
);
-const EntryInfoRow = ({item, fields, data, primaryData, compareType}) => {
+export type EntryInfoRowProps = {
+ data: LayerHoverProp['data'];
+ fields: Field[];
+ layer: Layer;
+ primaryData?: LayerHoverProp['primaryData'];
+ compareType?: CompareType;
+ currentTime?: VisState['animationConfig']['currentTime'];
+ item: TooltipField;
+};
+
+const EntryInfoRow: React.FC<EntryInfoRowProps> = ({
+ layer,
+ item,
+ fields,
+ data,
+ primaryData,
+ compareType,
+ currentTime
+}) => {
const fieldIdx = fields.findIndex(f => f.name === item.name);
if (fieldIdx < 0) {
return null;
}
const field = fields[fieldIdx];
- const value = data.valueAt(fieldIdx);
+ const fieldValueAccessor = layer.accessVSFieldValue(field, currentTime);
+ const value = fieldValueAccessor(field, data instanceof DataRow ? {index: data._rowIndex} : data);
+ const primaryValue = primaryData
+ ? fieldValueAccessor(
+ field,
+ primaryData instanceof DataRow ? {index: primaryData._rowIndex} : primaryData
+ )
+ : null;
const displayValue = getTooltipDisplayValue({item, field, value});
const displayDeltaValue = primaryData
? getTooltipDisplayDeltaValue({
field,
- data,
- fieldIdx,
- primaryData,
+ value,
+ primaryValue,
compareType
})
: null;
diff --git a/src/components/src/map/map-legend.tsx b/src/components/src/map/map-legend.tsx
index e7e63a6d3..e588795b0 100644
--- a/src/components/src/map/map-legend.tsx
+++ b/src/components/src/map/map-legend.tsx
@@ -118,6 +118,7 @@ export type LayerColorLegendProps = {
onLayerVisConfigChange?: (oldLayer: Layer, newVisConfig: Partial<LayerVisConfig>) => void;
layer: Layer;
disableEdit?: boolean;
+ mapState?: MapState;
};
LayerColorLegendFactory.deps = [ColorLegendFactory, SingleColorLegendFactory];
@@ -131,11 +132,14 @@ export function LayerColorLegendFactory(
layer,
colorChannel,
disableEdit,
- onLayerVisConfigChange
+ onLayerVisConfigChange,
+ mapState
}) => {
const enableColorBy = description.measure;
- const {scale, field, domain, range, property} = colorChannel;
+ const {scale, field, domain, range, property, fixed} = colorChannel;
const [colorScale, colorField, colorDomain] = [scale, field, domain].map(k => config[k]);
+ const isFixed = fixed && config.visConfig[fixed];
+
const colorRange = config.visConfig[range];
const onUpdateColorLegend = useCallback(
colorLegends => {
@@ -166,6 +170,8 @@ export function LayerColorLegendFactory(
range={colorRange}
onUpdateColorLegend={onUpdateColorLegend}
disableEdit={disableEdit}
+ isFixed={isFixed}
+ mapState={mapState}
/>
) : (
<SingleColorLegend
@@ -304,6 +310,7 @@ export function LayerLegendContentFactory(
description={layer.getVisualChannelDescription(colorChannel.key)}
layer={layer}
disableEdit={disableEdit}
+ mapState={mapState}
onLayerVisConfigChange={onLayerVisConfigChange}
/>
))}
diff --git a/src/layers/src/base-layer.ts b/src/layers/src/base-layer.ts
index d2cceb046..8e347ea34 100644
--- a/src/layers/src/base-layer.ts
+++ b/src/layers/src/base-layer.ts
@@ -43,7 +43,8 @@ import {
hasColorMap,
hexToRgb,
isPlainObject,
- reverseColorRange
+ reverseColorRange,
+ isDomainStops
} from '@kepler.gl/utils';
import {generateHashId, toArray, notNullorUndefined} from '@kepler.gl/common-utils';
import {Datasets, GpuFilter, KeplerTable} from '@kepler.gl/table';
@@ -68,6 +69,8 @@ import {
ValueOf
} from '@kepler.gl/types';
import {getScaleFunction, initializeLayerColorMap} from '@kepler.gl/utils';
+import {bisectLeft} from 'd3-array';
+import memoize from 'lodash.memoize';
export type VisualChannelDomain = number[] | string[];
export type VisualChannelField = Field | null;
@@ -229,6 +232,11 @@ export type BaseLayerConstructorProps = {
id?: string;
} & LayerBaseConfigPartial;
+export type GetVisChannelScaleReturnType = {
+ (z: number): any;
+ byZoom?: boolean;
+} | null;
+
class Layer {
id: string;
meta: Record<string, any>;
@@ -1049,7 +1057,11 @@ class Layer {
);
}
- getColorScale(colorScale: string, colorDomain: VisualChannelDomain, colorRange: ColorRange) {
+ getColorScale(
+ colorScale: string,
+ colorDomain: VisualChannelDomain,
+ colorRange: ColorRange
+ ): GetVisChannelScaleReturnType {
if (hasColorMap(colorRange) && colorScale === SCALE_TYPES.custom) {
const cMap = new Map();
colorRange.colorMap?.forEach(([k, v]) => {
@@ -1061,11 +1073,14 @@ class Layer {
const scale = getScaleFunction(scaleType, cMap.values(), cMap.keys(), false);
scale.unknown(cMap.get(UNKNOWN_COLOR_KEY) || NO_VALUE_COLOR);
- return scale;
+ return scale as () => any;
}
return this.getVisChannelScale(colorScale, colorDomain, colorRange.colors.map(hexToRgb));
}
+ accessVSFieldValue(field, indexKey) {
+ return defaultGetFieldValue;
+ }
/**
* Mapping from visual channels to deck.gl accesors
* @param {Object} param Parameters
@@ -1075,10 +1090,12 @@ class Layer {
*/
getAttributeAccessors({
dataAccessor = defaultDataAccessor,
- dataContainer
+ dataContainer,
+ indexKey
}: {
dataAccessor?: typeof defaultDataAccessor;
dataContainer: DataContainerInterface;
+ indexKey?: number;
}) {
const attributeAccessors: {[key: string]: any} = {};
@@ -1116,14 +1133,35 @@ class Layer {
isFixed
);
- attributeAccessors[accessor] = d =>
- this.getEncodedChannelValue(
- // @ts-ignore
- scaleFunction,
- dataAccessor(dataContainer)(d),
- this.config[field],
- nullValue
- );
+ const getFieldValue = this.accessVSFieldValue(this.config[field], indexKey);
+
+ if (scaleFunction) {
+ attributeAccessors[accessor] = scaleFunction.byZoom
+ ? memoize(z => {
+ const scaleFunc = scaleFunction(z);
+ return d =>
+ this.getEncodedChannelValue(
+ scaleFunc,
+ dataAccessor(dataContainer)(d),
+ this.config[field],
+ nullValue,
+ getFieldValue
+ );
+ })
+ : d =>
+ this.getEncodedChannelValue(
+ scaleFunction,
+ dataAccessor(dataContainer)(d),
+ this.config[field],
+ nullValue,
+ getFieldValue
+ );
+
+ // set getFillColorByZoom to true
+ if (scaleFunction.byZoom) {
+ attributeAccessors[`${accessor}ByZoom`] = true;
+ }
+ }
} else if (typeof getAttributeValue === 'function') {
attributeAccessors[accessor] = getAttributeValue(this.config);
} else {
@@ -1145,7 +1183,34 @@ class Layer {
domain: VisualChannelDomain,
range: any,
fixed?: boolean
- ): () => any | null {
+ ): GetVisChannelScaleReturnType {
+ if (isDomainStops(domain)) {
+ // color is based on zoom
+ const zSteps = domain.z;
+ // get scale function by z
+ // {
+ // z: [z, z, z],
+ // stops: [[min, max], [min, max]],
+ // interpolation: 'interpolate'
+ // }
+
+ const getScale = function getScaleByZoom(z) {
+ let scaleDomain;
+ const i = bisectLeft(zSteps, z);
+ if (i === 0) {
+ scaleDomain = domain.stops[0];
+ } else {
+ scaleDomain = domain.stops[i - 1];
+ }
+
+ return SCALE_FUNC[fixed ? 'linear' : scale]()
+ .domain(scaleDomain)
+ .range(fixed ? scaleDomain : range);
+ };
+ getScale.byZoom = true;
+ return getScale;
+ }
+
return SCALE_FUNC[fixed ? 'linear' : scale]()
.domain(domain)
.range(fixed ? domain : range);
diff --git a/src/reducers/src/interaction-utils.ts b/src/reducers/src/interaction-utils.ts
index 4c304bd2a..cbf82e492 100644
--- a/src/reducers/src/interaction-utils.ts
+++ b/src/reducers/src/interaction-utils.ts
@@ -11,7 +11,7 @@ import {
} from '@kepler.gl/constants';
import {Field, TooltipField, CompareType} from '@kepler.gl/types';
-import {DataRow, parseFieldValue, getFormatter, isNumber, defaultFormatter} from '@kepler.gl/utils';
+import {parseFieldValue, getFormatter, isNumber, defaultFormatter} from '@kepler.gl/utils';
import {notNullorUndefined} from '@kepler.gl/common-utils';
/**
@@ -82,29 +82,26 @@ function _mergeFieldPairs(pairs) {
}
export function getTooltipDisplayDeltaValue({
- primaryData,
field,
- compareType,
- data,
- fieldIdx
+ value,
+ primaryValue,
+ compareType
}: {
field: Field;
- data: DataRow;
- fieldIdx: number;
- primaryData: DataRow;
- compareType: CompareType;
+ value: any;
+ primaryValue: any;
+ compareType?: CompareType;
}): string | null {
let displayDeltaValue: string | null = null;
if (
- primaryData &&
// comparison mode only works for numeric field
- (field.type === ALL_FIELD_TYPES.integer || field.type === ALL_FIELD_TYPES.real)
+ field.type === ALL_FIELD_TYPES.integer ||
+ field.type === ALL_FIELD_TYPES.real
) {
- const baseDp = primaryData.valueAt(fieldIdx);
- const dp = data.valueAt(fieldIdx);
- if (isNumber(baseDp) && isNumber(dp)) {
- const deltaValue = compareType === COMPARE_TYPES.RELATIVE ? dp / baseDp - 1 : dp - baseDp;
+ if (isNumber(primaryValue) && isNumber(value)) {
+ const deltaValue =
+ compareType === COMPARE_TYPES.RELATIVE ? value / primaryValue - 1 : value - primaryValue;
const deltaFormat =
compareType === COMPARE_TYPES.RELATIVE
? TOOLTIP_FORMATS.DECIMAL_PERCENT_FULL_2[TOOLTIP_KEY]
@@ -113,7 +110,7 @@ export function getTooltipDisplayDeltaValue({
displayDeltaValue = getFormatter(deltaFormat, field)(deltaValue);
// safely cast string
- displayDeltaValue = defaultFormatter(displayDeltaValue) as string;
+ displayDeltaValue = defaultFormatter(displayDeltaValue);
const deltaFirstChar = displayDeltaValue.charAt(0);
if (deltaFirstChar !== '+' && !NEGATIVE_SIGNS.includes(deltaFirstChar)) {
diff --git a/src/reducers/src/layer-utils.ts b/src/reducers/src/layer-utils.ts
index 9485d7778..3ee5397d7 100644
--- a/src/reducers/src/layer-utils.ts
+++ b/src/reducers/src/layer-utils.ts
@@ -11,7 +11,6 @@ import {
TooltipField,
CompareType,
SplitMapLayers,
- InteractionConfig,
Editor,
Feature,
FeatureSelectionContext,
@@ -25,7 +24,7 @@ import {
getEditorLayer
} from '@kepler.gl/layers';
-import KeplerTable, {Datasets} from '@kepler.gl/table';
+import KeplerTable from '@kepler.gl/table';
import {VisState} from '@kepler.gl/schemas';
import {isFunction, getMapLayersFromSplitMaps, DataRow} from '@kepler.gl/utils';
import {ThreeDBuildingLayer} from '@kepler.gl/deckgl-layers';
@@ -54,6 +53,7 @@ export type LayerHoverProp = {
layer: Layer;
primaryData?: DataRow | AggregationLayerHoverData | null;
compareType?: CompareType;
+ currentTime?: VisState['animationConfig']['currentTime'];
};
/**
@@ -159,7 +159,6 @@ export function calculateLayerData<S extends MinVisStateForLayerData>(
/**
* Calculate props passed to LayerHoverInfo
- * @type {typeof import('./layer-utils').getLayerHoverProp}
*/
export function getLayerHoverProp({
animationConfig,
@@ -169,12 +168,12 @@ export function getLayerHoverProp({
layersToRender,
datasets
}: {
- interactionConfig: InteractionConfig;
+ interactionConfig: VisState['interactionConfig'];
animationConfig: VisState['animationConfig'];
- hoverInfo: any;
- layers: Layer[];
+ hoverInfo: VisState['hoverInfo'];
+ layers: VisState['layers'];
layersToRender: LayersToRender;
- datasets: Datasets;
+ datasets: VisState['datasets'];
}): LayerHoverProp | null {
if (interactionConfig.tooltip.enabled && hoverInfo && hoverInfo.picked) {
// if anything hovered
@@ -214,7 +213,8 @@ export function getLayerHoverProp({
data,
fields,
fieldsToShow,
- layer
+ layer,
+ currentTime: animationConfig.currentTime
};
}
}
diff --git a/src/utils/src/data-scale-utils.ts b/src/utils/src/data-scale-utils.ts
index 78dfb0a66..9a5dec6bc 100644
--- a/src/utils/src/data-scale-utils.ts
+++ b/src/utils/src/data-scale-utils.ts
@@ -77,23 +77,32 @@ export function getLogDomain(data: any[], valueAccessor: dataValueAccessor): [nu
return [d0 === 0 ? 1e-5 : d0, d1];
}
+export type DomainStops = {
+ stops: number[];
+ z: number[];
+};
+
/**
* whether field domain is stops
*/
-export function isDomainStops(domain: any): boolean {
+export function isDomainStops(domain: unknown): domain is DomainStops {
return isPlainObject(domain) && Array.isArray(domain.stops) && Array.isArray(domain.z);
}
+export type DomainQuantiles = {
+ quantiles: number[];
+ z: number[];
+};
+
/**
* whether field domain is quantiles
*/
-export function isDomainQuantile(domain: any): boolean {
+export function isDomainQuantile(domain: any): domain is DomainQuantiles {
return isPlainObject(domain) && Array.isArray(domain.quantiles) && Array.isArray(domain.z);
}
/**
* get the domain at zoom
- * @type {typeof import('./data-scale-utils').getThresholdsFromQuantiles}
*/
export function getThresholdsFromQuantiles(
quantiles: number[],
diff --git a/src/utils/src/index.ts b/src/utils/src/index.ts
index e00a3c4bc..6bbd5d295 100644
--- a/src/utils/src/index.ts
+++ b/src/utils/src/index.ts
@@ -133,9 +133,10 @@ export {
getScaleFunction,
getVisualChannelScaleByZoom,
initializeLayerColorMap,
- isNumericColorBreaks
+ isNumericColorBreaks,
+ isDomainStops
} from './data-scale-utils';
-export type {ColorBreak, ColorBreakOrdinal} from './data-scale-utils';
+export type {ColorBreak, ColorBreakOrdinal, DomainQuantiles, DomainStops} from './data-scale-utils';
export {DataRow} from './data-row';
diff --git a/test/browser/components/map/map-legend-test.js b/test/browser/components/map/map-legend-test.js
index d218924f8..a2da91944 100644
--- a/test/browser/components/map/map-legend-test.js
+++ b/test/browser/components/map/map-legend-test.js
@@ -6,6 +6,7 @@ import React from 'react';
import test from 'tape';
import {mount} from 'enzyme';
import cloneDeep from 'lodash.clonedeep';
+import sinon from 'sinon';
import {
MapLegendFactory,
@@ -14,6 +15,8 @@ import {
LayerDefaultLegend,
SingleColorLegendFactory,
LayerColorLegendFactory,
+ LegendRowFactory,
+ ResetColorLabelFactory,
appInjector
} from '@kepler.gl/components';
import {
@@ -23,10 +26,14 @@ import {
expectedSavedLayer2 as geojsonLayer
} from 'test/helpers/mock-state';
import {IntlWrapper, mountWithTheme} from 'test/helpers/component-utils';
+import {KeplerGlLayers} from '@kepler.gl/layers';
+const {PointLayer} = KeplerGlLayers;
const MapLegend = appInjector.get(MapLegendFactory);
const LayerColorLegend = appInjector.get(LayerColorLegendFactory);
const SingleColorLegend = appInjector.get(SingleColorLegendFactory);
+const LegendRow = appInjector.get(LegendRowFactory);
+const ResetColorLabel = appInjector.get(ResetColorLabelFactory);
test('Components -> MapLegend.render', t => {
t.doesNotThrow(() => {
@@ -38,13 +45,14 @@ test('Components -> MapLegend.render', t => {
test('Components -> MapLegend.render -> with layers', t => {
const initialState = cloneDeep(StateWFilesFiltersLayerColor);
+ const onLayerVisConfigChange = sinon.spy();
const {layers} = initialState.visState;
let wrapper;
t.doesNotThrow(() => {
wrapper = mountWithTheme(
<IntlWrapper>
- <MapLegend layers={layers} />
+ <MapLegend layers={layers} onLayerVisConfigChange={onLayerVisConfigChange} />
</IntlWrapper>
);
}, 'Show not fail with layers');
@@ -55,13 +63,13 @@ test('Components -> MapLegend.render -> with layers', t => {
'should render 3 layer legends'
);
- const pointLegend = wrapper.find(StyledMapControlLegend).at(0);
const geojsonLegend = wrapper.find(StyledMapControlLegend).at(1);
const hexagonLegend = wrapper.find(StyledMapControlLegend).at(2);
+ const pointLegend = wrapper.find(StyledMapControlLegend).at(0);
- testPointLayerLegend(t, pointLegend);
testGeojsonLegend(t, geojsonLegend);
testHexagonLayerLegend(t, hexagonLegend);
+ testPointLayerLegend(t, pointLegend, onLayerVisConfigChange);
t.end();
});
@@ -108,7 +116,7 @@ function testGeojsonLegend(t, geojsonLegend) {
);
}
-function testPointLayerLegend(t, pointLegend) {
+function testPointLayerLegend(t, pointLegend, onLayerVisConfigChange) {
// layer[0] point layer
// color by: gps_data.types
// point layer has 2 color channels, only fill is enabled
@@ -145,6 +153,55 @@ function testPointLayerLegend(t, pointLegend) {
pointLayer.visualChannels.colorField.name,
'point layer legend should render color by measure: gps_data.types'
);
+
+ // colors: ["#E6FAFA", "#AAD7DA", "#68B4BB", "#00939C"]
+ // colorDomain ["driver_analytics", "driver_analytics_0", "driver_gps"]
+ t.equal(pointLegend.find(LegendRow).length, 3, 'Should render 3 legends');
+ const expectedLegend = [
+ ['#E6FAFA', 'driver_analytics'],
+ ['#AAD7DA', 'driver_analytics_0'],
+ ['#68B4BB', 'driver_gps']
+ ];
+ for (let i = 0; i < 3; i++) {
+ const rect = pointLegend
+ .find(LegendRow)
+ .at(i)
+ .find('.legend-row-color')
+ .at(0);
+ t.equal(
+ rect.props().style.backgroundColor,
+ expectedLegend[i][0],
+ 'should render correct legend color'
+ );
+ const input = pointLegend
+ .find(LegendRow)
+ .at(i)
+ .find('input')
+ .at(0);
+ t.equal(input.props().value, expectedLegend[i][1], 'should render correct legend label');
+ }
+
+ // test change input
+ const firstLegendInput = pointLegend
+ .find(LegendRow)
+ .at(0)
+ .find('input');
+ const event = {target: {name: 'input-legend-label', value: 'taro'}};
+ firstLegendInput.simulate('change', event);
+
+ t.ok(onLayerVisConfigChange.calledOnce, 'should call onLayerVisConfigChange');
+
+ t.ok(onLayerVisConfigChange.args[0][0] instanceof PointLayer, 'first arg should be Layer');
+ t.deepEqual(
+ Object.keys(onLayerVisConfigChange.args[0][1]),
+ ['colorRange'],
+ 'second arg should be colorRange'
+ );
+ t.deepEqual(
+ onLayerVisConfigChange.args[0][1].colorRange.colorLegends,
+ {'#E6FAFA': 'taro'},
+ 'second arg should contain colorLegends'
+ );
}
function testHexagonLayerLegend(t, hexagonLegend) {
@@ -181,3 +238,56 @@ function testHexagonLayerLegend(t, hexagonLegend) {
'hexagon layer legend should render color by Point Count'
);
}
+
+test('Components -> MapLegend.render -> with colorLegends', t => {
+ const initialState = cloneDeep(StateWFilesFiltersLayerColor);
+ const onLayerVisConfigChange = sinon.spy();
+ const {layers} = initialState.visState;
+ const ptLayer = layers[0];
+
+ ptLayer.config.visConfig.colorRange = {
+ ...ptLayer.config.visConfig.colorRange,
+ colorLegends: {
+ '#E6FAFA': 'taro'
+ }
+ };
+ let wrapper;
+
+ t.doesNotThrow(() => {
+ wrapper = mountWithTheme(
+ <IntlWrapper>
+ <MapLegend layers={[ptLayer]} onLayerVisConfigChange={onLayerVisConfigChange} />
+ </IntlWrapper>
+ );
+ }, 'Show not fail with layers');
+
+ t.equal(wrapper.find(StyledMapControlLegend).length, 1, 'should render 1 layer legends');
+
+ const pointLegend = wrapper.find(StyledMapControlLegend).at(0);
+ const firstLegend = pointLegend.find(LegendRow).at(0);
+ const input = firstLegend.find('input').at(0);
+
+ t.equal(input.props().value, 'taro', 'should render custom legend label');
+ t.equal(firstLegend.find(ResetColorLabel).length, 1, 'should render reset');
+
+ // click reset
+ firstLegend
+ .find(ResetColorLabel)
+ .at(0)
+ .simulate('click');
+ t.ok(onLayerVisConfigChange.calledOnce, 'should call onLayerVisConfigChange');
+
+ t.ok(onLayerVisConfigChange.args[0][0] instanceof PointLayer, 'first arg should be Layer');
+ t.deepEqual(
+ Object.keys(onLayerVisConfigChange.args[0][1]),
+ ['colorRange'],
+ 'second arg should be colorRange'
+ );
+ t.deepEqual(
+ onLayerVisConfigChange.args[0][1].colorRange.colorLegends,
+ {},
+ 'second arg should be empty'
+ );
+
+ t.end();
+});
diff --git a/test/browser/components/map/map-popover-test.js b/test/browser/components/map/map-popover-test.js
index 8e8aedffe..192fc04f9 100644
--- a/test/browser/components/map/map-popover-test.js
+++ b/test/browser/components/map/map-popover-test.js
@@ -6,7 +6,13 @@ import sinon from 'sinon';
import test from 'tape';
import {IntlWrapper, mountWithTheme} from 'test/helpers/component-utils';
-import {Icons, MapPopoverFactory, appInjector} from '@kepler.gl/components';
+import {
+ Icons,
+ MapPopoverFactory,
+ appInjector,
+ LayerHoverInfoFactory,
+ CoordinateInfoFactory
+} from '@kepler.gl/components';
import {
expectedLayerHoverProp as layerHoverProp,
expectedGeojsonLayerHoverProp as geojsonLayerHoverProp
@@ -14,6 +20,8 @@ import {
const {Pin} = Icons;
const MapPopover = appInjector.get(MapPopoverFactory);
+const LayerHoverInfo = appInjector.get(LayerHoverInfoFactory);
+const CoordinateInfo = appInjector.get(CoordinateInfoFactory);
const defaultProps = {
x: 400,
@@ -49,10 +57,10 @@ test('Map Popover - render', t => {
0,
'Should not display select geometry for point layer'
);
-
wrapper.setProps({
children: <MapPopover {...defaultProps} isBase={true} frozen={true} />
});
+
t.equal(wrapper.find(Pin).length, 1, 'Should display 1 pin');
t.equal(wrapper.find('.primary-label').length, 1, 'Should display 1 primary label');
t.equal(
@@ -87,13 +95,13 @@ test('Map Popover - render with layerHoverProp', t => {
</IntlWrapper>
);
}, 'Should render map popover with layerHoverProps');
- t.equal(wrapper.find('LayerHoverInfo').length, 1, 'Should render LayerHoverInfo');
+ t.equal(wrapper.find(LayerHoverInfo).length, 1, 'Should render LayerHoverInfo');
t.equal(wrapper.find('table').length, 1, 'Should render 1 table');
const table = wrapper.find('table').at(0);
const rows = table.find('.layer-hover-info__row');
t.equal(rows.length, 5, 'should render 5 rows');
const expectedTooltips = [
- ['gps_data.utc_timestamp', '2016-09-17 00:24:24'],
+ ['gps_data.utc_timestamp', '1474071864000'],
['gps_data.types', 'driver_analytics'],
['epoch', '1472754400000'],
['has_result', ''],
@@ -147,5 +155,47 @@ test('Map Popover - render with geojsonLayerHoverProp', t => {
t.ok(setSelectedFeature.called, 'should call setSelectedFeature when click select geometry');
t.ok(onSetFeatures.called, 'should call onSetFeatures when click select geometry');
+ // click pin
+ wrapper
+ .find('.popover-pin')
+ .at(0)
+ .simulate('click');
+ t.ok(onClose.called, 'should call onClose when click pin');
+
+ // render coordinate
+ wrapper.setProps({
+ children: (
+ <MapPopover {...defaultProps} coordinate={[127.12345678, -31.12345678]} zoom={12.123} />
+ )
+ });
+ t.equal(wrapper.find(CoordinateInfo).length, 1, 'Should render CoordinateInfo');
+
+ t.equal(
+ wrapper
+ .find('.row__value')
+ .at(0)
+ .text(),
+ '-31.123457,',
+ 'should render lat'
+ );
+
+ t.equal(
+ wrapper
+ .find('.row__value')
+ .at(1)
+ .text(),
+ '127.123457,',
+ 'should render longitude'
+ );
+
+ t.equal(
+ wrapper
+ .find('.row__value')
+ .at(2)
+ .text(),
+ '12.1z',
+ 'should render zoom'
+ );
+
t.end();
});
diff --git a/test/browser/layer-tests/base-layer-specs.js b/test/browser/layer-tests/base-layer-specs.js
index a6a528195..ffbe4f9a1 100644
--- a/test/browser/layer-tests/base-layer-specs.js
+++ b/test/browser/layer-tests/base-layer-specs.js
@@ -3,22 +3,44 @@
import test from 'tape-catch';
import {Layer, AggregationLayer} from '@kepler.gl/layers';
+import {KeplerTable} from '@kepler.gl/table';
-/* Fixed in #618
test('#BaseLayer -> updateLayerDomain', t => {
+ const rows = [
+ ['a', 3],
+ ['b', 4],
+ ['c', 1],
+ ['d', null],
+ ['e', 5],
+ ['f', 0]
+ ];
+ const fields = [
+ {
+ name: 'f1'
+ },
+ {
+ name: 'f2'
+ }
+ ];
+ const dataset = new KeplerTable({
+ info: {
+ id: 'test'
+ }
+ });
+ dataset.importData({
+ data: {
+ rows,
+ fields
+ }
+ });
- const allData = [['a', 3], ['b', 4], ['c', 1], ['d', null], ['e', 5], ['f', 0]];
- const data = [['a', 3], ['b', 4], ['c', 1], ['d', null]];
- const filteredIndex = [0, 1, 2, 3];
- const filteredIndexForDomain = [0, 1, 2, 3, 4];
+ dataset.filteredIndex = [0, 1, 2, 3];
+ dataset.filteredIndexForDomain = [0, 1, 2, 3, 4];
const mockLayer = new Layer({dataId: 'test'});
mockLayer.updateLayerConfig({
- colorField: {
- tableFieldIndex: 2,
- type: 'real'
- },
+ colorField: dataset.fields[1],
colorDomain: [0, 1],
colorScale: 'quantile',
sizeField: null,
@@ -27,25 +49,19 @@ test('#BaseLayer -> updateLayerDomain', t => {
const expectedDomain = [1, 3, 4, 5];
let updatedLayer = mockLayer.updateLayerDomain({
- test: {
- data,
- allData,
- filteredIndex,
- filteredIndexForDomain
- }
+ test: dataset
});
- t.deepEqual(updatedLayer.config.colorDomain, expectedDomain,
- 'should calculate layer color domain');
+ t.deepEqual(
+ updatedLayer.config.colorDomain,
+ expectedDomain,
+ 'should calculate layer color domain'
+ );
- t.deepEqual(updatedLayer.config.sizeDomain, [0, 1],
- 'should not calculate layer size domain');
+ t.deepEqual(updatedLayer.config.sizeDomain, [0, 1], 'should not calculate layer size domain');
mockLayer.updateLayerConfig({
- colorField: {
- tableFieldIndex: 1,
- type: 'string'
- },
+ colorField: dataset.fields[0],
colorDomain: [0, 1],
colorScale: 'ordinal',
sizeField: null,
@@ -53,55 +69,119 @@ test('#BaseLayer -> updateLayerDomain', t => {
});
updatedLayer = mockLayer.updateLayerDomain({
- test: {
- data,
- allData,
- filteredIndex,
- filteredIndexForDomain
- }
+ test: dataset
});
const expectedOrdinalDomain = ['a', 'b', 'c', 'd', 'e', 'f'];
- t.deepEqual(updatedLayer.config.colorDomain, expectedOrdinalDomain,
- 'should calculate layer color domain based on ordinal domain');
+ t.deepEqual(
+ updatedLayer.config.colorDomain,
+ expectedOrdinalDomain,
+ 'should calculate layer color domain based on ordinal domain'
+ );
+
+ const dataset2 = new KeplerTable({
+ info: {
+ id: 'test'
+ }
+ });
+ dataset2.importData({
+ data: {
+ rows: [
+ ['a', 3],
+ ['b', 4],
+ ['c', 1],
+ ['d', null],
+ ['e', 5],
+ ['f', 0],
+ ['g', 6]
+ ],
+ fields
+ }
+ });
+
+ dataset2.filteredIndex = [0, 1, 2, 3];
+ dataset2.filteredIndexForDomain = [0, 1, 2, 3, 4];
+ updatedLayer = mockLayer.updateLayerDomain({test: dataset2}, {id: 'newFilter'});
+
+ t.deepEqual(
+ updatedLayer.config.colorDomain,
+ expectedOrdinalDomain,
+ 'should skip domain calculation if field is oridinal'
+ );
+
+ t.end();
+});
- const newDataset = {
- allData: [['a', 3], ['b', 4], ['c', 1], ['d', null], ['e', 5], ['f', 0], ['g', 6]],
- data,
- filteredIndex,
- filteredIndexForDomain
+test('#BaseLayer -> getVisChannelScale, by zoom', t => {
+ const scale = 'quantize';
+ const domain = {
+ z: [2, 3, 4, 5],
+ stops: [
+ [0, 20],
+ [0, 30],
+ [0, 40],
+ [0, 50]
+ ]
};
+ const range = ['#010101', '#020202', '#030303'];
+
+ const mockLayer = new Layer({dataId: 'test'});
- updatedLayer = mockLayer.updateLayerDomain({test: newDataset}, {id: 'newFilter'});
+ const scaleFunc = mockLayer.getVisChannelScale(scale, domain, range);
- t.deepEqual(updatedLayer.config.colorDomain, expectedOrdinalDomain,
- 'should skip domain calculation if field is oridinal');
+ t.ok(scaleFunc.byZoom, true, 'should set by zoom to be truthy');
+ const scale1 = scaleFunc(1);
+ const scale2 = scaleFunc(3.2);
+ const scale3 = scaleFunc(9);
+
+ t.deepEqual(scale1.domain(), [0, 20], 'should set domain by zoom');
+ t.deepEqual(scale1.range(), range, 'should set range');
+ t.deepEqual(scale2.domain(), [0, 30], 'should set domain by zoom');
+ t.deepEqual(scale3.domain(), [0, 50], 'should set domain by zoom');
t.end();
});
-*/
+
test('#AggregationLayer -> updateLayerDomain', t => {
- const data = [
+ const rows = [
['a', 3],
['b', 4],
['c', 1],
['d', null]
];
+
+ const fields = [
+ {
+ name: 'f1'
+ },
+ {
+ name: 'f2'
+ }
+ ];
+ const dataset = new KeplerTable({
+ info: {
+ id: 'test'
+ }
+ });
+ dataset.importData({
+ data: {
+ rows,
+ fields
+ }
+ });
+
const mockLayer = new AggregationLayer({dataId: 'test'});
mockLayer.updateLayerConfig({
- colorField: {
- tableFieldIndex: 2,
- type: 'real'
- },
+ colorField: dataset.fields[1],
colorDomain: [0, 1],
colorScale: 'quantile',
sizeField: null,
sizeDomain: [0, 1]
});
- const updatedLayer = mockLayer.updateLayerDomain({test: {data, allData: data}});
+ const updatedLayer = mockLayer.updateLayerDomain({test: dataset});
t.deepEqual(
updatedLayer.config.colorDomain,
[0, 1],
diff --git a/test/browser/layer-tests/point-layer-specs.js b/test/browser/layer-tests/point-layer-specs.js
index ab23683f8..4ad0aaf2c 100644
--- a/test/browser/layer-tests/point-layer-specs.js
+++ b/test/browser/layer-tests/point-layer-specs.js
@@ -4,6 +4,20 @@
import test from 'tape';
import moment from 'moment';
import {getDistanceScales} from 'viewport-mercator-project';
+import {scaleQuantize} from 'd3-scale';
+import cloneDeep from 'lodash.clonedeep';
+
+import {DEFAULT_TEXT_LABEL, PROJECTED_PIXEL_SIZE_MULTIPLIER} from '@kepler.gl/constants';
+import {KeplerGlLayers} from '@kepler.gl/layers';
+import {processGeojson} from '@kepler.gl/processors';
+import {INITIAL_MAP_STATE} from '@kepler.gl/reducers';
+import {copyTableAndUpdate} from '@kepler.gl/table';
+import {hexToRgb} from '@kepler.gl/utils';
+
+import {geoJsonWithStyle, geojsonData} from 'test/fixtures/geojson';
+import testArcData, {pointFromNeighbor} from 'test/fixtures/test-arc-data';
+import {StateWArcNeighbors} from 'test/helpers/mock-state';
+import {createNewDataEntryMock} from 'test/helpers/table-utils';
import {
testCreateCases,
testFormatLayerDataCases,
@@ -15,16 +29,6 @@ import {
pointLayerMeta,
fieldDomain
} from 'test/helpers/layer-utils';
-import {processGeojson} from '@kepler.gl/processors';
-import {geoJsonWithStyle, geojsonData} from 'test/fixtures/geojson';
-import testArcData, {pointFromNeighbor} from 'test/fixtures/test-arc-data';
-import {StateWArcNeighbors} from 'test/helpers/mock-state';
-import {createNewDataEntryMock} from 'test/helpers/table-utils';
-import {copyTableAndUpdate} from '@kepler.gl/table';
-import {KeplerGlLayers} from '@kepler.gl/layers';
-import {INITIAL_MAP_STATE} from '@kepler.gl/reducers';
-import {DEFAULT_TEXT_LABEL, PROJECTED_PIXEL_SIZE_MULTIPLIER} from '@kepler.gl/constants';
-import cloneDeep from 'lodash.clonedeep';
const {PointLayer} = KeplerGlLayers;
@@ -63,7 +67,6 @@ test('#PointLayer -> constructor', t => {
test('#PointLayer -> formatLayerData', t => {
const filteredIndex = [0, 2, 4];
const filterDomain0 = 1474071056000;
-
const TEST_CASES = [
{
name: 'Point gps point.1',
@@ -465,6 +468,86 @@ test('#PointLayer -> formatLayerData', t => {
);
}
}
+ },
+ {
+ name: 'Test gps point.2 Data colorFields, domainStops',
+ layer: {
+ type: 'point',
+ id: 'test_layer_2',
+ config: {
+ dataId,
+ label: 'some point file',
+ columns: {
+ lat: 'lat',
+ lng: 'lng'
+ },
+ visConfig: {
+ outline: true,
+ fixedRadius: true,
+ colorRange: {
+ colors: ['#010101', '#020202', '#030303', '#040404', '#050505', '#060606', '#070707']
+ },
+ strokeColor: [4, 5, 6]
+ },
+ // color by id(integer)
+ colorField: {
+ type: 'integer',
+ name: 'id'
+ },
+ colorScale: 'quantize'
+ }
+ },
+ datasets: {
+ [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
+ },
+ assert: result => {
+ const {layer} = result;
+ layer.config.colorDomain = {
+ z: [2, 3, 4, 5],
+ stops: [
+ [0, 20],
+ [0, 30],
+ [0, 40],
+ [0, 50]
+ ]
+ };
+
+ const layerData = layer.formatLayerData({
+ [dataId]: copyTableAndUpdate(preparedDataset, {filteredIndex})
+ });
+
+ // get scale function
+ const getFillColor0 = layerData.getFillColor(1);
+ const getFillColor = layerData.getFillColor(1);
+ t.equal(layerData.getFillColorByZoom, true, 'should set getFillColorByZoom to truthy');
+ t.equal(getFillColor0, getFillColor, 'function should be memoized');
+
+ const expectedScale = scaleQuantize()
+ .domain([0, 20])
+ .range(layer.config.visConfig.colorRange.colors);
+
+ const expectedColors = [
+ hexToRgb(expectedScale(preparedDataset.dataContainer.row(0).valueAt(7))),
+ [0, 0, 0, 0],
+ hexToRgb(expectedScale(preparedDataset.dataContainer.row(2).valueAt(7))),
+ hexToRgb(expectedScale(preparedDataset.dataContainer.row(3).valueAt(7))),
+ hexToRgb(expectedScale(preparedDataset.dataContainer.row(4).valueAt(7))),
+ hexToRgb(expectedScale(preparedDataset.dataContainer.row(5).valueAt(7)))
+ ];
+ for (let i = 0; i < 6; i++) {
+ t.deepEqual(
+ getFillColor({
+ data: preparedDataset.dataContainer.row(i),
+ index: i
+ }),
+ expectedColors[i],
+ `Should get corrent value from zoom scale for ${preparedDataset.dataContainer
+ .row(i)
+ .valueAt(7)}`
+ );
+ }
+ // should use domain [0, 20]
+ }
}
];
diff --git a/test/helpers/mock-state.js b/test/helpers/mock-state.js
index 4de61663c..379ca1601 100644
--- a/test/helpers/mock-state.js
+++ b/test/helpers/mock-state.js
@@ -1275,6 +1275,7 @@ export const mockKeplerProps = mockKeplerPropsWithState({state: StateWLayerStyle
// hover over data index 15
// tested in map-container-test
export const expectedLayerHoverProp = {
+ currentTime: null,
data: mockKeplerProps.visState.datasets[testCsvDataId].dataContainer.row(15),
fields: mockKeplerProps.visState.datasets[testCsvDataId].fields,
fieldsToShow:
diff --git a/test/node/utils/interaction-utils-test.js b/test/node/utils/interaction-utils-test.js
index f9f5227b0..3aa0d057f 100644
--- a/test/node/utils/interaction-utils-test.js
+++ b/test/node/utils/interaction-utils-test.js
@@ -122,12 +122,11 @@ test('interactionUtil -> getTooltipDisplayDeltaValue', t => {
const TEST_CASES = [
{
input: {
- primaryData: dataset.dataContainer.row(0),
+ primaryValue: dataset.dataContainer.row(0).valueAt(testFieldIdx),
// field.displayFormat has been used to replace tooltipConfig.format
field: {...dataset.fields[testFieldIdx], displayFormat: item.format},
compareType: COMPARE_TYPES.ABSOLUTE,
- data: dataset.dataContainer.row(1),
- fieldIdx: testFieldIdx,
+ value: dataset.dataContainer.row(1).valueAt(testFieldIdx),
item
},
output: `${TOOLTIP_MINUS_SIGN}7.000`,
@@ -135,11 +134,10 @@ test('interactionUtil -> getTooltipDisplayDeltaValue', t => {
},
{
input: {
- primaryData: dataset.dataContainer.row(0),
+ primaryValue: dataset.dataContainer.row(0).valueAt(testFieldIdx),
field: {...dataset.fields[testFieldIdx], displayFormat: item.format},
compareType: COMPARE_TYPES.RELATIVE,
- data: dataset.dataContainer.row(1),
- fieldIdx: testFieldIdx,
+ value: dataset.dataContainer.row(1).valueAt(testFieldIdx),
item
},
output: `${TOOLTIP_MINUS_SIGN}63.64%`,
@@ -147,11 +145,10 @@ test('interactionUtil -> getTooltipDisplayDeltaValue', t => {
},
{
input: {
- primaryData: dataset.dataContainer.row(3),
+ primaryValue: dataset.dataContainer.row(3).valueAt(testFieldIdx),
field: {...dataset.fields[testFieldIdx], displayFormat: item.format},
compareType: COMPARE_TYPES.ABSOLUTE,
- data: dataset.dataContainer.row(1),
- fieldIdx: testFieldIdx,
+ value: dataset.dataContainer.row(1).valueAt(testFieldIdx),
item
},
output: TOOLTIP_MINUS_SIGN,
@@ -159,11 +156,10 @@ test('interactionUtil -> getTooltipDisplayDeltaValue', t => {
},
{
input: {
- primaryData: dataset.dataContainer.row(0),
+ primaryValue: dataset.dataContainer.row(0).valueAt(testFieldIdx),
field: {...dataset.fields[testFieldIdx], displayFormat: item.format},
compareType: COMPARE_TYPES.ABSOLUTE,
- data: dataset.dataContainer.row(3),
- fieldIdx: testFieldIdx,
+ value: dataset.dataContainer.row(3).valueAt(testFieldIdx),
item
},
output: TOOLTIP_MINUS_SIGN,
@@ -171,11 +167,10 @@ test('interactionUtil -> getTooltipDisplayDeltaValue', t => {
},
{
input: {
- primaryData: dataset.dataContainer.row(4),
+ primaryValue: dataset.dataContainer.row(4).valueAt(testFieldIdx),
field: {...dataset.fields[testFieldIdx], displayFormat: item.format},
compareType: COMPARE_TYPES.ABSOLUTE,
- data: dataset.dataContainer.row(3),
- fieldIdx: testFieldIdx,
+ value: dataset.dataContainer.row(3).valueAt(testFieldIdx),
item
},
output: TOOLTIP_MINUS_SIGN,
diff --git a/test/node/utils/layer-utils-test.js b/test/node/utils/layer-utils-test.js
index 61e2cb012..bde34a443 100644
--- a/test/node/utils/layer-utils-test.js
+++ b/test/node/utils/layer-utils-test.js
@@ -906,6 +906,7 @@ test('layerUtils -> getLayerHoverProp', t => {
object: null
};
const args = {
+ animationConfig: visState.animationConfig,
interactionConfig: visState.interactionConfig,
hoverInfo: mockHoverInfo,
layers: visState.layers,
@@ -918,7 +919,8 @@ test('layerUtils -> getLayerHoverProp', t => {
data: expectedDataset.dataContainer.row(obj.index),
fields: expectedDataset.fields,
fieldsToShow: visState.interactionConfig.tooltip.config.fieldsToShow[layer.config.dataId],
- layer
+ layer,
+ currentTime: visState.animationConfig.currentTime
};
t.deepEqual(getLayerHoverProp(args), expected, 'should get correct layerHoverProp');