@deck.gl/aggregation-layers 9.0.40 → 9.1.0-beta.3

package/src/grid-aggregation-layer.ts

@@ -1,243 +0,0 @@
-// Copyright (c) 2015 - 2017 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 {GL} from '@luma.gl/constants';
-import {LayerContext, log, UpdateParameters, Accessor} from '@deck.gl/core';
-import AggregationLayer, {AggregationLayerProps} from './aggregation-layer';
-import GPUGridAggregator from './utils/gpu-grid-aggregation/gpu-grid-aggregator';
-import BinSorter from './utils/bin-sorter';
-import {pointToDensityGridDataCPU} from './cpu-grid-layer/grid-aggregator';
-import type {Buffer} from '@luma.gl/core';
-
-export type GridAggregationLayerProps<DataT> = AggregationLayerProps<DataT>;
-
-export default abstract class GridAggregationLayer<
-  DataT,
-  ExtraPropsT extends {} = {}
-> extends AggregationLayer<DataT, ExtraPropsT> {
-  static layerName = 'GridAggregationLayer';
-
-  state!: AggregationLayer<DataT>['state'] & {
-    aggregationDataDirty?: boolean;
-    aggregationWeightsDirty?: boolean;
-    aggregationDirty?: boolean;
-    gpuAggregation?: any;
-    getValue?: () => any;
-    sortedBins?: BinSorter;
-    weights: {
-      [key: string]: {
-        aggregationBuffer?: Buffer;
-        maxMinBuffer?: Buffer;
-        aggregationData: Float32Array | null;
-        maxMinData: Float32Array;
-        maxData: Float32Array;
-        minData: Float32Array;
-        getWeight: Accessor<DataT, number>;
-        operation: number;
-      };
-    };
-    cpuGridAggregator?: Function;
-    gpuGridAggregator?: GPUGridAggregator;
-    layerData: any;
-    numRow: number;
-    numCol: number;
-    gridOffset: {xOffset: number; yOffset: number};
-    posOffset: number[];
-    gridOrigin: number[];
-    translation: number[];
-    scaling: number[];
-    boundingBox: {xMin: number; yMin: number; xMax: number; yMax: number};
-    projectPoints?: (p: [number, number]) => [number, number];
-  };
-
-  initializeAggregationLayer({dimensions}) {
-    super.initializeAggregationLayer(dimensions);
-    this.setState({
-      // CPU aggregation results
-      layerData: {},
-      gpuGridAggregator: new GPUGridAggregator(this.context.device, {
-        id: `${this.id}-gpu-aggregator`
-      }),
-      cpuGridAggregator: pointToDensityGridDataCPU
-    });
-  }
-
-  updateState(opts: UpdateParameters<this>) {
-    // get current attributes
-    super.updateState(opts);
-
-    this.updateAggregationState(opts);
-
-    const {aggregationDataDirty, aggregationWeightsDirty, gpuAggregation} = this.state;
-    if (this.getNumInstances() <= 0) {
-      return;
-    }
-    let aggregationDirty = false;
-    // CPU aggregation is two steps
-    // 1. Create bins (based on cellSize and position) 2. Aggregate weights for each bin
-    // For GPU aggregation both above steps are combined into one step
-
-    // step-1
-    if (aggregationDataDirty || (gpuAggregation && aggregationWeightsDirty)) {
-      this._updateAggregation(opts);
-      aggregationDirty = true;
-    }
-    // step-2 (Applicalbe for CPU aggregation only)
-    if (!gpuAggregation && (aggregationDataDirty || aggregationWeightsDirty)) {
-      this._updateWeightBins();
-      this._uploadAggregationResults();
-      aggregationDirty = true;
-    }
-
-    this.setState({aggregationDirty});
-  }
-
-  finalizeState(context: LayerContext) {
-    const {count} = this.state.weights;
-    if (count && count.aggregationBuffer) {
-      count.aggregationBuffer.delete();
-    }
-    this.state.gpuGridAggregator?.delete();
-    super.finalizeState(context);
-  }
-
-  updateShaders(shaders: any): void {
-    if (this.state.gpuAggregation) {
-      this.state.gpuGridAggregator!.updateShaders(shaders);
-    }
-  }
-
-  // Methods that can be overriden by subclasses for customizations
-
-  updateAggregationState(opts: UpdateParameters<this>) {
-    // Sublayers should implement this method.
-    log.assert(false);
-  }
-
-  allocateResources(numRow, numCol) {
-    if (this.state.numRow !== numRow || this.state.numCol !== numCol) {
-      const dataBytes = numCol * numRow * 4 * 4;
-      const {weights} = this.state;
-      for (const name in weights) {
-        const weight = weights[name];
-        if (weight.aggregationBuffer) {
-          weight.aggregationBuffer.delete();
-        }
-        weight.aggregationBuffer = this.context.device.createBuffer({
-          byteLength: dataBytes,
-          // @ts-expect-error legacy
-          accessor: {
-            size: 4,
-            type: GL.FLOAT,
-            divisor: 1
-          }
-        });
-      }
-    }
-  }
-
-  updateResults({aggregationData, maxMinData, maxData, minData}) {
-    const {count} = this.state.weights;
-    if (count) {
-      count.aggregationData = aggregationData;
-      count.maxMinData = maxMinData;
-      count.maxData = maxData;
-      count.minData = minData;
-    }
-  }
-
-  // Private
-
-  _updateAggregation(opts) {
-    const {
-      cpuGridAggregator,
-      gpuGridAggregator,
-      gridOffset,
-      posOffset,
-      translation = [0, 0],
-      scaling = [0, 0, 0],
-      boundingBox,
-      projectPoints,
-      gpuAggregation,
-      numCol,
-      numRow
-    } = this.state;
-    const {props} = opts;
-    const {viewport} = this.context;
-    const attributes = this.getAttributes();
-    const vertexCount = this.getNumInstances();
-
-    if (!gpuAggregation) {
-      const result = cpuGridAggregator!(props, {
-        gridOffset,
-        projectPoints,
-        attributes,
-        viewport,
-        posOffset,
-        boundingBox
-      });
-      this.setState({
-        layerData: result
-      });
-    } else {
-      const {weights} = this.state;
-      gpuGridAggregator!.run({
-        weights,
-        cellSize: [gridOffset.xOffset, gridOffset.yOffset],
-        numCol,
-        numRow,
-        translation,
-        scaling,
-        vertexCount,
-        projectPoints,
-        attributes,
-        moduleSettings: this.getModuleSettings()
-      });
-    }
-  }
-
-  _updateWeightBins() {
-    const {getValue} = this.state;
-
-    const sortedBins = new BinSorter(this.state.layerData.data || [], {getValue});
-    this.setState({sortedBins});
-  }
-
-  _uploadAggregationResults(): void {
-    const {numCol, numRow} = this.state;
-    const {data} = this.state.layerData;
-    const {aggregatedBins, minValue, maxValue, totalCount} = this.state.sortedBins!;
-
-    const ELEMENTCOUNT = 4;
-    const aggregationSize = numCol * numRow * ELEMENTCOUNT;
-    const aggregationData = new Float32Array(aggregationSize).fill(0);
-    for (const bin of aggregatedBins) {
-      const {lonIdx, latIdx} = data[bin.i];
-      const {value, counts} = bin;
-      const cellIndex = (lonIdx + latIdx * numCol) * ELEMENTCOUNT;
-      aggregationData[cellIndex] = value;
-      aggregationData[cellIndex + ELEMENTCOUNT - 1] = counts;
-    }
-    const maxMinData = new Float32Array([maxValue, 0, 0, minValue]);
-    const maxData = new Float32Array([maxValue, 0, 0, totalCount]);
-    const minData = new Float32Array([minValue, 0, 0, totalCount]);
-    this.updateResults({aggregationData, maxMinData, maxData, minData});
-  }
-}

package/src/hexagon-layer/hexagon-aggregator.ts

@@ -1,127 +0,0 @@
-// Copyright (c) 2015 - 2017 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 {hexbin} from 'd3-hexbin';
-import {createIterable, log} from '@deck.gl/core';
-
-/**
- * Use d3-hexbin to performs hexagonal binning from geo points to hexagons
- * @param {Iterable} data - array of points
- * @param {Number} radius - hexagon radius in meter
- * @param {function} getPosition - get points lon lat
- * @param {Object} viewport - current viewport object
-
- * @return {Object} - hexagons and countRange
- */
-export function pointToHexbin(props, aggregationParams) {
-  const {data, radius} = props;
-  const {viewport, attributes} = aggregationParams;
-  // get hexagon radius in mercator world unit
-  const centerLngLat = data.length ? getPointsCenter(data, aggregationParams) : null;
-  const radiusCommon = getRadiusInCommon(radius, viewport, centerLngLat);
-
-  // add world space coordinates to points
-  const screenPoints: {
-    screenCoord: number[];
-    source: any;
-    index: number;
-  }[] = [];
-  const {iterable, objectInfo} = createIterable(data);
-  const positions = attributes.positions.value;
-  const {size} = attributes.positions.getAccessor();
-  for (const object of iterable) {
-    objectInfo.index++;
-    const posIndex = objectInfo.index * size;
-    const position = [positions[posIndex], positions[posIndex + 1]];
-    const arrayIsFinite = Number.isFinite(position[0]) && Number.isFinite(position[1]);
-    if (arrayIsFinite) {
-      screenPoints.push({
-        screenCoord: viewport.projectFlat(position),
-        source: object,
-        index: objectInfo.index
-      });
-    } else {
-      log.warn('HexagonLayer: invalid position')();
-    }
-  }
-
-  const newHexbin = hexbin()
-    .radius(radiusCommon)
-    .x(d => d.screenCoord[0])
-    .y(d => d.screenCoord[1]);
-
-  const hexagonBins = newHexbin(screenPoints);
-
-  return {
-    hexagons: hexagonBins.map((hex, index) => ({
-      position: viewport.unprojectFlat([hex.x, hex.y]),
-      points: hex,
-      index
-    })),
-    radiusCommon
-  };
-}
-
-/**
- * Get the bounding box of all data points
- */
-export function getPointsCenter(data, aggregationParams) {
-  const {attributes} = aggregationParams;
-  const positions = attributes.positions.value;
-  const {size} = attributes.positions.getAccessor();
-
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  let i;
-
-  for (i = 0; i < size * data.length; i += size) {
-    const x = positions[i];
-    const y = positions[i + 1];
-    const arrayIsFinite = Number.isFinite(x) && Number.isFinite(y);
-
-    if (arrayIsFinite) {
-      minX = Math.min(x, minX);
-      maxX = Math.max(x, maxX);
-      minY = Math.min(y, minY);
-      maxY = Math.max(y, maxY);
-    }
-  }
-
-  // return center
-  return [minX, minY, maxX, maxY].every(Number.isFinite)
-    ? [(minX + maxX) / 2, (minY + maxY) / 2]
-    : null;
-}
-
-/**
- * Get radius in mercator world space coordinates from meter
- * @param {Number} radius - in meter
- * @param {Object} viewport - current viewport object
- * @param {Array<Number>} center - data center
-
- * @return {Number} radius in mercator world spcae coordinates
- */
-export function getRadiusInCommon(radius, viewport, center) {
-  const {unitsPerMeter} = viewport.getDistanceScales(center);
-  // x, y distance should be the same
-  return radius * unitsPerMeter[0];
-}

