itowns 2.44.3-next.40 → 2.44.3-next.41

package/lib/Utils/DEMUtils.js

@@ -1,350 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from "../Core/Geographic/Coordinates.js";
-import placeObjectOnGround from "./placeObjectOnGround.js";
-const FAST_READ_Z = 0;
-const PRECISE_READ_Z = 1;
-
-/**
- * Utility module to retrieve elevation at a given coordinates. The returned
- * value is read in the elevation textures used by the graphics card to render
- * the tiles (globe or plane). This implies that the return value may change
- * depending on the current tile resolution.
- *
- * @module DEMUtils
- */
-export default {
-  /**
-   * Gives the elevation value of a {@link TiledGeometryLayer}, at a specific
-   * {@link Coordinates}.
-   *
-   * @param {TiledGeometryLayer} layer - The tile layer owning the elevation
-   * textures we're going to query. This is typically a `GlobeLayer` or
-   * `PlanarLayer` (accessible through `view.tileLayer`).
-   * @param {Coordinates} coord - The coordinates that we're interested in.
-   * @param {number} [method=FAST_READ_Z] - There are two available methods:
-   * `FAST_READ_Z` (default) or `PRECISE_READ_Z`. The first one is faster,
-   * while the second one is slower but gives better precision.
-   * @param {TileMesh[]} [tileHint] - Optional array of tiles to speed up the
-   * process. You can give candidates tiles likely to contain `coord`.
-   * Otherwise the lookup process starts from the root of `layer`.
-   *
-   * @return {number} If found, a value in meters is returned; otherwise
-   * `undefined`.
-   */
-  getElevationValueAt(layer, coord) {
-    let method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : FAST_READ_Z;
-    let tileHint = arguments.length > 3 ? arguments[3] : undefined;
-    const result = _readZ(layer, method, coord, tileHint || layer.level0Nodes);
-    if (result) {
-      return result.coord.z;
-    }
-  },
-  /**
-   * @typedef Terrain
-   * @type {Object}
-   *
-   * @property {Coordinates} coord - Pick coordinate with the elevation in coord.z.
-   * @property {THREE.Texture} texture - the picked elevation texture.
-   * The texture where the `z` value has been read from
-   * @property {TileMesh} tile - the picked tile and the tile containing the texture
-   */
-  /**
-   * Gives a {@link Terrain} object, at a specific {@link Coordinates}. The returned
-   * object is as follow:
-   * - `coord`, Coordinate, coord.z is the value in meters of the elevation at the coordinates
-   * - `texture`, the texture where the `z` value has been read from
-   * - `tile`, the tile containing the texture
-   * @example
-   * // place mesh on the ground
-   * const coord = new Coordinates('EPSG:4326', 6, 45);
-   * const result = DEMUtils.getTerrainObjectAt(view.tileLayer, coord)
-   * mesh.position.copy(result.coord.as(view.referenceCrs));
-   * view.scene.add(mesh);
-   * mesh.updateMatrixWorld();
-   *
-   *
-   * @param {TiledGeometryLayer} layer - The tile layer owning the elevation
-   * textures we're going to query. This is typically a `GlobeLayer` or
-   * `PlanarLayer` (accessible through `view.tileLayer`).
-   * @param {Coordinates} coord - The coordinates that we're interested in.
-   * @param {number} [method=FAST_READ_Z] - There are two available methods:
-   * `FAST_READ_Z` (default) or `PRECISE_READ_Z`. The first one is faster,
-   * while the second one is slower but gives better precision.
-   * @param {TileMesh[]} [tileHint] - Optional array of tiles to speed up the
-   * process. You can give candidates tiles likely to contain `coord`.
-   * Otherwise the lookup process starts from the root of `layer`.
-   * @param {Object} [cache] - Object to cache previous result and speed up the next `getTerrainObjectAt`` use.
-   *
-   * @return {Terrain} - The {@link Terrain} object.
-   */
-  getTerrainObjectAt(layer, coord) {
-    let method = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : FAST_READ_Z;
-    let tileHint = arguments.length > 3 ? arguments[3] : undefined;
-    let cache = arguments.length > 4 ? arguments[4] : undefined;
-    return _readZ(layer, method, coord, tileHint || layer.level0Nodes, cache);
-  },
-  FAST_READ_Z,
-  PRECISE_READ_Z,
-  placeObjectOnGround
-};
-function tileAt(pt, tile) {
-  if (tile.extent) {
-    if (!tile.extent.isPointInside(pt)) {
-      return undefined;
-    }
-    for (let i = 0; i < tile.children.length; i++) {
-      const t = tileAt(pt, tile.children[i]);
-      if (t) {
-        return t;
-      }
-    }
-    const tileLayer = tile.material.getElevationLayer();
-    if (tileLayer && tileLayer.level >= 0) {
-      return tile;
-    }
-    return undefined;
-  }
-}
-let _canvas;
-function _readTextureValueAt(metadata, texture) {
-  for (var _len = arguments.length, uv = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-    uv[_key - 2] = arguments[_key];
-  }
-  for (let i = 0; i < uv.length; i += 2) {
-    uv[i] = THREE.MathUtils.clamp(uv[i], 0, texture.image.width - 1);
-    uv[i + 1] = THREE.MathUtils.clamp(uv[i + 1], 0, texture.image.height - 1);
-  }
-  if (texture.image.data) {
-    // read a single value
-    if (uv.length === 2) {
-      const v = texture.image.data[uv[1] * texture.image.width + uv[0]];
-      return v != metadata.noDataValue ? v : undefined;
-    }
-    // or read multiple values
-    const result = [];
-    for (let i = 0; i < uv.length; i += 2) {
-      const v = texture.image.data[uv[i + 1] * texture.image.width + uv[i]];
-      result.push(v != metadata.noDataValue ? v : undefined);
-    }
-    return result;
-  } else {
-    if (!_canvas) {
-      _canvas = document.createElement('canvas');
-      _canvas.width = 2;
-      _canvas.height = 2;
-    }
-    let minx = Infinity;
-    let miny = Infinity;
-    let maxx = -Infinity;
-    let maxy = -Infinity;
-    for (let i = 0; i < uv.length; i += 2) {
-      minx = Math.min(uv[i], minx);
-      miny = Math.min(uv[i + 1], miny);
-      maxx = Math.max(uv[i], maxx);
-      maxy = Math.max(uv[i + 1], maxy);
-    }
-    const dw = maxx - minx + 1;
-    const dh = maxy - miny + 1;
-    _canvas.width = Math.max(_canvas.width, dw);
-    _canvas.height = Math.max(_canvas.height, dh);
-    const ctx = _canvas.getContext('2d', {
-      willReadFrequently: true
-    });
-    ctx.drawImage(texture.image, minx, miny, dw, dh, 0, 0, dw, dh);
-    const d = ctx.getImageData(0, 0, dw, dh);
-    const result = [];
-    for (let i = 0; i < uv.length; i += 2) {
-      const ox = uv[i] - minx;
-      const oy = uv[i + 1] - miny;
-
-      // d is 4 bytes per pixel
-      const v = THREE.MathUtils.lerp(metadata.colorTextureElevationMinZ, metadata.colorTextureElevationMaxZ, d.data[4 * oy * dw + 4 * ox] / 255);
-      result.push(v != metadata.noDataValue ? v : undefined);
-    }
-    if (uv.length === 2) {
-      return result[0];
-    } else {
-      return result;
-    }
-  }
-}
-function _convertUVtoTextureCoords(texture, u, v) {
-  const width = texture.image.width;
-  const height = texture.image.height;
-  const up = Math.max(0, u * width - 0.5);
-  const vp = Math.max(0, v * height - 0.5);
-  const u1 = Math.floor(up);
-  const u2 = Math.ceil(up);
-  const v1 = Math.floor(vp);
-  const v2 = Math.ceil(vp);
-  return {
-    u1,
-    u2,
-    v1,
-    v2,
-    wu: up - u1,
-    wv: vp - v1
-  };
-}
-function _readTextureValueNearestFiltering(metadata, texture, vertexU, vertexV) {
-  const coords = _convertUVtoTextureCoords(texture, vertexU, vertexV);
-  const u = coords.wu <= 0 ? coords.u1 : coords.u2;
-  const v = coords.wv <= 0 ? coords.v1 : coords.v2;
-  return _readTextureValueAt(metadata, texture, u, v);
-}
-function _lerpWithUndefinedCheck(x, y, t) {
-  if (x == undefined) {
-    return y;
-  } else if (y == undefined) {
-    return x;
-  } else {
-    return THREE.MathUtils.lerp(x, y, t);
-  }
-}
-export function readTextureValueWithBilinearFiltering(metadata, texture, vertexU, vertexV) {
-  const coords = _convertUVtoTextureCoords(texture, vertexU, vertexV);
-  const [z11, z21, z12, z22] = _readTextureValueAt(metadata, texture, coords.u1, coords.v1, coords.u2, coords.v1, coords.u1, coords.v2, coords.u2, coords.v2);
-
-  // horizontal filtering
-  const zu1 = _lerpWithUndefinedCheck(z11, z21, coords.wu);
-  const zu2 = _lerpWithUndefinedCheck(z12, z22, coords.wu);
-  // then vertical filtering
-  return _lerpWithUndefinedCheck(zu1, zu2, coords.wv);
-}
-function _readZFast(layer, texture, uv) {
-  const elevationLayer = layer.attachedLayers.filter(l => l.isElevationLayer)[0];
-  return _readTextureValueNearestFiltering(elevationLayer, texture, uv.x, uv.y);
-}
-const bary = new THREE.Vector3();
-function _readZCorrect(layer, texture, uv, tileDimensions, tileOwnerDimensions) {
-  // We need to emulate the vertex shader code that does 2 thing:
-  //   - interpolate (u, v) between triangle vertices: u,v will be multiple of 1/nsegments
-  //     (for now assume nsegments == 16)
-  //   - read elevation texture at (u, v) for
-
-  // Determine u,v based on the vertices count.
-  // 'modulo' is the gap (in [0, 1]) between 2 successive vertices in the geometry
-  // e.g if you have 5 vertices, the only possible values for u (or v) are: 0, 0.25, 0.5, 0.75, 1
-  // so modulo would be 0.25
-  // note: currently the number of segments is hard-coded to 16 (see TileProvider) => 17 vertices
-  const modulo = tileDimensions.x / tileOwnerDimensions.x / (17 - 1);
-  let u = Math.floor(uv.x / modulo) * modulo;
-  let v = Math.floor(uv.y / modulo) * modulo;
-  if (u == 1) {
-    u -= modulo;
-  }
-  if (v == 1) {
-    v -= modulo;
-  }
-
-  // Build 4 vertices, 3 of them will be our triangle:
-  //    11---21
-  //    |   / |
-  //    |  /  |
-  //    | /   |
-  //    21---22
-  const u1 = u;
-  const u2 = u + modulo;
-  const v1 = v;
-  const v2 = v + modulo;
-
-  // Our multiple z-value will be weigh-blended, depending on the distance of the real point
-  // so lu (resp. lv) are the weight. When lu -> 0 (resp. 1) the final value -> z at u1 (resp. u2)
-  const lu = (uv.x - u) / modulo;
-  const lv = (uv.y - v) / modulo;
-
-  // Determine if we're going to read the vertices from the top-left or lower-right triangle
-  // (low-right = on the line 21-22 or under the diagonal lu = 1 - lv)
-
-  const tri = new THREE.Triangle(new THREE.Vector3(u1, v2), new THREE.Vector3(u2, v1), lv == 1 || lu / (1 - lv) >= 1 ? new THREE.Vector3(u2, v2) : new THREE.Vector3(u1, v1));
-
-  // bary holds the respective weight of each vertices of the triangles
-  tri.getBarycoord(new THREE.Vector3(uv.x, uv.y), bary);
-  const elevationLayer = layer.attachedLayers.filter(l => l.isElevationLayer)[0];
-
-  // read the 3 interesting values
-  const z1 = readTextureValueWithBilinearFiltering(elevationLayer, texture, tri.a.x, tri.a.y);
-  const z2 = readTextureValueWithBilinearFiltering(elevationLayer, texture, tri.b.x, tri.b.y);
-  const z3 = readTextureValueWithBilinearFiltering(elevationLayer, texture, tri.c.x, tri.c.y);
-
-  // Blend with bary
-  return z1 * bary.x + z2 * bary.y + z3 * bary.z;
-}
-const temp = {
-  v: new THREE.Vector3(),
-  coord1: new Coordinates('EPSG:4978'),
-  coord2: new Coordinates('EPSG:4978'),
-  offset: new THREE.Vector2()
-};
-const dimension = new THREE.Vector2();
-function offsetInExtent(point, extent) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new THREE.Vector2();
-  if (point.crs != extent.crs) {
-    throw new Error(`Unsupported mix: ${point.crs} and ${extent.crs}`);
-  }
-  extent.planarDimensions(dimension);
-  const originX = (point.x - extent.west) / dimension.x;
-  const originY = (extent.north - point.y) / dimension.y;
-  return target.set(originX, originY);
-}
-function _readZ(layer, method, coord, nodes, cache) {
-  const pt = coord.as(layer.extent.crs, temp.coord1);
-  let tileWithValidElevationTexture = null;
-  // first check in cache
-  if (cache?.tile?.material) {
-    tileWithValidElevationTexture = tileAt(pt, cache.tile);
-  }
-  for (let i = 0; !tileWithValidElevationTexture && i < nodes.length; i++) {
-    tileWithValidElevationTexture = tileAt(pt, nodes[i]);
-  }
-  if (!tileWithValidElevationTexture) {
-    // failed to find a tile, abort
-    return;
-  }
-  const tile = tileWithValidElevationTexture;
-  const tileLayer = tile.material.getElevationLayer();
-  const src = tileLayer.textures[0];
-
-  // check cache value if existing
-  if (cache) {
-    if (cache.id === src.id && cache.version === src.version) {
-      return {
-        coord: pt,
-        texture: src,
-        tile
-      };
-    }
-  }
-
-  // Assuming that tiles are split in 4 children, we lookup the parent that
-  // really owns this texture
-  const stepsUpInHierarchy = Math.round(Math.log2(1.0 / tileLayer.offsetScales[0].z));
-  for (let i = 0; i < stepsUpInHierarchy; i++) {
-    tileWithValidElevationTexture = tileWithValidElevationTexture.parent;
-  }
-
-  // offset = offset from top-left
-  offsetInExtent(pt, tileWithValidElevationTexture.extent, temp.offset);
-
-  // At this point we have:
-  //   - tileWithValidElevationTexture.texture.image which is the current image
-  //     used for rendering
-  //   - offset which is the offset in this texture for the coordinate we're
-  //     interested in
-  // We now have 2 options:
-  //   - the fast one: read the value of tileWithValidElevationTexture.texture.image
-  //     at (offset.x, offset.y) and we're done
-  //   - the correct one: emulate the vertex shader code
-  if (method == PRECISE_READ_Z) {
-    pt.z = _readZCorrect(layer, src, temp.offset, tile.extent.planarDimensions(), tileWithValidElevationTexture.extent.planarDimensions());
-  } else {
-    pt.z = _readZFast(layer, src, temp.offset);
-  }
-  if (pt.z != undefined) {
-    return {
-      coord: pt,
-      texture: src,
-      tile
-    };
-  }
-}

