itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Utils/DEMUtils.js

@@ -0,0 +1,350 @@
+import * as THREE from 'three';
+import { Coordinates } from '@itowns/geographic';
+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

@@ -0,0 +1,156 @@
+import { FEATURE_TYPES } from "../Core/Feature.js";
+import { Coordinates } from '@itowns/geographic';
+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

@@ -0,0 +1,16 @@
+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)]]
+};

package/lib/Utils/ThreeUtils.js

@@ -0,0 +1,115 @@
+/**
+ * Find threejs textures from a material
+ * @param {Material} material the threejs material holding textures
+ * @returns {Array} an array of textures in the material
+ */
+function findTextures(material) {
+  const textures = [];
+  if (material.alphaMap) {
+    textures.push(material.map);
+  }
+  if (material.aoMap) {
+    textures.push(material.map);
+  }
+  if (material.bumpMap) {
+    textures.push(material.bumpMap);
+  }
+  if (material.displacementMap) {
+    textures.push(material.bumpMap);
+  }
+  if (material.emissiveMap) {
+    textures.push(material.emissiveMap);
+  }
+  if (material.envMap) {
+    textures.push(material.envMap);
+  }
+  if (material.lightMap) {
+    textures.push(material.envMap);
+  }
+  if (material.map) {
+    textures.push(material.map);
+  }
+  if (material.metalnessMap) {
+    textures.push(material.map);
+  }
+  if (material.normalMap) {
+    textures.push(material.map);
+  }
+  if (material.roughnessMap) {
+    textures.push(material.map);
+  }
+  if (material.specularMap) {
+    textures.push(material.specularMap);
+  }
+  return textures;
+}
+
+/**
+ * Removes a material and its textures, memory will be freed.
+ * IMPORTANT NOTE: the material and the texture must not be referenced by other threejs objects, otherwise the memory
+ * won't be freed.
+ * @param {Material} material the material to remove
+ */
+export default function disposeThreeMaterial(material) {
+  const textures = findTextures(material);
+  // Remove material
+  if (Array.isArray(material)) {
+    for (const m of material) {
+      m.dispose();
+    }
+  } else {
+    material.dispose();
+  }
+  // Remove textures
+  for (let i = 0; i < textures.length; i++) {
+    textures[i].dispose();
+  }
+}
+
+/**
+ * Merge groups of an object3D when it can to reduce number of them + remove unused materials
+ * Reduce draw call https://threejs.org/docs/index.html?q=geometry#api/en/core/BufferGeometry.groups
+ *
+ * @param {THREE.Object3D} object3D - object to get optimize
+ */
+export function optimizeGeometryGroups(object3D) {
+  if (!object3D.geometry) {
+    return;
+  }
+  object3D.geometry.groups.sort((a, b) => (a.start - b.start) * -1); // [5,10,7] => [10,7,5]
+  const lastIndex = object3D.geometry.groups.length - 1;
+  let currentMaterialIndex = object3D.geometry.groups[lastIndex].materialIndex; // initialized with the lastest group
+  const usedIndexMaterials = [currentMaterialIndex]; // compute materials actually used by group
+  // for loop descendant to be able to splice in loop without modifying group index
+  for (let index = lastIndex - 1; index >= 0; index--) {
+    // begin at lastIndex - 1 because intialized with lastIndex
+    const group = object3D.geometry.groups[index];
+    if (group.materialIndex !== currentMaterialIndex) {
+      // this is another group (!= materialIndex) take its material as ref to continue
+      currentMaterialIndex = group.materialIndex;
+      usedIndexMaterials.push(currentMaterialIndex);
+      continue;
+    } else {
+      // indeed same group merge with previous group
+      const previousGroup = object3D.geometry.groups[index + 1];
+      previousGroup.count += group.count; // previous group wrap the current one
+      object3D.geometry.groups.splice(index, 1); // remove group
+    }
+  }
+
+  // clean unused material
+  for (let index = object3D.material.length - 1; index >= 0; index--) {
+    if (!usedIndexMaterials.includes(index)) {
+      // update all materialIndex in groups
+      object3D.geometry.groups.forEach(group => {
+        if (group.materialIndex > index) {
+          // only materialIndex > at index are modified
+          group.materialIndex -= 1;
+        }
+      });
+
+      // remove
+      object3D.material.splice(index, 1);
+    }
+  }
+}