package/src/utils/aggregation-operation-utils.ts

@@ -1,118 +0,0 @@
-// Copyright (c) 2015 - 2019 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.
-
-export const AGGREGATION_OPERATION = {
-  SUM: 1,
-  MEAN: 2,
-  MIN: 3,
-  MAX: 4
-};
-
-function sumReducer(accu, cur) {
-  return accu + cur;
-}
-
-function maxReducer(accu, cur) {
-  return cur > accu ? cur : accu;
-}
-
-function minReducer(accu, cur) {
-  return cur < accu ? cur : accu;
-}
-
-export function getMean(pts, accessor) {
-  if (Number.isFinite(accessor)) {
-    return pts.length ? accessor : null;
-  }
-  const filtered = pts.map(accessor).filter(Number.isFinite);
-
-  return filtered.length ? filtered.reduce(sumReducer, 0) / filtered.length : null;
-}
-
-export function getSum(pts, accessor) {
-  if (Number.isFinite(accessor)) {
-    return pts.length ? pts.length * accessor : null;
-  }
-  const filtered = pts.map(accessor).filter(Number.isFinite);
-
-  return filtered.length ? filtered.reduce(sumReducer, 0) : null;
-}
-
-export function getMax(pts, accessor) {
-  if (Number.isFinite(accessor)) {
-    return pts.length ? accessor : null;
-  }
-  const filtered = pts.map(accessor).filter(Number.isFinite);
-
-  return filtered.length ? filtered.reduce(maxReducer, -Infinity) : null;
-}
-
-export function getMin(pts, accessor) {
-  if (Number.isFinite(accessor)) {
-    return pts.length ? accessor : null;
-  }
-  const filtered = pts.map(accessor).filter(Number.isFinite);
-
-  return filtered.length ? filtered.reduce(minReducer, Infinity) : null;
-}
-
-// Function to convert from aggregation/accessor props (like colorAggregation and getColorWeight) to getValue prop (like getColorValue)
-export function getValueFunc(aggregation, accessor, context) {
-  const op = AGGREGATION_OPERATION[aggregation] || AGGREGATION_OPERATION.SUM;
-  accessor = wrapAccessor(accessor, context);
-  switch (op) {
-    case AGGREGATION_OPERATION.MIN:
-      return pts => getMin(pts, accessor);
-    case AGGREGATION_OPERATION.SUM:
-      return pts => getSum(pts, accessor);
-    case AGGREGATION_OPERATION.MEAN:
-      return pts => getMean(pts, accessor);
-    case AGGREGATION_OPERATION.MAX:
-      return pts => getMax(pts, accessor);
-    default:
-      return null;
-  }
-}
-
-type AccessorContext = {
-  data?;
-  index?: number;
-  indices?: number[];
-};
-
-function wrapAccessor(accessor, context: AccessorContext = {}) {
-  if (Number.isFinite(accessor)) {
-    return accessor;
-  }
-  return pt => {
-    context.index = pt.index;
-    return accessor(pt.source, context);
-  };
-}
-
-export function wrapGetValueFunc(getValue, context: AccessorContext = {}) {
-  return pts => {
-    context.indices = pts.map(pt => pt.index);
-    return getValue(
-      pts.map(pt => pt.source),
-      context
-    );
-  };
-}

