10519844544

Committed 23 Aug 2024 04:24AM UTC coverage: 88.902% (-0.2%) from 89.141%

Build # 10519844544

Build Type

push

github

Committed by

web-flow

Commit Message

GPU Aggregation (6/8): HexagonLayer (#9098)

Run Details

6667 of 7306 branches covered (91.25%)

Branch coverage included in aggregate %.

674 of 710 new or added lines in 5 files covered. (94.93%)

223 existing lines in 3 files now uncovered.

55786 of 62943 relevant lines covered (88.63%)

6459.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.48

/modules/aggregation-layers/src/utils/cpu-aggregator.ts

// Copyright (c) 2015 - 2018 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
import BinSorter from './bin-sorter';
import {getScaleFunctionByScaleType} from './scale-utils';
import {getValueFunc, wrapGetValueFunc} from './aggregation-operation-utils';

// eslint-disable-next-line @typescript-eslint/no-empty-function
function noop() {}

const dimensionSteps = ['getBins', 'getDomain', 'getScaleFunc'];
const defaultDimensions = [
  {
    key: 'fillColor',
    accessor: 'getFillColor',
    pickingInfo: 'colorValue',
    getBins: {
      triggers: {
        value: {
          prop: 'getColorValue',
          updateTrigger: 'getColorValue'
        },
        weight: {
          prop: 'getColorWeight',
          updateTrigger: 'getColorWeight'
        },
        aggregation: {
          prop: 'colorAggregation'
        },
        filterData: {
          prop: '_filterData',
          updateTrigger: '_filterData'
        }
      }
    },
    getDomain: {
      triggers: {
        lowerPercentile: {
          prop: 'lowerPercentile'
        },
        upperPercentile: {
          prop: 'upperPercentile'
        },
        scaleType: {
          prop: 'colorScaleType'
        }
      }
    },
    getScaleFunc: {
      triggers: {
        domain: {prop: 'colorDomain'},
        range: {prop: 'colorRange'}
      },
      onSet: {
        props: 'onSetColorDomain'
      }
    },
    nullValue: [0, 0, 0, 0]
  },
  {
    key: 'elevation',
    accessor: 'getElevation',
    pickingInfo: 'elevationValue',
    getBins: {
      triggers: {
        value: {
          prop: 'getElevationValue',
          updateTrigger: 'getElevationValue'
        },
        weight: {
          prop: 'getElevationWeight',
          updateTrigger: 'getElevationWeight'
        },
        aggregation: {
          prop: 'elevationAggregation'
        },
        filterData: {
          prop: '_filterData',
          updateTrigger: '_filterData'
        }
      }
    },
    getDomain: {
      triggers: {
        lowerPercentile: {
          prop: 'elevationLowerPercentile'
        },
        upperPercentile: {
          prop: 'elevationUpperPercentile'
        },
        scaleType: {
          prop: 'elevationScaleType'
        }
      }
    },
    getScaleFunc: {
      triggers: {
        domain: {prop: 'elevationDomain'},
        range: {prop: 'elevationRange'}
      },
      onSet: {
        props: 'onSetElevationDomain'
      }
    },
    nullValue: -1
  }
];
const defaultGetCellSize = props => props.cellSize;
export default class CPUAggregator {
  state: {
    layerData: {
      data?: any[];
    };
    dimensions: Record<string, any>;
  } = {
    layerData: {
      data: undefined
    },
    dimensions: {
      // color: {
      //   getValue: null,
      //   domain: null,
      //   sortedBins: null,
      //   scaleFunc: noop
      // },
      // elevation: {
      //   getValue: null,
      //   domain: null,
      //   sortedBins: null,
      //   scaleFunc: noop
      // }
    }
  };
  changeFlags: Record<string, any> = {};
  dimensionUpdaters: Record<string, any> = {};

  _getCellSize;
  _getAggregator;

  constructor(opts) {
    this._getCellSize = opts.getCellSize || defaultGetCellSize;
    this._getAggregator = opts.getAggregator;
    this._addDimension(opts.dimensions || defaultDimensions);
  }

  static defaultDimensions() {
    return defaultDimensions;
  }

  updateState(opts, aggregationParams) {
    const {oldProps, props, changeFlags} = opts;
    this.updateGetValueFuncs(oldProps, props, changeFlags);
    const reprojectNeeded = this.needsReProjectPoints(oldProps, props, changeFlags);
    let aggregationDirty = false;
    if (changeFlags.dataChanged || reprojectNeeded) {
      // project data into bin and aggregate wegiths per bin
      this.getAggregatedData(props, aggregationParams);
      aggregationDirty = true;
    } else {
      const dimensionChanges = this.getDimensionChanges(oldProps, props, changeFlags) || [];
      // this here is layer
      dimensionChanges.forEach(f => typeof f === 'function' && f());
      aggregationDirty = true;
    }
    this.setState({aggregationDirty});

    return this.state;
  }

  // Update private state
  setState(updateObject) {
    this.state = {...this.state, ...updateObject};
  }

  // Update private state.dimensions
  setDimensionState(key, updateObject) {
    this.setState({
      dimensions: {
        ...this.state.dimensions,
        [key]: {...this.state.dimensions[key], ...updateObject}
      }
    });
  }

  normalizeResult(result: {hexagons?; layerData?} = {}) {
    // support previous hexagonAggregator API
    if (result.hexagons) {
      return {data: result.hexagons, ...result};
    } else if (result.layerData) {
      return {data: result.layerData, ...result};
    }

    return result;
  }

  getAggregatedData(props, aggregationParams) {
    const aggregator = this._getAggregator(props);

    const result = aggregator(props, aggregationParams);
    this.setState({
      layerData: this.normalizeResult(result)
    });
    this.changeFlags = {
      layerData: true
    };
    this.getSortedBins(props);
  }

  updateGetValueFuncs(oldProps, props, changeFlags) {
    for (const key in this.dimensionUpdaters) {
      const {value, weight, aggregation} = this.dimensionUpdaters[key].getBins.triggers;
      let getValue = props[value.prop];
      const getValueChanged = this.needUpdateDimensionStep(
        this.dimensionUpdaters[key].getBins,
        oldProps,
        props,
        changeFlags
      );

      if (getValueChanged) {
        if (getValue) {
          getValue = wrapGetValueFunc(getValue, {data: props.data});
        } else {
          // If `getValue` is not provided from props, build it with aggregation and weight.
          getValue = getValueFunc(props[aggregation.prop], props[weight.prop], {data: props.data});
        }
      }

      if (getValue) {
        this.setDimensionState(key, {getValue});
      }
    }
  }

  needsReProjectPoints(oldProps, props, changeFlags) {
    return (
      this._getCellSize(oldProps) !== this._getCellSize(props) ||
      this._getAggregator(oldProps) !== this._getAggregator(props) ||
      (changeFlags.updateTriggersChanged &&
        (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPosition))
    );
  }

  // Adds dimensions
  addDimension(dimensions) {
    this._addDimension(dimensions);
  }

  _addDimension(dimensions = []) {
    dimensions.forEach(dimension => {
      const {key} = dimension;
      this.dimensionUpdaters[key] = this.getDimensionUpdaters(dimension);
      this.state.dimensions[key] = {
        getValue: null,
        domain: null,
        sortedBins: null,
        scaleFunc: noop
      };
    });
  }

  getDimensionUpdaters({key, accessor, pickingInfo, getBins, getDomain, getScaleFunc, nullValue}) {
    return {
      key,
      accessor,
      pickingInfo,
      getBins: {updater: this.getDimensionSortedBins.bind(this), ...getBins},
      getDomain: {updater: this.getDimensionValueDomain.bind(this), ...getDomain},
      getScaleFunc: {updater: this.getDimensionScale.bind(this), ...getScaleFunc},
      attributeAccessor: this.getSubLayerDimensionAttribute(key, nullValue)
    };
  }

  needUpdateDimensionStep(dimensionStep, oldProps, props, changeFlags) {
    // whether need to update current dimension step
    // dimension step is the value, domain, scaleFunction of each dimension
    // each step is an object with properties links to layer prop and whether the prop is
    // controlled by updateTriggers
    // getBins: {
    //   value: {
    //     prop: 'getElevationValue',
    //     updateTrigger: 'getElevationValue'
    //   },
    //   weight: {
    //     prop: 'getElevationWeight',
    //     updateTrigger: 'getElevationWeight'
    //   },
    //   aggregation: {
    //     prop: 'elevationAggregation'
    //   }
    // }
    return Object.values(dimensionStep.triggers).some((item: any) => {
      if (item.updateTrigger) {
        // check based on updateTriggers change first
        // if data has changed, always update value
        return (
          changeFlags.dataChanged ||
          (changeFlags.updateTriggersChanged &&
            (changeFlags.updateTriggersChanged.all ||
              changeFlags.updateTriggersChanged[item.updateTrigger]))
        );
      }
      // fallback to direct comparison
      return oldProps[item.prop] !== props[item.prop];
    });
  }

  getDimensionChanges(oldProps: any, props: any, changeFlags: any): Function[] | null {
    // const {dimensionUpdaters} = this.state;
    const updaters: Function[] = [];

    // get dimension to be updated
    for (const key in this.dimensionUpdaters) {
      // return the first triggered updater for each dimension
      const needUpdate = dimensionSteps.find(step =>
        this.needUpdateDimensionStep(
          this.dimensionUpdaters[key][step],
          oldProps,
          props,
          changeFlags
        )
      );

      if (needUpdate) {
        updaters.push(
          this.dimensionUpdaters[key][needUpdate].updater.bind(
            this,
            props,
            this.dimensionUpdaters[key]
          )
        );
      }
    }

    return updaters.length ? updaters : null;
  }

  getUpdateTriggers(props) {
    const _updateTriggers = props.updateTriggers || {};
    const updateTriggers = {};

    for (const key in this.dimensionUpdaters) {
      const {accessor} = this.dimensionUpdaters[key];
      // fold dimension triggers into each accessor
      updateTriggers[accessor] = {};

      dimensionSteps.forEach(step => {
        Object.values(this.dimensionUpdaters[key][step].triggers).forEach(
          ({prop, updateTrigger}: any) => {
            if (updateTrigger) {
              // if prop is based on updateTrigger e.g. getColorValue, getColorWeight
              // and updateTriggers is passed in from layer prop
              // fold the updateTriggers into accessor
              const fromProp = _updateTriggers[updateTrigger];
              if (typeof fromProp === 'object' && !Array.isArray(fromProp)) {
                // if updateTrigger is an object spread it
                Object.assign(updateTriggers[accessor], fromProp);
              } else if (fromProp !== undefined) {
                updateTriggers[accessor][prop] = fromProp;
              }
            } else {
              // if prop is not based on updateTrigger
              updateTriggers[accessor][prop] = props[prop];
            }
          }
        );
      });
    }

    return updateTriggers;
  }

  getSortedBins(props) {
    for (const key in this.dimensionUpdaters) {
      this.getDimensionSortedBins(props, this.dimensionUpdaters[key]);
    }
  }

  getDimensionSortedBins(props, dimensionUpdater) {
    const {key} = dimensionUpdater;
    const {getValue} = this.state.dimensions[key];

    const sortedBins = new BinSorter(this.state.layerData.data || [], {
      getValue,
      filterData: props._filterData
    });
    this.setDimensionState(key, {sortedBins});
    this.getDimensionValueDomain(props, dimensionUpdater);
  }

  getDimensionValueDomain(props, dimensionUpdater) {
    const {getDomain, key} = dimensionUpdater;
    const {
      triggers: {lowerPercentile, upperPercentile, scaleType}
    } = getDomain;
    const valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(
      props[scaleType.prop],
      [props[lowerPercentile.prop], props[upperPercentile.prop]]
    );

    this.setDimensionState(key, {valueDomain});
    this.getDimensionScale(props, dimensionUpdater);
  }

  getDimensionScale(props, dimensionUpdater) {
    const {key, getScaleFunc, getDomain} = dimensionUpdater;
    const {domain, range} = getScaleFunc.triggers;
    const {scaleType} = getDomain.triggers;
    const {onSet} = getScaleFunc;
    const dimensionRange = props[range.prop];
    const dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;
    const getScaleFunction = getScaleFunctionByScaleType(scaleType && props[scaleType.prop]);
    const scaleFunc = getScaleFunction(dimensionDomain, dimensionRange);

    if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {
      props[onSet.props](scaleFunc.domain());
    }

    this.setDimensionState(key, {scaleFunc});
  }

  getSubLayerDimensionAttribute(key, nullValue) {
    return cell => {
      const {sortedBins, scaleFunc} = this.state.dimensions[key];
      const bin = sortedBins.binMap[cell.index];

      if (bin && bin.counts === 0) {
        // no points left in bin after filtering
        return nullValue;
      }
      const cv = bin && bin.value;
      const domain = scaleFunc.domain();

      const isValueInDomain = cv >= domain[0] && cv <= domain[domain.length - 1];

      // if cell value is outside domain, set alpha to 0
      return isValueInDomain ? scaleFunc(cv) : nullValue;
    };
  }

  getSubLayerAccessors(props) {
    const accessors = {};
    for (const key in this.dimensionUpdaters) {
      const {accessor} = this.dimensionUpdaters[key];
      accessors[accessor] = this.getSubLayerDimensionAttribute(props, key);
    }

    return accessors;
  }

  getPickingInfo({info}) {
    const isPicked = info.picked && info.index > -1;
    let object = null;

    if (isPicked) {
      // const {sortedColorBins, sortedElevationBins} = this.state;

      // @ts-expect-error
      const cell = this.state.layerData.data[info.index];

      const binInfo = {};
      for (const key in this.dimensionUpdaters) {
        const {pickingInfo} = this.dimensionUpdaters[key];
        const {sortedBins} = this.state.dimensions[key];
        const value = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
        binInfo[pickingInfo] = value;
      }

      object = Object.assign(binInfo, cell, {
        points: cell.filteredPoints || cell.points
      });
    }

    // override object with picked cell
    info.picked = Boolean(object);
    info.object = object;

    return info;
  }

  getAccessor(dimensionKey) {
    if (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {
      return noop;
    }
    return this.dimensionUpdaters[dimensionKey].attributeAccessor;
  }
}

1	// Copyright (c) 2015 - 2018 Uber Technologies, Inc.	1✔
2	//	1✔
3	// Permission is hereby granted, free of charge, to any person obtaining a copy	1✔
4	// of this software and associated documentation files (the "Software"), to deal	1✔
5	// in the Software without restriction, including without limitation the rights	1✔
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell	1✔
7	// copies of the Software, and to permit persons to whom the Software is	1✔
8	// furnished to do so, subject to the following conditions:	1✔
9	//	1✔
10	// The above copyright notice and this permission notice shall be included in	1✔
11	// all copies or substantial portions of the Software.	1✔
12	//	1✔
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	1✔
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	1✔
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE	1✔
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER	1✔
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,	1✔
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN	1✔
19	// THE SOFTWARE.	1✔
20	import BinSorter from './bin-sorter';	1✔
21	import {getScaleFunctionByScaleType} from './scale-utils';	1✔
22	import {getValueFunc, wrapGetValueFunc} from './aggregation-operation-utils';	1✔
23		1✔
24	// eslint-disable-next-line @typescript-eslint/no-empty-function	1✔
25	function noop() {}	×
26		1✔
27	const dimensionSteps = ['getBins', 'getDomain', 'getScaleFunc'];	1✔
28	const defaultDimensions = [	1✔
29	{	1✔
30	key: 'fillColor',	1✔
31	accessor: 'getFillColor',	1✔
32	pickingInfo: 'colorValue',	1✔
33	getBins: {	1✔
34	triggers: {	1✔
35	value: {	1✔
36	prop: 'getColorValue',	1✔
37	updateTrigger: 'getColorValue'	1✔
38	},	1✔
39	weight: {	1✔
40	prop: 'getColorWeight',	1✔
41	updateTrigger: 'getColorWeight'	1✔
42	},	1✔
43	aggregation: {	1✔
44	prop: 'colorAggregation'	1✔
45	},	1✔
46	filterData: {	1✔
47	prop: '_filterData',	1✔
48	updateTrigger: '_filterData'	1✔
49	}	1✔
50	}	1✔
51	},	1✔
52	getDomain: {	1✔
53	triggers: {	1✔
54	lowerPercentile: {	1✔
55	prop: 'lowerPercentile'	1✔
56	},	1✔
57	upperPercentile: {	1✔
58	prop: 'upperPercentile'	1✔
59	},	1✔
60	scaleType: {	1✔
61	prop: 'colorScaleType'	1✔
62	}	1✔
63	}	1✔
64	},	1✔
65	getScaleFunc: {	1✔
66	triggers: {	1✔
67	domain: {prop: 'colorDomain'},	1✔
68	range: {prop: 'colorRange'}	1✔
69	},	1✔
70	onSet: {	1✔
71	props: 'onSetColorDomain'	1✔
72	}	1✔
73	},	1✔
74	nullValue: [0, 0, 0, 0]	1✔
75	},	1✔
76	{	1✔
77	key: 'elevation',	1✔
78	accessor: 'getElevation',	1✔
79	pickingInfo: 'elevationValue',	1✔
80	getBins: {	1✔
81	triggers: {	1✔
82	value: {	1✔
83	prop: 'getElevationValue',	1✔
84	updateTrigger: 'getElevationValue'	1✔
85	},	1✔
86	weight: {	1✔
87	prop: 'getElevationWeight',	1✔
88	updateTrigger: 'getElevationWeight'	1✔
89	},	1✔
90	aggregation: {	1✔
91	prop: 'elevationAggregation'	1✔
92	},	1✔
93	filterData: {	1✔
94	prop: '_filterData',	1✔
95	updateTrigger: '_filterData'	1✔
96	}	1✔
97	}	1✔
98	},	1✔
99	getDomain: {	1✔
100	triggers: {	1✔
101	lowerPercentile: {	1✔
102	prop: 'elevationLowerPercentile'	1✔
103	},	1✔
104	upperPercentile: {	1✔
105	prop: 'elevationUpperPercentile'	1✔
106	},	1✔
107	scaleType: {	1✔
108	prop: 'elevationScaleType'	1✔
109	}	1✔
110	}	1✔
111	},	1✔
112	getScaleFunc: {	1✔
113	triggers: {	1✔
114	domain: {prop: 'elevationDomain'},	1✔
115	range: {prop: 'elevationRange'}	1✔
116	},	1✔
117	onSet: {	1✔
118	props: 'onSetElevationDomain'	1✔
119	}	1✔
120	},	1✔
121	nullValue: -1	1✔
122	}	1✔
123	];	1✔
124	const defaultGetCellSize = props => props.cellSize;	1✔
125	export default class CPUAggregator {	1✔
126	state: {	1✔
127	layerData: {	1✔
128	data?: any[];	1✔
129	};	1✔
130	dimensions: Record<string, any>;	1✔
131	} = {	1✔
132	layerData: {	1✔
133	data: undefined	1✔
134	},	1✔
135	dimensions: {	1✔
136	// color: {	1✔
137	// getValue: null,	1✔
138	// domain: null,	1✔
139	// sortedBins: null,	1✔
140	// scaleFunc: noop	1✔
141	// },	1✔
142	// elevation: {	1✔
143	// getValue: null,	1✔
144	// domain: null,	1✔
145	// sortedBins: null,	1✔
146	// scaleFunc: noop	1✔
147	// }	1✔
148	}	1✔
149	};	1✔
150	changeFlags: Record<string, any> = {};	1✔
151	dimensionUpdaters: Record<string, any> = {};	1✔
152		1✔
153	_getCellSize;	1✔
154	_getAggregator;	1✔
155		1✔
156	constructor(opts) {	1✔
UNCOV 157	this._getCellSize = opts.getCellSize \|\| defaultGetCellSize;	×
UNCOV 158	this._getAggregator = opts.getAggregator;	×
UNCOV 159	this._addDimension(opts.dimensions \|\| defaultDimensions);	×
UNCOV 160	}	×
161		1✔
162	static defaultDimensions() {	1✔
163	return defaultDimensions;	×
164	}	×
165		1✔
166	updateState(opts, aggregationParams) {	1✔
UNCOV 167	const {oldProps, props, changeFlags} = opts;	×
UNCOV 168	this.updateGetValueFuncs(oldProps, props, changeFlags);	×
UNCOV 169	const reprojectNeeded = this.needsReProjectPoints(oldProps, props, changeFlags);	×
UNCOV 170	let aggregationDirty = false;	×
UNCOV 171	if (changeFlags.dataChanged \|\| reprojectNeeded) {	×
UNCOV 172	// project data into bin and aggregate wegiths per bin	×
UNCOV 173	this.getAggregatedData(props, aggregationParams);	×
UNCOV 174	aggregationDirty = true;	×
UNCOV 175	} else {	×
176	const dimensionChanges = this.getDimensionChanges(oldProps, props, changeFlags) \|\| [];	×
177	// this here is layer	×
178	dimensionChanges.forEach(f => typeof f === 'function' && f());	×
179	aggregationDirty = true;	×
180	}	×
UNCOV 181	this.setState({aggregationDirty});	×
UNCOV 182		×
UNCOV 183	return this.state;	×
UNCOV 184	}	×
185		1✔
186	// Update private state	1✔
187	setState(updateObject) {	1✔
UNCOV 188	this.state = {...this.state, ...updateObject};	×
UNCOV 189	}	×
190		1✔
191	// Update private state.dimensions	1✔
192	setDimensionState(key, updateObject) {	1✔
UNCOV 193	this.setState({	×
UNCOV 194	dimensions: {	×
UNCOV 195	...this.state.dimensions,	×
UNCOV 196	[key]: {...this.state.dimensions[key], ...updateObject}	×
UNCOV 197	}	×
UNCOV 198	});	×
UNCOV 199	}	×
200		1✔
201	normalizeResult(result: {hexagons?; layerData?} = {}) {	1✔
UNCOV 202	// support previous hexagonAggregator API	×
UNCOV 203	if (result.hexagons) {	×
UNCOV 204	return {data: result.hexagons, ...result};	×
UNCOV 205	} else if (result.layerData) {	×
206	return {data: result.layerData, ...result};	×
207	}	×
208		×
209	return result;	×
UNCOV 210	}	×
211		1✔
212	getAggregatedData(props, aggregationParams) {	1✔
UNCOV 213	const aggregator = this._getAggregator(props);	×
UNCOV 214		×
UNCOV 215	const result = aggregator(props, aggregationParams);	×
UNCOV 216	this.setState({	×
UNCOV 217	layerData: this.normalizeResult(result)	×
UNCOV 218	});	×
UNCOV 219	this.changeFlags = {	×
UNCOV 220	layerData: true	×
UNCOV 221	};	×
UNCOV 222	this.getSortedBins(props);	×
UNCOV 223	}	×
224		1✔
225	updateGetValueFuncs(oldProps, props, changeFlags) {	1✔
UNCOV 226	for (const key in this.dimensionUpdaters) {	×
UNCOV 227	const {value, weight, aggregation} = this.dimensionUpdaters[key].getBins.triggers;	×
UNCOV 228	let getValue = props[value.prop];	×
UNCOV 229	const getValueChanged = this.needUpdateDimensionStep(	×
UNCOV 230	this.dimensionUpdaters[key].getBins,	×
UNCOV 231	oldProps,	×
UNCOV 232	props,	×
UNCOV 233	changeFlags	×
UNCOV 234	);	×
UNCOV 235		×
UNCOV 236	if (getValueChanged) {	×
UNCOV 237	if (getValue) {	×
UNCOV 238	getValue = wrapGetValueFunc(getValue, {data: props.data});	×
UNCOV 239	} else {	×
UNCOV 240	// If `getValue` is not provided from props, build it with aggregation and weight.	×
UNCOV 241	getValue = getValueFunc(props[aggregation.prop], props[weight.prop], {data: props.data});	×
UNCOV 242	}	×
UNCOV 243	}	×
UNCOV 244		×
UNCOV 245	if (getValue) {	×
UNCOV 246	this.setDimensionState(key, {getValue});	×
UNCOV 247	}	×
UNCOV 248	}	×
UNCOV 249	}	×
250		1✔
251	needsReProjectPoints(oldProps, props, changeFlags) {	1✔
UNCOV 252	return (	×
UNCOV 253	this._getCellSize(oldProps) !== this._getCellSize(props) \|\|	×
254	this._getAggregator(oldProps) !== this._getAggregator(props) \|\|	×
255	(changeFlags.updateTriggersChanged &&	×
256	(changeFlags.updateTriggersChanged.all \|\| changeFlags.updateTriggersChanged.getPosition))	×
UNCOV 257	);	×
UNCOV 258	}	×
259		1✔
260	// Adds dimensions	1✔
261	addDimension(dimensions) {	1✔
262	this._addDimension(dimensions);	×
263	}	×
264		1✔
265	_addDimension(dimensions = []) {	1✔
UNCOV 266	dimensions.forEach(dimension => {	×
UNCOV 267	const {key} = dimension;	×
UNCOV 268	this.dimensionUpdaters[key] = this.getDimensionUpdaters(dimension);	×
UNCOV 269	this.state.dimensions[key] = {	×
UNCOV 270	getValue: null,	×
UNCOV 271	domain: null,	×
UNCOV 272	sortedBins: null,	×
UNCOV 273	scaleFunc: noop	×
UNCOV 274	};	×
UNCOV 275	});	×
UNCOV 276	}	×
277		1✔
278	getDimensionUpdaters({key, accessor, pickingInfo, getBins, getDomain, getScaleFunc, nullValue}) {	1✔
UNCOV 279	return {	×
UNCOV 280	key,	×
UNCOV 281	accessor,	×
UNCOV 282	pickingInfo,	×
UNCOV 283	getBins: {updater: this.getDimensionSortedBins.bind(this), ...getBins},	×
UNCOV 284	getDomain: {updater: this.getDimensionValueDomain.bind(this), ...getDomain},	×
UNCOV 285	getScaleFunc: {updater: this.getDimensionScale.bind(this), ...getScaleFunc},	×
UNCOV 286	attributeAccessor: this.getSubLayerDimensionAttribute(key, nullValue)	×
UNCOV 287	};	×
UNCOV 288	}	×
289		1✔
290	needUpdateDimensionStep(dimensionStep, oldProps, props, changeFlags) {	1✔
UNCOV 291	// whether need to update current dimension step	×
UNCOV 292	// dimension step is the value, domain, scaleFunction of each dimension	×
UNCOV 293	// each step is an object with properties links to layer prop and whether the prop is	×
UNCOV 294	// controlled by updateTriggers	×
UNCOV 295	// getBins: {	×
UNCOV 296	// value: {	×
UNCOV 297	// prop: 'getElevationValue',	×
UNCOV 298	// updateTrigger: 'getElevationValue'	×
UNCOV 299	// },	×
UNCOV 300	// weight: {	×
UNCOV 301	// prop: 'getElevationWeight',	×
UNCOV 302	// updateTrigger: 'getElevationWeight'	×
UNCOV 303	// },	×
UNCOV 304	// aggregation: {	×
UNCOV 305	// prop: 'elevationAggregation'	×
UNCOV 306	// }	×
UNCOV 307	// }	×
UNCOV 308	return Object.values(dimensionStep.triggers).some((item: any) => {	×
UNCOV 309	if (item.updateTrigger) {	×
UNCOV 310	// check based on updateTriggers change first	×
UNCOV 311	// if data has changed, always update value	×
UNCOV 312	return (	×
UNCOV 313	changeFlags.dataChanged \|\|	×
314	(changeFlags.updateTriggersChanged &&	×
315	(changeFlags.updateTriggersChanged.all \|\|	×
316	changeFlags.updateTriggersChanged[item.updateTrigger]))	×
UNCOV 317	);	×
UNCOV 318	}	×
319	// fallback to direct comparison	×
320	return oldProps[item.prop] !== props[item.prop];	×
UNCOV 321	});	×
UNCOV 322	}	×
323		1✔
324	getDimensionChanges(oldProps: any, props: any, changeFlags: any): Function[] \| null {	1✔
325	// const {dimensionUpdaters} = this.state;	×
326	const updaters: Function[] = [];	×
327		×
328	// get dimension to be updated	×
329	for (const key in this.dimensionUpdaters) {	×
330	// return the first triggered updater for each dimension	×
331	const needUpdate = dimensionSteps.find(step =>	×
332	this.needUpdateDimensionStep(	×
333	this.dimensionUpdaters[key][step],	×
334	oldProps,	×
335	props,	×
336	changeFlags	×
337	)	×
338	);	×
339		×
340	if (needUpdate) {	×
341	updaters.push(	×
342	this.dimensionUpdaters[key][needUpdate].updater.bind(	×
343	this,	×
344	props,	×
345	this.dimensionUpdaters[key]	×
346	)	×
347	);	×
348	}	×
349	}	×
350		×
351	return updaters.length ? updaters : null;	×
352	}	×
353		1✔
354	getUpdateTriggers(props) {	1✔
UNCOV 355	const _updateTriggers = props.updateTriggers \|\| {};	×
UNCOV 356	const updateTriggers = {};	×
UNCOV 357		×
UNCOV 358	for (const key in this.dimensionUpdaters) {	×
UNCOV 359	const {accessor} = this.dimensionUpdaters[key];	×
UNCOV 360	// fold dimension triggers into each accessor	×
UNCOV 361	updateTriggers[accessor] = {};	×
UNCOV 362		×
UNCOV 363	dimensionSteps.forEach(step => {	×
UNCOV 364	Object.values(this.dimensionUpdaters[key][step].triggers).forEach(	×
UNCOV 365	({prop, updateTrigger}: any) => {	×
UNCOV 366	if (updateTrigger) {	×
UNCOV 367	// if prop is based on updateTrigger e.g. getColorValue, getColorWeight	×
UNCOV 368	// and updateTriggers is passed in from layer prop	×
UNCOV 369	// fold the updateTriggers into accessor	×
UNCOV 370	const fromProp = _updateTriggers[updateTrigger];	×
UNCOV 371	if (typeof fromProp === 'object' && !Array.isArray(fromProp)) {	×
372	// if updateTrigger is an object spread it	×
373	Object.assign(updateTriggers[accessor], fromProp);	×
UNCOV 374	} else if (fromProp !== undefined) {	×
375	updateTriggers[accessor][prop] = fromProp;	×
376	}	×
UNCOV 377	} else {	×
UNCOV 378	// if prop is not based on updateTrigger	×
UNCOV 379	updateTriggers[accessor][prop] = props[prop];	×
UNCOV 380	}	×
UNCOV 381	}	×
UNCOV 382	);	×
UNCOV 383	});	×
UNCOV 384	}	×
UNCOV 385		×
UNCOV 386	return updateTriggers;	×
UNCOV 387	}	×
388		1✔
389	getSortedBins(props) {	1✔
UNCOV 390	for (const key in this.dimensionUpdaters) {	×
UNCOV 391	this.getDimensionSortedBins(props, this.dimensionUpdaters[key]);	×
UNCOV 392	}	×
UNCOV 393	}	×
394		1✔
395	getDimensionSortedBins(props, dimensionUpdater) {	1✔
UNCOV 396	const {key} = dimensionUpdater;	×
UNCOV 397	const {getValue} = this.state.dimensions[key];	×
UNCOV 398		×
UNCOV 399	const sortedBins = new BinSorter(this.state.layerData.data \|\| [], {	×
UNCOV 400	getValue,	×
UNCOV 401	filterData: props._filterData	×
UNCOV 402	});	×
UNCOV 403	this.setDimensionState(key, {sortedBins});	×
UNCOV 404	this.getDimensionValueDomain(props, dimensionUpdater);	×
UNCOV 405	}	×
406		1✔
407	getDimensionValueDomain(props, dimensionUpdater) {	1✔
UNCOV 408	const {getDomain, key} = dimensionUpdater;	×
UNCOV 409	const {	×
UNCOV 410	triggers: {lowerPercentile, upperPercentile, scaleType}	×
UNCOV 411	} = getDomain;	×
UNCOV 412	const valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(	×
UNCOV 413	props[scaleType.prop],	×
UNCOV 414	[props[lowerPercentile.prop], props[upperPercentile.prop]]	×
UNCOV 415	);	×
UNCOV 416		×
UNCOV 417	this.setDimensionState(key, {valueDomain});	×
UNCOV 418	this.getDimensionScale(props, dimensionUpdater);	×
UNCOV 419	}	×
420		1✔
421	getDimensionScale(props, dimensionUpdater) {	1✔
UNCOV 422	const {key, getScaleFunc, getDomain} = dimensionUpdater;	×
UNCOV 423	const {domain, range} = getScaleFunc.triggers;	×
UNCOV 424	const {scaleType} = getDomain.triggers;	×
UNCOV 425	const {onSet} = getScaleFunc;	×
UNCOV 426	const dimensionRange = props[range.prop];	×
UNCOV 427	const dimensionDomain = props[domain.prop] \|\| this.state.dimensions[key].valueDomain;	×
UNCOV 428	const getScaleFunction = getScaleFunctionByScaleType(scaleType && props[scaleType.prop]);	×
UNCOV 429	const scaleFunc = getScaleFunction(dimensionDomain, dimensionRange);	×
UNCOV 430		×
UNCOV 431	if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {	×
UNCOV 432	props[onSet.props](scaleFunc.domain());	×
UNCOV 433	}	×
UNCOV 434		×
UNCOV 435	this.setDimensionState(key, {scaleFunc});	×
UNCOV 436	}	×
437		1✔
438	getSubLayerDimensionAttribute(key, nullValue) {	1✔
UNCOV 439	return cell => {	×
UNCOV 440	const {sortedBins, scaleFunc} = this.state.dimensions[key];	×
UNCOV 441	const bin = sortedBins.binMap[cell.index];	×
UNCOV 442		×
UNCOV 443	if (bin && bin.counts === 0) {	×
444	// no points left in bin after filtering	×
445	return nullValue;	×
446	}	×
UNCOV 447	const cv = bin && bin.value;	×
UNCOV 448	const domain = scaleFunc.domain();	×
UNCOV 449		×
UNCOV 450	const isValueInDomain = cv >= domain[0] && cv <= domain[domain.length - 1];	×
UNCOV 451		×
UNCOV 452	// if cell value is outside domain, set alpha to 0	×
UNCOV 453	return isValueInDomain ? scaleFunc(cv) : nullValue;	×
UNCOV 454	};	×
UNCOV 455	}	×
456		1✔
457	getSubLayerAccessors(props) {	1✔
458	const accessors = {};	×
459	for (const key in this.dimensionUpdaters) {	×
460	const {accessor} = this.dimensionUpdaters[key];	×
461	accessors[accessor] = this.getSubLayerDimensionAttribute(props, key);	×
462	}	×
463		×
464	return accessors;	×
465	}	×
466		1✔
467	getPickingInfo({info}) {	1✔
468	const isPicked = info.picked && info.index > -1;	×
469	let object = null;	×
470		×
471	if (isPicked) {	×
472	// const {sortedColorBins, sortedElevationBins} = this.state;	×
473		×
474	// @ts-expect-error	×
475	const cell = this.state.layerData.data[info.index];	×
476		×
477	const binInfo = {};	×
478	for (const key in this.dimensionUpdaters) {	×
479	const {pickingInfo} = this.dimensionUpdaters[key];	×
480	const {sortedBins} = this.state.dimensions[key];	×
481	const value = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;	×
482	binInfo[pickingInfo] = value;	×
483	}	×
484		×
485	object = Object.assign(binInfo, cell, {	×
486	points: cell.filteredPoints \|\| cell.points	×
487	});	×
488	}	×
489		×
490	// override object with picked cell	×
491	info.picked = Boolean(object);	×
492	info.object = object;	×
493		×
494	return info;	×
495	}	×
496		1✔
497	getAccessor(dimensionKey) {	1✔
UNCOV 498	if (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {	×
499	return noop;	×
500	}	×
UNCOV 501	return this.dimensionUpdaters[dimensionKey].attributeAccessor;	×
UNCOV 502	}	×
503	}	1✔

visgl / deck.gl / 10519844544

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous