@deck.gl/aggregation-layers 8.8.0-beta.2 → 8.8.0-beta.5

package/typed/contour-layer/contour-layer.js

@@ -1,234 +0,0 @@
-// 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 GL from '@luma.gl/constants';
-import { LineLayer, SolidPolygonLayer } from '@deck.gl/layers';
-import { generateContours } from './contour-utils';
-import { log } from '@deck.gl/core';
-import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
-import { AGGREGATION_OPERATION, getValueFunc } from '../utils/aggregation-operation-utils';
-import { getBoundingBox, getGridParams } from '../utils/grid-aggregation-utils';
-import GridAggregationLayer from '../grid-aggregation-layer';
-const DEFAULT_COLOR = [255, 255, 255, 255];
-const DEFAULT_STROKE_WIDTH = 1;
-const DEFAULT_THRESHOLD = 1;
-const defaultProps = {
-    // grid aggregation
-    cellSize: { type: 'number', min: 1, max: 1000, value: 1000 },
-    getPosition: { type: 'accessor', value: x => x.position },
-    getWeight: { type: 'accessor', value: 1 },
-    gpuAggregation: true,
-    aggregation: 'SUM',
-    // contour lines
-    contours: [{ threshold: DEFAULT_THRESHOLD }],
-    zOffset: 0.005
-};
-const POSITION_ATTRIBUTE_NAME = 'positions';
-const DIMENSIONS = {
-    data: {
-        props: ['cellSize']
-    },
-    weights: {
-        props: ['aggregation'],
-        accessors: ['getWeight']
-    }
-};
-export default class ContourLayer extends GridAggregationLayer {
-    initializeState() {
-        super.initializeAggregationLayer({
-            dimensions: DIMENSIONS
-        });
-        this.setState({
-            contourData: {},
-            projectPoints: false,
-            weights: {
-                count: {
-                    size: 1,
-                    operation: AGGREGATION_OPERATION.SUM
-                }
-            }
-        });
-        const attributeManager = this.getAttributeManager();
-        attributeManager.add({
-            [POSITION_ATTRIBUTE_NAME]: {
-                size: 3,
-                accessor: 'getPosition',
-                type: GL.DOUBLE,
-                fp64: this.use64bitPositions()
-            },
-            // this attribute is used in gpu aggregation path only
-            count: { size: 3, accessor: 'getWeight' }
-        });
-    }
-    updateState(opts) {
-        super.updateState(opts);
-        let contoursChanged = false;
-        const { oldProps, props } = opts;
-        const { aggregationDirty } = this.state;
-        if (oldProps.contours !== props.contours || oldProps.zOffset !== props.zOffset) {
-            contoursChanged = true;
-            this._updateThresholdData(opts.props);
-        }
-        if (this.getNumInstances() > 0 && (aggregationDirty || contoursChanged)) {
-            this._generateContours();
-        }
-    }
-    renderLayers() {
-        const { contourSegments, contourPolygons } = this.state.contourData;
-        const LinesSubLayerClass = this.getSubLayerClass('lines', LineLayer);
-        const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);
-        // Contour lines layer
-        const lineLayer = contourSegments &&
-            contourSegments.length > 0 &&
-            new LinesSubLayerClass(this.getSubLayerProps({
-                id: 'lines'
-            }), {
-                data: this.state.contourData.contourSegments,
-                getSourcePosition: d => d.start,
-                getTargetPosition: d => d.end,
-                getColor: d => d.contour.color || DEFAULT_COLOR,
-                getWidth: d => d.contour.strokeWidth || DEFAULT_STROKE_WIDTH
-            });
-        // Contour bands layer
-        const bandsLayer = contourPolygons &&
-            contourPolygons.length > 0 &&
-            new BandsSubLayerClass(this.getSubLayerProps({
-                id: 'bands'
-            }), {
-                data: this.state.contourData.contourPolygons,
-                getPolygon: d => d.vertices,
-                getFillColor: d => d.contour.color || DEFAULT_COLOR
-            });
-        return [lineLayer, bandsLayer];
-    }
-    // Aggregation Overrides
-    /* eslint-disable max-statements, complexity */
-    updateAggregationState(opts) {
-        const { props, oldProps } = opts;
-        const { cellSize, coordinateSystem } = props;
-        const { viewport } = this.context;
-        const cellSizeChanged = oldProps.cellSize !== cellSize;
-        let gpuAggregation = props.gpuAggregation;
-        if (this.state.gpuAggregation !== props.gpuAggregation) {
-            if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.gl)) {
-                log.warn('GPU Grid Aggregation not supported, falling back to CPU')();
-                gpuAggregation = false;
-            }
-        }
-        const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;
-        this.setState({
-            gpuAggregation
-        });
-        const { dimensions } = this.state;
-        const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
-        const { data, weights } = dimensions;
-        let { boundingBox } = this.state;
-        if (positionsChanged) {
-            boundingBox = getBoundingBox(this.getAttributes(), this.getNumInstances());
-            this.setState({ boundingBox });
-        }
-        if (positionsChanged || cellSizeChanged) {
-            const { gridOffset, translation, width, height, numCol, numRow } = getGridParams(boundingBox, cellSize, viewport, coordinateSystem);
-            this.allocateResources(numRow, numCol);
-            this.setState({
-                gridOffset,
-                boundingBox,
-                translation,
-                posOffset: translation.slice(),
-                gridOrigin: [-1 * translation[0], -1 * translation[1]],
-                width,
-                height,
-                numCol,
-                numRow
-            });
-        }
-        const aggregationDataDirty = positionsChanged ||
-            gpuAggregationChanged ||
-            this.isAggregationDirty(opts, {
-                dimension: data,
-                compareAll: gpuAggregation // check for all (including extentions props) when using gpu aggregation
-            });
-        const aggregationWeightsDirty = this.isAggregationDirty(opts, {
-            dimension: weights
-        });
-        if (aggregationWeightsDirty) {
-            this._updateAccessors(opts);
-        }
-        if (aggregationDataDirty || aggregationWeightsDirty) {
-            this._resetResults();
-        }
-        this.setState({
-            aggregationDataDirty,
-            aggregationWeightsDirty
-        });
-    }
-    /* eslint-enable max-statements, complexity */
-    // Private (Aggregation)
-    _updateAccessors(opts) {
-        const { getWeight, aggregation, data } = opts.props;
-        const { count } = this.state.weights;
-        if (count) {
-            count.getWeight = getWeight;
-            count.operation = AGGREGATION_OPERATION[aggregation];
-        }
-        this.setState({ getValue: getValueFunc(aggregation, getWeight, { data }) });
-    }
-    _resetResults() {
-        const { count } = this.state.weights;
-        if (count) {
-            count.aggregationData = null;
-        }
-    }
-    // Private (Contours)
-    _generateContours() {
-        const { numCol, numRow, gridOrigin, gridOffset, thresholdData } = this.state;
-        const { count } = this.state.weights;
-        let { aggregationData } = count;
-        if (!aggregationData) {
-            aggregationData = count.aggregationBuffer.getData();
-            count.aggregationData = aggregationData;
-        }
-        const { cellWeights } = GPUGridAggregator.getCellData({ countsData: aggregationData });
-        const contourData = generateContours({
-            thresholdData,
-            cellWeights,
-            gridSize: [numCol, numRow],
-            gridOrigin,
-            cellSize: [gridOffset.xOffset, gridOffset.yOffset]
-        });
-        // contourData contains both iso-lines and iso-bands if requested.
-        this.setState({ contourData });
-    }
-    _updateThresholdData(props) {
-        const { contours, zOffset } = props;
-        const count = contours.length;
-        const thresholdData = new Array(count);
-        for (let i = 0; i < count; i++) {
-            const contour = contours[i];
-            thresholdData[i] = {
-                contour,
-                zIndex: contour.zIndex || i,
-                zOffset
-            };
-        }
-        this.setState({ thresholdData });
-    }
-}
-ContourLayer.layerName = 'ContourLayer';
-ContourLayer.defaultProps = defaultProps;

