choropleth-layer.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _layer = require('../../layer');

var _layer2 = _interopRequireDefault(_layer);

var _earcut = require('earcut');

var _earcut2 = _interopRequireDefault(_earcut);

var _lodash = require('lodash.flattendeep');

var _lodash2 = _interopRequireDefault(_lodash);

var _geojsonNormalize = require('geojson-normalize');

var _geojsonNormalize2 = _interopRequireDefault(_geojsonNormalize);

var _luma = require('luma.gl');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) 2015 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.

var glslify = require('glslify');

var ATTRIBUTES = {
  vertices: { size: 3, '0': 'x', '1': 'y', '2': 'unused' },
  instances: { size: 3, '0': 'x', '1': 'y', '2': 'unused' },
  colors: { size: 3, '0': 'red', '1': 'green', '2': 'blue' }
  // Override picking colors to prevent auto allocation
  // pickingColors: {size: 3, '0': 'pickRed', '1': 'pickGreen', '2': 'pickBlue'}
};

var ChoroplethLayer = function (_Layer) {
  _inherits(ChoroplethLayer, _Layer);

  /**
   * @classdesc
   * ChoroplethLayer
   *
   * @class
   * @param {object} opts
   * @param {bool} opts.drawContour - ? drawContour : drawArea
   * @param {function} opts.onChoroplethHovered - provide proerties of the
   * selected choropleth, together with the mouse event when mouse hovered
   * @param {function} opts.onChoroplethClicked - provide proerties of the
   * selected choropleth, together with the mouse event when mouse clicked
   */

  function ChoroplethLayer(opts) {
    _classCallCheck(this, ChoroplethLayer);

    return _possibleConstructorReturn(this, Object.getPrototypeOf(ChoroplethLayer).call(this, _extends({}, opts)));
  }

  _createClass(ChoroplethLayer, [{
    key: 'initializeState',
    value: function initializeState() {
      var _state = this.state;
      var gl = _state.gl;
      var attributeManager = _state.attributeManager;


      attributeManager.addInstanced(ATTRIBUTES, {
        // Primtive attributes
        indices: { update: this.calculateIndices },
        vertices: { update: this.calculateVertices },
        colors: { update: this.calculateColors },
        // Instanced attributes
        pickingColors: { update: this.calculatePickingColors, noAlloc: true }
      });

      this.setState({
        numInstances: 0,
        model: this.getModel(gl)
      });

      this.extractChoropleths();
    }
  }, {
    key: 'willReceiveProps',
    value: function willReceiveProps(oldProps, newProps) {
      _get(Object.getPrototypeOf(ChoroplethLayer.prototype), 'willReceiveProps', this).call(this, oldProps, newProps);

      var _state2 = this.state;
      var dataChanged = _state2.dataChanged;
      var attributeManager = _state2.attributeManager;

      if (dataChanged) {
        this.extractChoropleths();
        attributeManager.invalidateAll();
      }
    }
  }, {
    key: 'getModel',
    value: function getModel(gl) {
      return new _luma.Model({
        program: new _luma.Program(gl, {
          vs: glslify('./choropleth-layer-vertex.glsl'),
          fs: glslify('./choropleth-layer-fragment.glsl'),
          id: 'choropleth'
        }),
        geometry: new _luma.Geometry({
          id: this.props.id,
          drawMode: this.props.drawContour ? 'LINES' : 'TRIANGLES'
        })
      });
    }
  }, {
    key: 'calculateVertices',
    value: function calculateVertices(attribute) {
      var vertices = (0, _lodash2.default)(this.state.groupedVertices);
      attribute.value = new Float32Array(vertices);
    }
  }, {
    key: 'calculateIndices',
    value: function calculateIndices(attribute) {
      var _this2 = this;

      // adjust index offset for multiple choropleths
      var offsets = this.state.groupedVertices.reduce(function (acc, vertices) {
        return [].concat(_toConsumableArray(acc), [acc[acc.length - 1] + vertices.length]);
      }, [0]);

      var indices = this.state.groupedVertices.map(function (vertices, choroplethIndex) {
        return _this2.drawContour ?
        // 1. get sequentially ordered indices of each choropleth contour
        // 2. offset them by the number of indices in previous choropleths
        _this2.calculateContourIndices(vertices.length).map(function (index) {
          return index + offsets[choroplethIndex];
        }) :
        // 1. get triangulated indices for the internal areas
        // 2. offset them by the number of indices in previous choropleths
        (0, _earcut2.default)((0, _lodash2.default)(vertices), null, 3).map(function (index) {
          return index + offsets[choroplethIndex];
        });
      });

      attribute.value = new Uint16Array((0, _lodash2.default)(indices));
    }
  }, {
    key: 'calculateColors',
    value: function calculateColors(attribute) {
      var _this3 = this;

      var colors = this.state.groupedVertices.map(function (vertices) {
        return vertices.map(function (vertex) {
          return _this3.drawContour ? [0, 0, 0] : [128, 128, 128];
        });
      });

      attribute.value = new Float32Array((0, _lodash2.default)(colors));
    }

    // Override the default picking colors calculation

  }, {
    key: 'calculatePickingColors',
    value: function calculatePickingColors(attribute) {
      // const {attributeManager} = this.state;
      // const {vertices: value} = attributeManager
      // const pickingColors = this.state.groupedVer.map(
      //   (vertices, choroplethIndex) => vertices.map(
      //     vertex => this.drawContour ? [-1, -1, -1] : [
      //       (choroplethIndex + 1) % 256,
      //       Math.floor((choroplethIndex + 1) / 256) % 256,
      //       this.layerIndex
      //     ]
      //   )
      // );

      // attribute.value = new Float32Array(flattenDeep(pickingColors));
    }
  }, {
    key: 'extractChoropleths',
    value: function extractChoropleths() {
      var data = this.props.data;

      var normalizedGeojson = (0, _geojsonNormalize2.default)(data);

      this.state.choropleths = normalizedGeojson.features.map(function (choropleth) {
        var coordinates = choropleth.geometry.coordinates[0];
        // flatten nested polygons
        if (coordinates.length === 1 && coordinates[0].length > 2) {
          coordinates = coordinates[0];
        }
        return {
          properties: choropleth.properties,
          coordinates: coordinates
        };
      });

      this.state.groupedVertices = this.state.choropleths.map(function (choropleth) {
        return choropleth.coordinates.map(function (coordinate) {
          return [coordinate[0], coordinate[1], 100];
        });
      });
    }
  }, {
    key: 'calculateContourIndices',
    value: function calculateContourIndices(numVertices) {
      // use vertex pairs for gl.LINES => [0, 1, 1, 2, 2, ..., n-1, n-1, 0]
      var indices = [];
      for (var i = 1; i < numVertices - 1; i++) {
        indices = [].concat(_toConsumableArray(indices), [i, i]);
      }
      return [0].concat(_toConsumableArray(indices), [0]);
    }
  }, {
    key: 'onHover',
    value: function onHover(info) {
      var index = info.index;
      var data = this.props.data;

      var feature = data.features[index];
      this.props.onHover(_extends({}, info, { feature: feature }));
    }
  }, {
    key: 'onClick',
    value: function onClick(info) {
      var index = info.index;
      var data = this.props.data;

      var feature = data.features[index];
      this.props.onClick(_extends({}, info, { feature: feature }));
    }
  }]);

  return ChoroplethLayer;
}(_layer2.default);