package/src/utils/bin-sorter.ts

@@ -1,218 +0,0 @@
-// Copyright (c) 2015 - 2017 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.
-
-// getValue takes an array of points returns a value to sort the bins on.
-// by default it returns the number of points
-// this is where to pass in a function to color the bins by
-// avg/mean/max of specific value of the point
-const defaultGetValue = points => points.length;
-
-import {clamp, getQuantileDomain, getOrdinalDomain} from './scale-utils';
-
-const MAX_32_BIT_FLOAT = 3.402823466e38;
-
-// access array of points in each bin
-const defaultGetPoints = bin => bin.points;
-// access index of each bin
-const defaultGetIndex = bin => bin.index;
-
-// d3-scending
-const ascending = (a, b) => (a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN);
-
-const defaultProps = {
-  getValue: defaultGetValue,
-  getPoints: defaultGetPoints,
-  getIndex: defaultGetIndex,
-  filterData: null
-};
-
-export type AggregatedBin = {
-  i: number;
-  value: any;
-  counts: number;
-};
-
-export default class BinSorter {
-  maxCount!: number;
-  maxValue!: number;
-  minValue!: number;
-  totalCount!: number;
-
-  aggregatedBins: AggregatedBin[];
-  sortedBins!: AggregatedBin[];
-  binMap: Record<number, AggregatedBin>;
-
-  constructor(bins: unknown[] = [], props: Partial<typeof defaultProps> = defaultProps) {
-    this.aggregatedBins = this.getAggregatedBins(bins, props);
-    this._updateMinMaxValues();
-    this.binMap = this.getBinMap();
-  }
-
-  /**
-   * Get an array of object with aggregated values and index of bins
-   * Array object will be sorted by value optionally.
-   * @param {Array} bins
-   * @param {Function} getValue
-   * @return {Array} array of values and index lookup
-   */
-  getAggregatedBins(bins, props): AggregatedBin[] {
-    const {
-      getValue = defaultGetValue,
-      getPoints = defaultGetPoints,
-      getIndex = defaultGetIndex,
-      filterData
-    } = props;
-
-    const hasFilter = typeof filterData === 'function';
-    const binCount = bins.length;
-    const aggregatedBins: AggregatedBin[] = [];
-    let index = 0;
-
-    for (let binIndex = 0; binIndex < binCount; binIndex++) {
-      const bin = bins[binIndex];
-      const points = getPoints(bin);
-      const i = getIndex(bin);
-
-      const filteredPoints = hasFilter ? points.filter(filterData) : points;
-
-      bin.filteredPoints = hasFilter ? filteredPoints : null;
-
-      const value = filteredPoints.length ? getValue(filteredPoints) : null;
-
-      if (value !== null && value !== undefined) {
-        // filter bins if value is null or undefined
-        aggregatedBins[index] = {
-          i: Number.isFinite(i) ? i : binIndex,
-          value,
-          counts: filteredPoints.length
-        };
-        index++;
-      }
-    }
-    return aggregatedBins;
-  }
-
-  _percentileToIndex(percentileRange): [number, number] {
-    const len = this.sortedBins.length;
-    if (len < 2) {
-      return [0, 0];
-    }
-
-    const [lower, upper] = percentileRange.map(n => clamp(n, 0, 100));
-
-    const lowerIdx = Math.ceil((lower / 100) * (len - 1));
-    const upperIdx = Math.floor((upper / 100) * (len - 1));
-
-    return [lowerIdx, upperIdx];
-  }
-
-  /**
-   * Get a mapping from cell/hexagon index to sorted bin
-   * This is used to retrieve bin value for color calculation
-   * @return {Object} bin index to aggregatedBins
-   */
-  getBinMap(): Record<number, AggregatedBin> {
-    const binMap = {};
-    for (const bin of this.aggregatedBins) {
-      binMap[bin.i] = bin;
-    }
-    return binMap;
-  }
-
-  // Private
-
-  /**
-   * Get ths max count of all bins
-   */
-  _updateMinMaxValues(): void {
-    let maxCount = 0;
-    let maxValue = 0;
-    let minValue = MAX_32_BIT_FLOAT;
-    let totalCount = 0;
-    for (const x of this.aggregatedBins) {
-      maxCount = maxCount > x.counts ? maxCount : x.counts;
-      maxValue = maxValue > x.value ? maxValue : x.value;
-      minValue = minValue < x.value ? minValue : x.value;
-      totalCount += x.counts;
-    }
-    this.maxCount = maxCount;
-    this.maxValue = maxValue;
-    this.minValue = minValue;
-    this.totalCount = totalCount;
-  }
-
-  /**
-   * Get range of values of all bins
-   * @param {Number[]} range
-   * @param {Number} range[0] - lower bound
-   * @param {Number} range[1] - upper bound
-   * @return {Array} array of new value range
-   */
-  getValueRange(percentileRange: [number, number]): [number, number] {
-    if (!this.sortedBins) {
-      this.sortedBins = this.aggregatedBins.sort((a, b) => ascending(a.value, b.value));
-    }
-    if (!this.sortedBins.length) {
-      // @ts-expect-error
-      return [];
-    }
-    let lowerIdx = 0;
-    let upperIdx = this.sortedBins.length - 1;
-
-    if (Array.isArray(percentileRange)) {
-      const idxRange = this._percentileToIndex(percentileRange);
-      lowerIdx = idxRange[0];
-      upperIdx = idxRange[1];
-    }
-
-    return [this.sortedBins[lowerIdx].value, this.sortedBins[upperIdx].value];
-  }
-
-  getValueDomainByScale(scale: string, [lower = 0, upper = 100] = []) {
-    if (!this.sortedBins) {
-      this.sortedBins = this.aggregatedBins.sort((a, b) => ascending(a.value, b.value));
-    }
-    if (!this.sortedBins.length) {
-      return [];
-    }
-    const indexEdge = this._percentileToIndex([lower, upper]);
-
-    return this._getScaleDomain(scale, indexEdge);
-  }
-
-  _getScaleDomain(scaleType: string, [lowerIdx, upperIdx]: [number, number]): [number, number] {
-    const bins = this.sortedBins;
-
-    switch (scaleType) {
-      case 'quantize':
-      case 'linear':
-        return [bins[lowerIdx].value, bins[upperIdx].value];
-
-      case 'quantile':
-        return getQuantileDomain(bins.slice(lowerIdx, upperIdx + 1), d => d.value);
-
-      case 'ordinal':
-        return getOrdinalDomain(bins, d => d.value) as [number, number];
-
-      default:
-        return [bins[lowerIdx].value, bins[upperIdx].value];
-    }
-  }
-}