package/typed/contour-layer/contour-utils.js

@@ -1,64 +0,0 @@
-import { getCode, getVertices, CONTOUR_TYPE } from './marching-squares';
-// Given all the cell weights, generates contours for each threshold.
-/* eslint-disable max-depth */
-export function generateContours({ thresholdData, cellWeights, gridSize, gridOrigin, cellSize }) {
-    const contourSegments = [];
-    const contourPolygons = [];
-    const width = gridSize[0];
-    const height = gridSize[1];
-    let segmentIndex = 0;
-    let polygonIndex = 0;
-    for (const data of thresholdData) {
-        const { contour } = data;
-        const { threshold } = contour;
-        for (let x = -1; x < width; x++) {
-            for (let y = -1; y < height; y++) {
-                // Get the MarchingSquares code based on neighbor cell weights.
-                const { code, meanCode } = getCode({
-                    cellWeights,
-                    threshold,
-                    x,
-                    y,
-                    width,
-                    height
-                });
-                const opts = {
-                    type: CONTOUR_TYPE.ISO_BANDS,
-                    gridOrigin,
-                    cellSize,
-                    x,
-                    y,
-                    width,
-                    height,
-                    code,
-                    meanCode,
-                    thresholdData: data
-                };
-                if (Array.isArray(threshold)) {
-                    opts.type = CONTOUR_TYPE.ISO_BANDS;
-                    const polygons = getVertices(opts);
-                    for (const polygon of polygons) {
-                        contourPolygons[polygonIndex++] = {
-                            vertices: polygon,
-                            contour
-                        };
-                    }
-                }
-                else {
-                    // Get the intersection vertices based on MarchingSquares code.
-                    opts.type = CONTOUR_TYPE.ISO_LINES;
-                    const vertices = getVertices(opts);
-                    for (let i = 0; i < vertices.length; i += 2) {
-                        contourSegments[segmentIndex++] = {
-                            start: vertices[i],
-                            end: vertices[i + 1],
-                            contour
-                        };
-                    }
-                }
-            }
-        }
-    }
-    return { contourSegments, contourPolygons };
-}
-/* eslint-enable max-depth */

