util/mesh.js

  1. /**
  2.  * Computed colored mesh information.
  3.  *
  4.  * @typedef {geo.meshFeature.meshInfo} geo.meshFeature.meshColoredInfo
  5.  * @extends geo.meshFeature.meshInfo
  6.  * @property {number[]} value An array of values that have been normalized to a
  7.  *    range of [0, steps].  There is one value per vertex or element.
  8.  * @property {number[]} opacity An array of opacities per vertex or element.
  9.  * @property {number} minValue the minimum value used for the contour.  If
  10.  *    `rangeValues` was specified, this is the first entry of that array.
  11.  * @property {number} maxValue the maximum value used for the contour.  If
  12.  *    `rangeValues` was specified, this is the last entry of that array.
  13.  * @property {number} factor If linear value scaling is used, this is the
  14.  *    number of color values divided by the difference between the maximum and
  15.  *    minimum values.  It is ignored if non-linear value scaling is used.
  16.  * @property {geo.geoColorObject} minColor The color used for values below
  17.  *    minValue.  Includes opacity.
  18.  * @property {geo.geoColorObject} maxColor The color used for values above
  19.  *    maxValue.  Includes opacity.
  20.  * @property {geo.geoColorObject[]} colorMap The specified `colorRange` and
  21.  *    `opacityRange` converted into objects that include opacity.
  22.  * @property {boolean} elementValues Truthy if the `value` and `opacity` are
  23.  *    for elements, falsy for vertices.
  24.  */
  26. /**
  27.  * Create a set of vertices, values at the vertices or elements, and opacities
  28.  * at the vertices or elements.  Create a set of triangles of indices into the
  29.  * vertex array.  Create a color and opacity map corresponding to the values.
  30.  *
  31.  * @param {geo.meshFeature} feature A mesh feature.
  32.  * @param {boolean} elementValues Truthy to compute values and opacities at
  33.  *    elements, falsy for vertices.
  34.  * @returns {geo.meshFeature.meshColoredInfo} An object with the colored mesh
  35.  *    information.
  36.  * @memberof geo.util
  37.  */
  38. function createColoredMesh(feature, elementValues) {
  39.   var util = require('../util');
  41.   var mesh = feature.mesh,
  42.       valueFunc = feature.style.get('value'),
  43.       usedFunc = feature.style('used') !== undefined ?
  44.         feature.style.get('used') :
  45.         function (d, i) { return util.isNonNullFinite(valueFunc(d, i)); },
  46.       minmax, val, range, i, k;
  47.   var meshParams = {
  48.     used: usedFunc,
  49.     opacity: feature.style.get('opacity'),
  50.     value: valueFunc
  51.   };
  52.   var result = feature._createMesh(
  53.     !elementValues ? meshParams : {},
  54.     elementValues ? meshParams : {});
  55.   result.elementValues = !!elementValues;
  56.   if (!result.numVertices || !result.numElements) {
  57.     return result;
  58.   }
  59.   var stepped = mesh.get('stepped')(result),
  60.       opacityRange = mesh.get('opacityRange')(result),
  61.       rangeValues = mesh.get('rangeValues')(result);
  62.   result.stepped = stepped === undefined || stepped ? true : false;
  63.   /* Create the min/max colors and the color array */
  64.   result.colorMap = [];
  65.   result.minColor = Object.assign(
  66.     {a: mesh.get('minOpacity')(result) || 0},
  67.     util.convertColor(mesh.get('minColor')(result)));
  68.   result.maxColor = Object.assign(
  69.     {a: mesh.get('maxOpacity')(result) || 0},
  70.     util.convertColor(mesh.get('maxColor')(result)));
  71.   mesh.get('colorRange')(result).forEach(function (clr, idx) {
  72.     result.colorMap.push(Object.assign({
  73.       a: opacityRange && opacityRange[idx] !== undefined ? opacityRange[idx] : 1
  74.     }, util.convertColor(clr)));
  75.   });
  76.   /* Get min and max values */
  77.   minmax = util.getMinMaxValues(result.value, mesh.get('min')(result), mesh.get('max')(result));
  78.   result.minValue = minmax.min;
  79.   result.maxValue = minmax.max;
  80.   if (!rangeValues || !result.colorMap ||
  81.       (rangeValues.length !== result.colorMap.length + 1 && (
  82.         stepped || rangeValues.length !== result.colorMap.length))) {
  83.     rangeValues = null;
  84.   }
  85.   if (rangeValues) {  /* ensure increasing monotonicity */
  86.     for (k = 1; k < rangeValues.length; k += 1) {
  87.       if (rangeValues[k - 1] > rangeValues[k]) {
  88.         rangeValues = null;
  89.         break;
  90.       }
  91.     }
  92.   }
  93.   if (rangeValues) {
  94.     result.minValue = rangeValues[0];
  95.     result.maxValue = rangeValues[rangeValues.length - 1];
  96.   }
  97.   range = result.maxValue - result.minValue;
  98.   if (!range) {
  99.     result.colorMap = result.colorMap.slice(0, 1);
  100.     range = 1;
  101.     rangeValues = null;
  102.   }
  103.   result.rangeValues = rangeValues;
  104.   result.factor = (result.colorMap.length - (stepped ? 0 : 1)) / range;
  105.   /* Scale values */
  106.   for (i = 0; i < result.value.length; i += 1) {
  107.     val = result.value[i];
  108.     if (rangeValues && val >= result.minValue && val <= result.maxValue) {
  109.       for (k = 1; k < rangeValues.length; k += 1) {
  110.         if (val <= rangeValues[k]) {
  111.           result.value[i] = k - 1 + (val - rangeValues[k - 1]) /
  112.               (rangeValues[k] - rangeValues[k - 1]);
  113.           break;
  114.         }
  115.       }
  116.     } else {
  117.       result.value[i] = (val - result.minValue) * result.factor;
  118.     }
  119.   }
  120.   return result;
  121. }
  123. module.exports = {
  124.   createColoredMesh: createColoredMesh
  125. };