exports.default = ChoroplethLayer;
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/layers/choropleth-layer/choropleth-layer.js"],"names":[],"mappings":";;;;;;;;;;;;;AAoBA;;;;AACA;;;;AACA;;;;AACA;;;;AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,IAAM,UAAU,QAAQ,SAAR,CAAV;;AAEN,IAAM,aAAa;AACjB,YAAU,EAAC,MAAM,CAAN,EAAS,KAAK,GAAL,EAAU,KAAK,GAAL,EAAU,KAAK,QAAL,EAAxC;AACA,aAAW,EAAC,MAAM,CAAN,EAAS,KAAK,GAAL,EAAU,KAAK,GAAL,EAAU,KAAK,QAAL,EAAzC;AACA,UAAQ,EAAC,MAAM,CAAN,EAAS,KAAK,KAAL,EAAY,KAAK,OAAL,EAAc,KAAK,MAAL,EAA5C;;;AAHiB,CAAb;;IAQe;;;;;;;;;;;;;;;;AAanB,WAbmB,eAanB,CAAY,IAAZ,EAAkB;0BAbC,iBAaD;;kEAbC,yCAeZ,QAFW;GAAlB;;eAbmB;;sCAmBD;mBACe,KAAK,KAAL,CADf;UACT,eADS;UACL,2CADK;;;AAGhB,uBAAiB,YAAjB,CAA8B,UAA9B,EAA0C;;AAExC,iBAAS,EAAC,QAAQ,KAAK,gBAAL,EAAlB;AACA,kBAAU,EAAC,QAAQ,KAAK,iBAAL,EAAnB;AACA,gBAAQ,EAAC,QAAQ,KAAK,eAAL,EAAjB;;AAEA,uBAAe,EAAC,QAAQ,KAAK,sBAAL,EAA6B,SAAS,IAAT,EAArD;OANF,EAHgB;;AAYhB,WAAK,QAAL,CAAc;AACZ,sBAAc,CAAd;AACA,eAAO,KAAK,QAAL,CAAc,EAAd,CAAP;OAFF,EAZgB;;AAiBhB,WAAK,kBAAL,GAjBgB;;;;qCAoBD,UAAU,UAAU;AACnC,iCAxCiB,iEAwCM,UAAU,SAAjC,CADmC;;oBAGK,KAAK,KAAL,CAHL;UAG5B,kCAH4B;UAGf,4CAHe;;AAInC,UAAI,WAAJ,EAAiB;AACf,aAAK,kBAAL,GADe;AAEf,yBAAiB,aAAjB,GAFe;OAAjB;;;;6BAMO,IAAI;AACX,aAAO,gBAAU;AACf,iBAAS,kBAAY,EAAZ,EAAgB;AACvB,cAAI,QAAQ,gCAAR,CAAJ;AACA,cAAI,QAAQ,kCAAR,CAAJ;AACA,cAAI,YAAJ;SAHO,CAAT;AAKA,kBAAU,mBAAa;AACrB,cAAI,KAAK,KAAL,CAAW,EAAX;AACJ,oBAAU,KAAK,KAAL,CAAW,WAAX,GAAyB,OAAzB,GAAmC,WAAnC;SAFF,CAAV;OANK,CAAP,CADW;;;;sCAcK,WAAW;AAC3B,UAAM,WAAW,sBAAY,KAAK,KAAL,CAAW,eAAX,CAAvB,CADqB;AAE3B,gBAAU,KAAV,GAAkB,IAAI,YAAJ,CAAiB,QAAjB,CAAlB,CAF2B;;;;qCAKZ,WAAW;;;;AAE1B,UAAM,UAAU,KAAK,KAAL,CAAW,eAAX,CAA2B,MAA3B,CACd,UAAC,GAAD,EAAM,QAAN;4CAAuB,OAAK,IAAI,IAAI,MAAJ,GAAa,CAAb,CAAJ,GAAsB,SAAS,MAAT;OAAlD,EACA,CAAC,CAAD,CAFc,CAAV,CAFoB;;AAO1B,UAAM,UAAU,KAAK,KAAL,CAAW,eAAX,CAA2B,GAA3B,CACd,UAAC,QAAD,EAAW,eAAX;eAA+B,OAAK,WAAL;;;AAG7B,eAAK,uBAAL,CAA6B,SAAS,MAAT,CAA7B,CAA8C,GAA9C,CACE;iBAAS,QAAQ,QAAQ,eAAR,CAAR;SAAT,CAJ2B;;;AAQ7B,8BAAO,sBAAY,QAAZ,CAAP,EAA8B,IAA9B,EAAoC,CAApC,EAAuC,GAAvC,CACE;iBAAS,QAAQ,QAAQ,eAAR,CAAR;SAAT,CAT2B;OAA/B,CADI,CAPoB;;AAqB1B,gBAAU,KAAV,GAAkB,IAAI,WAAJ,CAAgB,sBAAY,OAAZ,CAAhB,CAAlB,CArB0B;;;;oCAwBZ,WAAW;;;AACzB,UAAM,SAAS,KAAK,KAAL,CAAW,eAAX,CAA2B,GAA3B,CACb;eAAY,SAAS,GAAT,CACV;iBAAU,OAAK,WAAL,GAAmB,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,CAAnB,GAA+B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAA/B;SAAV;OADF,CADI,CADmB;;AAOzB,gBAAU,KAAV,GAAkB,IAAI,YAAJ,CAAiB,sBAAY,MAAZ,CAAjB,CAAlB,CAPyB;;;;;;;2CAWJ,WAAW;;;;;;;;;;;;;;;;;yCAgBb;UACZ,OAAQ,KAAK,KAAL,CAAR,KADY;;AAEnB,UAAM,oBAAoB,gCAAU,IAAV,CAApB,CAFa;;AAInB,WAAK,KAAL,CAAW,WAAX,GAAyB,kBAAkB,QAAlB,CAA2B,GAA3B,CAA+B,sBAAc;AACpE,YAAI,cAAc,WAAW,QAAX,CAAoB,WAApB,CAAgC,CAAhC,CAAd;;AADgE,YAGhE,YAAY,MAAZ,KAAuB,CAAvB,IAA4B,YAAY,CAAZ,EAAe,MAAf,GAAwB,CAAxB,EAA2B;AACzD,wBAAc,YAAY,CAAZ,CAAd,CADyD;SAA3D;AAGA,eAAO;AACL,sBAAY,WAAW,UAAX;AACZ,kCAFK;SAAP,CANoE;OAAd,CAAxD,CAJmB;;AAgBnB,WAAK,KAAL,CAAW,eAAX,GAA6B,KAAK,KAAL,CAAW,WAAX,CAAuB,GAAvB,CAC3B;eAAc,WAAW,WAAX,CAAuB,GAAvB,CACZ;iBAAc,CAAC,WAAW,CAAX,CAAD,EAAgB,WAAW,CAAX,CAAhB,EAA+B,GAA/B;SAAd;OADF,CADF,CAhBmB;;;;4CAuBG,aAAa;;AAEnC,UAAI,UAAU,EAAV,CAF+B;AAGnC,WAAK,IAAI,IAAI,CAAJ,EAAO,IAAI,cAAc,CAAd,EAAiB,GAArC,EAA0C;AACxC,+CAAc,WAAS,GAAG,GAA1B,CADwC;OAA1C;AAGA,cAAQ,6BAAM,WAAS,GAAvB,CANmC;;;;4BAS7B,MAAM;UACL,QAAS,KAAT,MADK;UAEL,OAAQ,KAAK,KAAL,CAAR,KAFK;;AAGZ,UAAM,UAAU,KAAK,QAAL,CAAc,KAAd,CAAV,CAHM;AAIZ,WAAK,KAAL,CAAW,OAAX,cAAuB,QAAM,mBAA7B,EAJY;;;;4BAON,MAAM;UACL,QAAS,KAAT,MADK;UAEL,OAAQ,KAAK,KAAL,CAAR,KAFK;;AAGZ,UAAM,UAAU,KAAK,QAAL,CAAc,KAAd,CAAV,CAHM;AAIZ,WAAK,KAAL,CAAW,OAAX,cAAuB,QAAM,mBAA7B,EAJY;;;;SA9JK","file":"choropleth-layer.js","sourcesContent":["// Copyright (c) 2015 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport Layer from '../../layer';\nimport earcut from 'earcut';\nimport flattenDeep from 'lodash.flattendeep';\nimport normalize from 'geojson-normalize';\nimport {Model, Program, Geometry} from 'luma.gl';\nconst glslify = require('glslify');\n\nconst ATTRIBUTES = {\n  vertices: {size: 3, '0': 'x', '1': 'y', '2': 'unused'},\n  instances: {size: 3, '0': 'x', '1': 'y', '2': 'unused'},\n  colors: {size: 3, '0': 'red', '1': 'green', '2': 'blue'}\n  // Override picking colors to prevent auto allocation\n  // pickingColors: {size: 3, '0': 'pickRed', '1': 'pickGreen', '2': 'pickBlue'}\n};\n\nexport default class ChoroplethLayer extends Layer {\n  /**\n   * @classdesc\n   * ChoroplethLayer\n   *\n   * @class\n   * @param {object} opts\n   * @param {bool} opts.drawContour - ? drawContour : drawArea\n   * @param {function} opts.onChoroplethHovered - provide proerties of the\n   * selected choropleth, together with the mouse event when mouse hovered\n   * @param {function} opts.onChoroplethClicked - provide proerties of the\n   * selected choropleth, together with the mouse event when mouse clicked\n   */\n  constructor(opts) {\n    super({\n      ...opts\n    });\n  }\n\n  initializeState() {\n    const {gl, attributeManager} = this.state;\n\n    attributeManager.addInstanced(ATTRIBUTES, {\n      // Primtive attributes\n      indices: {update: this.calculateIndices},\n      vertices: {update: this.calculateVertices},\n      colors: {update: this.calculateColors},\n      // Instanced attributes\n      pickingColors: {update: this.calculatePickingColors, noAlloc: true}\n    });\n\n    this.setState({\n      numInstances: 0,\n      model: this.getModel(gl)\n    });\n\n    this.extractChoropleths();\n  }\n\n  willReceiveProps(oldProps, newProps) {\n    super.willReceiveProps(oldProps, newProps);\n\n    const {dataChanged, attributeManager} = this.state;\n    if (dataChanged) {\n      this.extractChoropleths();\n      attributeManager.invalidateAll();\n    }\n  }\n\n  getModel(gl) {\n    return new Model({\n      program: new Program(gl, {\n        vs: glslify('./choropleth-layer-vertex.glsl'),\n        fs: glslify('./choropleth-layer-fragment.glsl'),\n        id: 'choropleth'\n      }),\n      geometry: new Geometry({\n        id: this.props.id,\n        drawMode: this.props.drawContour ? 'LINES' : 'TRIANGLES'\n      })\n    });\n  }\n\n  calculateVertices(attribute) {\n    const vertices = flattenDeep(this.state.groupedVertices);\n    attribute.value = new Float32Array(vertices);\n  }\n\n  calculateIndices(attribute) {\n    // adjust index offset for multiple choropleths\n    const offsets = this.state.groupedVertices.reduce(\n      (acc, vertices) => [...acc, acc[acc.length - 1] + vertices.length],\n      [0]\n    );\n\n    const indices = this.state.groupedVertices.map(\n      (vertices, choroplethIndex) => this.drawContour ?\n        // 1. get sequentially ordered indices of each choropleth contour\n        // 2. offset them by the number of indices in previous choropleths\n        this.calculateContourIndices(vertices.length).map(\n          index => index + offsets[choroplethIndex]\n        ) :\n        // 1. get triangulated indices for the internal areas\n        // 2. offset them by the number of indices in previous choropleths\n        earcut(flattenDeep(vertices), null, 3).map(\n          index => index + offsets[choroplethIndex]\n        )\n    );\n\n    attribute.value = new Uint16Array(flattenDeep(indices));\n  }\n\n  calculateColors(attribute) {\n    const colors = this.state.groupedVertices.map(\n      vertices => vertices.map(\n        vertex => this.drawContour ? [0, 0, 0] : [128, 128, 128]\n      )\n    );\n\n    attribute.value = new Float32Array(flattenDeep(colors));\n  }\n\n  // Override the default picking colors calculation\n  calculatePickingColors(attribute) {\n    // const {attributeManager} = this.state;\n    // const {vertices: value} = attributeManager\n    // const pickingColors = this.state.groupedVer.map(\n    //   (vertices, choroplethIndex) => vertices.map(\n    //     vertex => this.drawContour ? [-1, -1, -1] : [\n    //       (choroplethIndex + 1) % 256,\n    //       Math.floor((choroplethIndex + 1) / 256) % 256,\n    //       this.layerIndex\n    //     ]\n    //   )\n    // );\n\n    // attribute.value = new Float32Array(flattenDeep(pickingColors));\n  }\n\n  extractChoropleths() {\n    const {data} = this.props;\n    const normalizedGeojson = normalize(data);\n\n    this.state.choropleths = normalizedGeojson.features.map(choropleth => {\n      let coordinates = choropleth.geometry.coordinates[0];\n      // flatten nested polygons\n      if (coordinates.length === 1 && coordinates[0].length > 2) {\n        coordinates = coordinates[0];\n      }\n      return {\n        properties: choropleth.properties,\n        coordinates\n      };\n    });\n\n    this.state.groupedVertices = this.state.choropleths.map(\n      choropleth => choropleth.coordinates.map(\n        coordinate => [coordinate[0], coordinate[1], 100]\n      )\n    );\n  }\n\n  calculateContourIndices(numVertices) {\n    // use vertex pairs for gl.LINES => [0, 1, 1, 2, 2, ..., n-1, n-1, 0]\n    let indices = [];\n    for (let i = 1; i < numVertices - 1; i++) {\n      indices = [...indices, i, i];\n    }\n    return [0, ...indices, 0];\n  }\n\n  onHover(info) {\n    const {index} = info;\n    const {data} = this.props;\n    const feature = data.features[index];\n    this.props.onHover({...info, feature});\n  }\n\n  onClick(info) {\n    const {index} = info;\n    const {data} = this.props;\n    const feature = data.features[index];\n    this.props.onClick({...info, feature});\n  }\n\n}\n"]}