package/typed/contour-layer/marching-squares-codes.js

@@ -1,337 +0,0 @@
-// Code to Offsets Map needed to implement Marching Squares algorithm
-// Ref: https://en.wikipedia.org/wiki/Marching_squares
-// Table to map code to the intersection offsets
-// All offsets are relative to the center of marching cell (which is top right corner of grid-cell, and center of marching-square)
-const HALF = 0.5;
-const ONE6TH = 1 / 6;
-const OFFSET = {
-    N: [0, HALF],
-    E: [HALF, 0],
-    S: [0, -HALF],
-    W: [-HALF, 0],
-    // CORNERS
-    NE: [HALF, HALF],
-    NW: [-HALF, HALF],
-    SE: [HALF, -HALF],
-    SW: [-HALF, -HALF]
-};
-// NOTE: vertices are ordered in CCW direction, starting from NW corner
-// Triangles
-const SW_TRIANGLE = [OFFSET.W, OFFSET.SW, OFFSET.S];
-const SE_TRIANGLE = [OFFSET.S, OFFSET.SE, OFFSET.E];
-const NE_TRIANGLE = [OFFSET.E, OFFSET.NE, OFFSET.N];
-const NW_TRIANGLE = [OFFSET.NW, OFFSET.W, OFFSET.N];
-// Trapezoids
-const SW_TRAPEZOID = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF]
-];
-const SE_TRAPEZOID = [
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF],
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH]
-];
-const NE_TRAPEZOID = [
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH],
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-const NW_TRAPEZOID = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-// Rectangles
-const S_RECTANGLE = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.E];
-const E_RECTANGLE = [OFFSET.S, OFFSET.SE, OFFSET.NE, OFFSET.N];
-const N_RECTANGLE = [OFFSET.NW, OFFSET.W, OFFSET.E, OFFSET.NE];
-const W_RECTANGLE = [OFFSET.NW, OFFSET.SW, OFFSET.S, OFFSET.N];
-const EW_RECTANGEL = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH]
-];
-const SN_RECTANGEL = [
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF],
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-// Square
-const SQUARE = [OFFSET.NW, OFFSET.SW, OFFSET.SE, OFFSET.NE];
-// Pentagons
-const SW_PENTAGON = [OFFSET.NW, OFFSET.SW, OFFSET.SE, OFFSET.E, OFFSET.N];
-const SE_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.NE, OFFSET.N];
-const NE_PENTAGON = [OFFSET.NW, OFFSET.W, OFFSET.S, OFFSET.SE, OFFSET.NE];
-const NW_PENTAGON = [OFFSET.NW, OFFSET.SW, OFFSET.S, OFFSET.E, OFFSET.NE];
-const NW_N_PENTAGON = [OFFSET.NW, OFFSET.W, [HALF, -ONE6TH], [HALF, ONE6TH], OFFSET.N];
-const NE_E_PENTAGON = [[-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.E, OFFSET.NE, OFFSET.N];
-const SE_S_PENTAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.S, OFFSET.SE, OFFSET.E];
-const SW_W_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, [ONE6TH, HALF], [-ONE6TH, HALF]];
-const NW_W_PENTAGON = [OFFSET.NW, OFFSET.W, [-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.N];
-const NE_N_PENTAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.E, OFFSET.NE, OFFSET.N];
-const SE_E_PENTAGON = [OFFSET.S, OFFSET.SE, OFFSET.E, [ONE6TH, HALF], [-ONE6TH, HALF]];
-const SW_S_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, [HALF, -ONE6TH], [HALF, ONE6TH]];
-// Hexagon
-const S_HEXAGON = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.E, [ONE6TH, HALF], [-ONE6TH, HALF]];
-const E_HEXAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.S, OFFSET.SE, OFFSET.NE, OFFSET.N];
-const N_HEXAGON = [OFFSET.NW, OFFSET.W, [-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.E, OFFSET.NE];
-const W_HEXAGON = [OFFSET.NW, OFFSET.SW, OFFSET.S, [HALF, -ONE6TH], [HALF, ONE6TH], OFFSET.N];
-const SW_NE_HEXAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, OFFSET.E, OFFSET.NE, OFFSET.N];
-const NW_SE_HEXAGON = [OFFSET.NW, OFFSET.W, OFFSET.S, OFFSET.SE, OFFSET.E, OFFSET.N];
-// Heptagon (7-sided)
-const NE_HEPTAGON = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF],
-    OFFSET.E,
-    OFFSET.NE,
-    OFFSET.N
-];
-const SW_HEPTAGON = [
-    OFFSET.W,
-    OFFSET.SW,
-    OFFSET.S,
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH],
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-const NW_HEPTAGON = [
-    OFFSET.NW,
-    OFFSET.W,
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF],
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH],
-    OFFSET.N
-];
-const SE_HEPTAGON = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    OFFSET.S,
-    OFFSET.SE,
-    OFFSET.E,
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-// Octagon
-const OCTAGON = [
-    [-HALF, ONE6TH],
-    [-HALF, -ONE6TH],
-    [-ONE6TH, -HALF],
-    [ONE6TH, -HALF],
-    [HALF, -ONE6TH],
-    [HALF, ONE6TH],
-    [ONE6TH, HALF],
-    [-ONE6TH, HALF]
-];
-// Note: above wiki page invertes white/black dots for generating the code, we don't
-export const ISOLINES_CODE_OFFSET_MAP = {
-    // key is equal to the code of 4 vertices (invert the code specified in wiki)
-    // value can be an array or an Object
-    // Array : [line] or [line, line], where each line is [start-point, end-point], and each point is [x, y]
-    // Object : to handle saddle cases, whos output depends on mean value of all 4 corners
-    //  key: code of mean value (0 or 1)
-    //  value: Array , as above defines one or two line segments
-    0: [],
-    1: [[OFFSET.W, OFFSET.S]],
-    2: [[OFFSET.S, OFFSET.E]],
-    3: [[OFFSET.W, OFFSET.E]],
-    4: [[OFFSET.N, OFFSET.E]],
-    5: {
-        0: [
-            [OFFSET.W, OFFSET.S],
-            [OFFSET.N, OFFSET.E]
-        ],
-        1: [
-            [OFFSET.W, OFFSET.N],
-            [OFFSET.S, OFFSET.E]
-        ]
-    },
-    6: [[OFFSET.N, OFFSET.S]],
-    7: [[OFFSET.W, OFFSET.N]],
-    8: [[OFFSET.W, OFFSET.N]],
-    9: [[OFFSET.N, OFFSET.S]],
-    10: {
-        0: [
-            [OFFSET.W, OFFSET.N],
-            [OFFSET.S, OFFSET.E]
-        ],
-        1: [
-            [OFFSET.W, OFFSET.S],
-            [OFFSET.N, OFFSET.E]
-        ]
-    },
-    11: [[OFFSET.N, OFFSET.E]],
-    12: [[OFFSET.W, OFFSET.E]],
-    13: [[OFFSET.S, OFFSET.E]],
-    14: [[OFFSET.W, OFFSET.S]],
-    15: []
-};
-function ternaryToIndex(ternary) {
-    return parseInt(ternary, 4);
-}
-export const ISOBANDS_CODE_OFFSET_MAP = {
-    // Below list of cases, follow the same order as in above mentioned wiki page.
-    // Each case has its code on first commented line // T,TR,R,C
-    // where T: Top, TR: Top-right, R: Right and C: current, each will be either 0, 1 or 2
-    // final code is binary representation of above code , where takes 2 digits
-    // for example:  code 2-2-2-1 => 10-10-10-01 => 10101001 => 169
-    // no contours
-    [ternaryToIndex('0000')]: [],
-    [ternaryToIndex('2222')]: [],
-    // single triangle
-    [ternaryToIndex('2221')]: [SW_TRIANGLE],
-    [ternaryToIndex('2212')]: [SE_TRIANGLE],
-    [ternaryToIndex('2122')]: [NE_TRIANGLE],
-    [ternaryToIndex('1222')]: [NW_TRIANGLE],
-    [ternaryToIndex('0001')]: [SW_TRIANGLE],
-    [ternaryToIndex('0010')]: [SE_TRIANGLE],
-    [ternaryToIndex('0100')]: [NE_TRIANGLE],
-    [ternaryToIndex('1000')]: [NW_TRIANGLE],
-    // single trapezoid
-    [ternaryToIndex('2220')]: [SW_TRAPEZOID],
-    [ternaryToIndex('2202')]: [SE_TRAPEZOID],
-    [ternaryToIndex('2022')]: [NE_TRAPEZOID],
-    [ternaryToIndex('0222')]: [NW_TRAPEZOID],
-    [ternaryToIndex('0002')]: [SW_TRAPEZOID],
-    [ternaryToIndex('0020')]: [SE_TRAPEZOID],
-    [ternaryToIndex('0200')]: [NE_TRAPEZOID],
-    [ternaryToIndex('2000')]: [NW_TRAPEZOID],
-    // single rectangle
-    [ternaryToIndex('0011')]: [S_RECTANGLE],
-    [ternaryToIndex('0110')]: [E_RECTANGLE],
-    [ternaryToIndex('1100')]: [N_RECTANGLE],
-    [ternaryToIndex('1001')]: [W_RECTANGLE],
-    [ternaryToIndex('2211')]: [S_RECTANGLE],
-    [ternaryToIndex('2112')]: [E_RECTANGLE],
-    [ternaryToIndex('1122')]: [N_RECTANGLE],
-    [ternaryToIndex('1221')]: [W_RECTANGLE],
-    [ternaryToIndex('2200')]: [EW_RECTANGEL],
-    [ternaryToIndex('2002')]: [SN_RECTANGEL],
-    [ternaryToIndex('0022')]: [EW_RECTANGEL],
-    [ternaryToIndex('0220')]: [SN_RECTANGEL],
-    // single square
-    // 1111
-    [ternaryToIndex('1111')]: [SQUARE],
-    // single pentagon
-    [ternaryToIndex('1211')]: [SW_PENTAGON],
-    [ternaryToIndex('2111')]: [SE_PENTAGON],
-    [ternaryToIndex('1112')]: [NE_PENTAGON],
-    [ternaryToIndex('1121')]: [NW_PENTAGON],
-    [ternaryToIndex('1011')]: [SW_PENTAGON],
-    [ternaryToIndex('0111')]: [SE_PENTAGON],
-    [ternaryToIndex('1110')]: [NE_PENTAGON],
-    [ternaryToIndex('1101')]: [NW_PENTAGON],
-    [ternaryToIndex('1200')]: [NW_N_PENTAGON],
-    [ternaryToIndex('0120')]: [NE_E_PENTAGON],
-    [ternaryToIndex('0012')]: [SE_S_PENTAGON],
-    [ternaryToIndex('2001')]: [SW_W_PENTAGON],
-    [ternaryToIndex('1022')]: [NW_N_PENTAGON],
-    [ternaryToIndex('2102')]: [NE_E_PENTAGON],
-    [ternaryToIndex('2210')]: [SE_S_PENTAGON],
-    [ternaryToIndex('0221')]: [SW_W_PENTAGON],
-    [ternaryToIndex('1002')]: [NW_W_PENTAGON],
-    [ternaryToIndex('2100')]: [NE_N_PENTAGON],
-    [ternaryToIndex('0210')]: [SE_E_PENTAGON],
-    [ternaryToIndex('0021')]: [SW_S_PENTAGON],
-    [ternaryToIndex('1220')]: [NW_W_PENTAGON],
-    [ternaryToIndex('0122')]: [NE_N_PENTAGON],
-    [ternaryToIndex('2012')]: [SE_E_PENTAGON],
-    [ternaryToIndex('2201')]: [SW_S_PENTAGON],
-    // single hexagon
-    [ternaryToIndex('0211')]: [S_HEXAGON],
-    [ternaryToIndex('2110')]: [E_HEXAGON],
-    [ternaryToIndex('1102')]: [N_HEXAGON],
-    [ternaryToIndex('1021')]: [W_HEXAGON],
-    [ternaryToIndex('2011')]: [S_HEXAGON],
-    [ternaryToIndex('0112')]: [E_HEXAGON],
-    [ternaryToIndex('1120')]: [N_HEXAGON],
-    [ternaryToIndex('1201')]: [W_HEXAGON],
-    [ternaryToIndex('2101')]: [SW_NE_HEXAGON],
-    [ternaryToIndex('0121')]: [SW_NE_HEXAGON],
-    [ternaryToIndex('1012')]: [NW_SE_HEXAGON],
-    [ternaryToIndex('1210')]: [NW_SE_HEXAGON],
-    // 6-sided polygons based on mean weight
-    // NOTE: merges mean value codes for extreme changes (as per above Wiki doc)
-    [ternaryToIndex('0101')]: {
-        0: [SW_TRIANGLE, NE_TRIANGLE],
-        1: [SW_NE_HEXAGON],
-        2: [SW_NE_HEXAGON]
-    },
-    [ternaryToIndex('1010')]: {
-        0: [NW_TRIANGLE, SE_TRIANGLE],
-        1: [NW_SE_HEXAGON],
-        2: [NW_SE_HEXAGON]
-    },
-    [ternaryToIndex('2121')]: {
-        0: [SW_NE_HEXAGON],
-        1: [SW_NE_HEXAGON],
-        2: [SW_TRIANGLE, NE_TRIANGLE]
-    },
-    [ternaryToIndex('1212')]: {
-        0: [NW_SE_HEXAGON],
-        1: [NW_SE_HEXAGON],
-        2: [NW_TRIANGLE, SE_TRIANGLE]
-    },
-    // 7-sided polygons based on mean weight
-    [ternaryToIndex('2120')]: {
-        0: [NE_HEPTAGON],
-        1: [NE_HEPTAGON],
-        2: [SW_TRAPEZOID, NE_TRIANGLE]
-    },
-    [ternaryToIndex('2021')]: {
-        0: [SW_HEPTAGON],
-        1: [SW_HEPTAGON],
-        2: [SW_TRIANGLE, NE_TRAPEZOID]
-    },
-    [ternaryToIndex('1202')]: {
-        0: [NW_HEPTAGON],
-        1: [NW_HEPTAGON],
-        2: [NW_TRIANGLE, SE_TRAPEZOID]
-    },
-    [ternaryToIndex('0212')]: {
-        0: [SE_HEPTAGON],
-        1: [SE_HEPTAGON],
-        2: [SE_TRIANGLE, NW_TRAPEZOID]
-    },
-    [ternaryToIndex('0102')]: {
-        0: [SW_TRAPEZOID, NE_TRIANGLE],
-        1: [NE_HEPTAGON],
-        2: [NE_HEPTAGON]
-    },
-    [ternaryToIndex('0201')]: {
-        0: [SW_TRIANGLE, NE_TRAPEZOID],
-        1: [SW_HEPTAGON],
-        2: [SW_HEPTAGON]
-    },
-    [ternaryToIndex('1020')]: {
-        0: [NW_TRIANGLE, SE_TRAPEZOID],
-        1: [NW_HEPTAGON],
-        2: [NW_HEPTAGON]
-    },
-    [ternaryToIndex('2010')]: {
-        0: [SE_TRIANGLE, NW_TRAPEZOID],
-        1: [SE_HEPTAGON],
-        2: [SE_HEPTAGON]
-    },
-    // 8-sided polygons based on mean weight
-    [ternaryToIndex('2020')]: {
-        0: [NW_TRAPEZOID, SE_TRAPEZOID],
-        1: [OCTAGON],
-        2: [SW_TRAPEZOID, NE_TRAPEZOID]
-    },
-    [ternaryToIndex('0202')]: {
-        0: [NE_TRAPEZOID, SW_TRAPEZOID],
-        1: [OCTAGON],
-        2: [NW_TRAPEZOID, SE_TRAPEZOID]
-    }
-};