package/lib/Utils/FeaturesUtils.js

@@ -1,156 +0,0 @@
-import { FEATURE_TYPES } from "../Core/Feature.js";
-import Coordinates from "../Core/Geographic/Coordinates.js";
-function pointIsOverLine(point, linePoints, epsilon, offset, count, size) {
-  const x0 = point.x;
-  const y0 = point.y;
-  // for each segment of the line (j is i -1)
-  for (let i = offset + size, j = offset; i < offset + count; j = i, i += size) {
-    /* **********************************************************
-        norm     : norm of vector P1P2
-        distance : distance point P0 to line P1P2
-        scalar   : dot product of P1P0 and P1P2 divide by norm, it represents the projection of P0 on the line
-         Point is over segment P1P2 if :
-            * if the distance, , is inferior to epsilon
-            * and if :  -epsilon ≤ scalar ≤ (||P1P2|| +  epsilon)
-                         + (P0) _
-                        |      |
-                        |      |
-         <---scalar---->|    distance
-                        |      |
-                        |      v
-         +-------------------------------+
-        (P1)                            (P2)
-    *********************************************************** */
-
-    const x1 = linePoints[i];
-    const y1 = linePoints[i + 1];
-    const x2 = linePoints[j];
-    const y2 = linePoints[j + 1];
-    const x21 = x2 - x1;
-    const y21 = y2 - y1;
-    const norm = Math.sqrt(x21 * x21 + y21 * y21);
-    const scalar = ((x0 - x1) * x21 + (y0 - y1) * y21) / norm;
-    if (scalar >= -epsilon && scalar <= norm + epsilon) {
-      const distance = Math.abs(y21 * x0 - x21 * y0 + x2 * y1 - y2 * x1) / norm;
-      if (distance <= epsilon) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function getClosestPoint(point, points, epsilon, offset, count, size) {
-  const x0 = point.x;
-  const y0 = point.y;
-  let squaredEpsilon = epsilon * epsilon;
-  let closestPoint;
-  for (let i = offset; i < offset + count; i += size) {
-    const x1 = points[i];
-    const y1 = points[i + 1];
-    const xP = x0 - x1;
-    const yP = y0 - y1;
-    const n = xP * xP + yP * yP;
-    if (n < squaredEpsilon) {
-      closestPoint = [points[i], points[i + 1]];
-      squaredEpsilon = n;
-    }
-  }
-  return closestPoint;
-}
-function pointIsInsidePolygon(point, polygonPoints, epsilon, offset, count, size) {
-  // ray-casting algorithm based on
-  // http://wrf.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
-
-  const x = point.x;
-  const y = point.y;
-  let inside = false;
-  // in first j is last point of polygon
-  // for each segment of the polygon (j is i -1)
-  for (let i = offset, j = offset + count - size; i < offset + count; j = i, i += size) {
-    const xi = polygonPoints[i];
-    const yi = polygonPoints[i + 1];
-    const xj = polygonPoints[j];
-    const yj = polygonPoints[j + 1];
-    if (pointIsOverLine(point, [xi, yi, xj, yj], epsilon, 0, 4, 2)) {
-      return true;
-    }
-
-    // isIntersect semi-infinite ray horizontally with polygon's edge
-
-    if (yi > y != yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) {
-      inside = !inside;
-    }
-  }
-  return inside;
-}
-function isFeatureSingleGeometryUnderCoordinate(coordinate, type, coordinates, epsilon, offset, count, size) {
-  if (type == FEATURE_TYPES.LINE && pointIsOverLine(coordinate, coordinates, epsilon, offset, count, size)) {
-    return true;
-  } else if (type == FEATURE_TYPES.POLYGON && pointIsInsidePolygon(coordinate, coordinates, epsilon, offset, count, size)) {
-    return true;
-  } else if (type == FEATURE_TYPES.POINT) {
-    const closestPoint = getClosestPoint(coordinate, coordinates, epsilon, offset, count, size);
-    if (closestPoint) {
-      return {
-        coordinates: closestPoint
-      };
-    }
-  }
-}
-function isFeatureUnderCoordinate(coordinate, feature, epsilon, result) {
-  const featCoord = coordinate.as(feature.crs);
-  for (const geometry of feature.geometries) {
-    if (geometry.extent == undefined || geometry.extent.isPointInside(featCoord, epsilon)) {
-      const offset = geometry.indices[0].offset * feature.size;
-      const count = geometry.indices[0].count * feature.size;
-      const under = isFeatureSingleGeometryUnderCoordinate(featCoord, feature.type, feature.vertices, epsilon, offset, count, feature.size);
-      if (under) {
-        result.push({
-          type: feature.type,
-          geometry,
-          coordinates: under.coordinates /* || coordinates */,
-          style: feature.style
-        });
-      }
-    }
-  }
-}
-const coord = new Coordinates('EPSG:4326', 0, 0, 0);
-export default {
-  /**
-   * Filter from a list of features, features that are under a coordinate.
-   *
-   * @param {Coordinates} coordinate - The coordinate for the filter
-   * condition.
-   * @param {Feature|FeatureCollection} collection - A single feature or a
-   * collection of them, to filter given the previous coordinate.
-   * @param {number} [epsilon=0.1] Tolerance around the coordinate (in
-   * coordinate's unit).
-   *
-   * @return {Feature[]} Array of filtered features.
-   */
-  filterFeaturesUnderCoordinate(coordinate, collection) {
-    let epsilon = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.1;
-    const result = [];
-
-    // transform coordinates to collection system projection
-    coordinate.as(collection.crs, coord);
-
-    // transform coordinates to local system
-    coord.applyMatrix4(collection.matrixWorldInverse);
-    if (collection.extent.isPointInside(coord, epsilon)) {
-      if (collection.isFeatureCollection) {
-        epsilon *= Math.sqrt(collection.scale.x ** 2 + collection.scale.y ** 2);
-        for (const feature of collection.features) {
-          if (feature.extent && !feature.extent.isPointInside(coord, epsilon)) {
-            continue;
-          }
-          isFeatureUnderCoordinate(coord, feature, epsilon, result);
-        }
-      } else if (collection.geometries) {
-        isFeatureUnderCoordinate(coord, collection, epsilon, result);
-      }
-    }
-    return result;
-  }
-};

package/lib/Utils/Gradients.js

@@ -1,16 +0,0 @@
-import * as THREE from 'three';
-export default {
-  // From chroma spectral http://gka.github.io/chroma.js/
-  SPECTRAL: [[0, new THREE.Color(0.3686, 0.3098, 0.6353)], [0.1, new THREE.Color(0.1961, 0.5333, 0.7412)], [0.2, new THREE.Color(0.4000, 0.7608, 0.6471)], [0.3, new THREE.Color(0.6706, 0.8667, 0.6431)], [0.4, new THREE.Color(0.9020, 0.9608, 0.5961)], [0.5, new THREE.Color(1.0000, 1.0000, 0.7490)], [0.6, new THREE.Color(0.9961, 0.8784, 0.5451)], [0.7, new THREE.Color(0.9922, 0.6824, 0.3804)], [0.8, new THREE.Color(0.9569, 0.4275, 0.2627)], [0.9, new THREE.Color(0.8353, 0.2431, 0.3098)], [1, new THREE.Color(0.6196, 0.0039, 0.2588)]],
-  PLASMA: [[0.0, new THREE.Color(0.241, 0.015, 0.610)], [0.1, new THREE.Color(0.387, 0.001, 0.654)], [0.2, new THREE.Color(0.524, 0.025, 0.653)], [0.3, new THREE.Color(0.651, 0.125, 0.596)], [0.4, new THREE.Color(0.752, 0.227, 0.513)], [0.5, new THREE.Color(0.837, 0.329, 0.431)], [0.6, new THREE.Color(0.907, 0.435, 0.353)], [0.7, new THREE.Color(0.963, 0.554, 0.272)], [0.8, new THREE.Color(0.992, 0.681, 0.195)], [0.9, new THREE.Color(0.987, 0.822, 0.144)], [1.0, new THREE.Color(0.940, 0.975, 0.131)]],
-  YELLOW_GREEN: [[0, new THREE.Color(0.1647, 0.2824, 0.3451)], [0.1, new THREE.Color(0.1338, 0.3555, 0.4227)], [0.2, new THREE.Color(0.0610, 0.4319, 0.4864)], [0.3, new THREE.Color(0.0000, 0.5099, 0.5319)], [0.4, new THREE.Color(0.0000, 0.5881, 0.5569)], [0.5, new THREE.Color(0.1370, 0.6650, 0.5614)], [0.6, new THREE.Color(0.2906, 0.7395, 0.5477)], [0.7, new THREE.Color(0.4453, 0.8099, 0.5201)], [0.8, new THREE.Color(0.6102, 0.8748, 0.4850)], [0.9, new THREE.Color(0.7883, 0.9323, 0.4514)], [1, new THREE.Color(0.9804, 0.9804, 0.4314)]],
-  VIRIDIS: [[0.0, new THREE.Color(0.267, 0.005, 0.329)], [0.1, new THREE.Color(0.283, 0.141, 0.458)], [0.2, new THREE.Color(0.254, 0.265, 0.530)], [0.3, new THREE.Color(0.207, 0.372, 0.553)], [0.4, new THREE.Color(0.164, 0.471, 0.558)], [0.5, new THREE.Color(0.128, 0.567, 0.551)], [0.6, new THREE.Color(0.135, 0.659, 0.518)], [0.7, new THREE.Color(0.267, 0.749, 0.441)], [0.8, new THREE.Color(0.478, 0.821, 0.318)], [0.9, new THREE.Color(0.741, 0.873, 0.150)], [1.0, new THREE.Color(0.993, 0.906, 0.144)]],
-  INFERNO: [[0.0, new THREE.Color(0.077, 0.042, 0.206)], [0.1, new THREE.Color(0.225, 0.036, 0.388)], [0.2, new THREE.Color(0.373, 0.074, 0.432)], [0.3, new THREE.Color(0.522, 0.128, 0.420)], [0.4, new THREE.Color(0.665, 0.182, 0.370)], [0.5, new THREE.Color(0.797, 0.255, 0.287)], [0.6, new THREE.Color(0.902, 0.364, 0.184)], [0.7, new THREE.Color(0.969, 0.516, 0.063)], [0.8, new THREE.Color(0.988, 0.683, 0.072)], [0.9, new THREE.Color(0.961, 0.859, 0.298)], [1.0, new THREE.Color(0.988, 0.998, 0.645)]],
-  GRAYSCALE: [[0, new THREE.Color(0, 0, 0)], [1, new THREE.Color(1, 1, 1)]],
-  // 16 samples of the TURBU color scheme
-  // values taken from: https://gist.github.com/mikhailov-work/ee72ba4191942acecc03fe6da94fc73f
-  // original file licensed under Apache-2.0
-  TURBO: [[0.00, new THREE.Color(0.18995, 0.07176, 0.23217)], [0.07, new THREE.Color(0.25107, 0.25237, 0.63374)], [0.13, new THREE.Color(0.27628, 0.42118, 0.89123)], [0.20, new THREE.Color(0.25862, 0.57958, 0.99876)], [0.27, new THREE.Color(0.15844, 0.73551, 0.92305)], [0.33, new THREE.Color(0.09267, 0.86554, 0.7623)], [0.40, new THREE.Color(0.19659, 0.94901, 0.59466)], [0.47, new THREE.Color(0.42778, 0.99419, 0.38575)], [0.53, new THREE.Color(0.64362, 0.98999, 0.23356)], [0.60, new THREE.Color(0.80473, 0.92452, 0.20459)], [0.67, new THREE.Color(0.93301, 0.81236, 0.22667)], [0.73, new THREE.Color(0.99314, 0.67408, 0.20348)], [0.80, new THREE.Color(0.9836, 0.49291, 0.12849)], [0.87, new THREE.Color(0.92105, 0.31489, 0.05475)], [0.93, new THREE.Color(0.81608, 0.18462, 0.01809)], [1.00, new THREE.Color(0.66449, 0.08436, 0.00424)]],
-  RAINBOW: [[0, new THREE.Color(0.278, 0, 0.714)], [1 / 6, new THREE.Color(0, 0, 1)], [2 / 6, new THREE.Color(0, 1, 1)], [3 / 6, new THREE.Color(0, 1, 0)], [4 / 6, new THREE.Color(1, 1, 0)], [5 / 6, new THREE.Color(1, 0.64, 0)], [1, new THREE.Color(1, 0, 0)]],
-  CONTOUR: [[0.00, new THREE.Color(0, 0, 0)], [0.03, new THREE.Color(0, 0, 0)], [0.04, new THREE.Color(1, 1, 1)], [1.00, new THREE.Color(1, 1, 1)]]
-};