itowns 2.44.3-next.8 → 2.45.0

package/lib/Core/Geographic/Extent.js

@@ -1,534 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from "./Coordinates.js";
-import CRS from "./Crs.js";
-
-/**
- * Extent is a SIG-area (so 2D)
- * It can use explicit coordinates (e.g: lon/lat) or implicit (WMTS coordinates)
- */
-
-const _dim = new THREE.Vector2();
-const _dim2 = new THREE.Vector2();
-const _box = new THREE.Box3();
-const defaultScheme = new THREE.Vector2(2, 2);
-const cNorthWest = new Coordinates('EPSG:4326', 0, 0, 0);
-const cSouthWest = new Coordinates('EPSG:4326', 0, 0, 0);
-const cNorthEast = new Coordinates('EPSG:4326', 0, 0, 0);
-const southWest = new THREE.Vector3();
-const northEast = new THREE.Vector3();
-
-/** @type {Extent} */
-let _extent;
-const cardinals = new Array(8);
-for (let i = cardinals.length - 1; i >= 0; i--) {
-  cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0);
-}
-const _c = new Coordinates('EPSG:4326', 0, 0);
-class Extent {
-  /**
-   * Extent is geographical bounding rectangle defined by 4 limits: west, east, south and north.
-   *
-   * Warning, using geocentric projection isn't consistent with geographical extent.
-   *
-   * @param {String} crs projection of limit values.
-   * @param {number|Array.<number>|Coordinates|Object} v0 west value, Array
-   * of values [west, east, south and north], Coordinates of west-south
-   * corner or object {west, east, south and north}
-   * @param {number|Coordinates} [v1] east value or Coordinates of
-   * east-north corner
-   * @param {number} [v2] south value
-   * @param {number} [v3] north value
-   */
-  constructor(crs, v0, v1, v2, v3) {
-    if (CRS.isGeocentric(crs)) {
-      throw new Error(`${crs} is a geocentric projection, it doesn't make sense with a geographical extent`);
-    }
-    if (CRS.isTms(crs)) {
-      throw new Error(`${crs} is a tiled projection, use Tile instead`);
-    }
-    this.isExtent = true;
-    this.crs = crs;
-    this.west = 0;
-    this.east = 0;
-    this.south = 0;
-    this.north = 0;
-    this.set(v0, v1, v2, v3);
-  }
-
-  /**
-   * Clone this extent
-   * @return {Extent} cloned extent
-   */
-  clone() {
-    return new Extent(this.crs, this.west, this.east, this.south, this.north);
-  }
-
-  /**
-   * Convert Extent to the specified projection.
-   * @param {string} crs the projection of destination.
-   * @param {Extent} [target] copy the destination to target.
-   * @return {Extent}
-   */
-  as(crs, target) {
-    CRS.isValid(crs);
-    target = target || new Extent('EPSG:4326', [0, 0, 0, 0]);
-    if (this.crs != crs) {
-      // Compute min/max in x/y by projecting 8 cardinal points,
-      // and then taking the min/max of each coordinates.
-      const center = this.center(_c);
-      cardinals[0].setFromValues(this.west, this.north);
-      cardinals[1].setFromValues(center.x, this.north);
-      cardinals[2].setFromValues(this.east, this.north);
-      cardinals[3].setFromValues(this.east, center.y);
-      cardinals[4].setFromValues(this.east, this.south);
-      cardinals[5].setFromValues(center.x, this.south);
-      cardinals[6].setFromValues(this.west, this.south);
-      cardinals[7].setFromValues(this.west, center.y);
-      target.set(Infinity, -Infinity, Infinity, -Infinity);
-
-      // loop over the coordinates
-      for (let i = 0; i < cardinals.length; i++) {
-        // convert the coordinate.
-        cardinals[i].crs = this.crs;
-        cardinals[i].as(crs, _c);
-        target.north = Math.max(target.north, _c.y);
-        target.south = Math.min(target.south, _c.y);
-        target.east = Math.max(target.east, _c.x);
-        target.west = Math.min(target.west, _c.x);
-      }
-      target.crs = crs;
-      return target;
-    }
-    target.crs = crs;
-    target.set(this.west, this.east, this.south, this.north);
-    return target;
-  }
-
-  /**
-   * Return the center of Extent
-   * @param {Coordinates} target copy the center to the target.
-   * @return {Coordinates}
-   */
-  center() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Coordinates(this.crs);
-    this.planarDimensions(_dim);
-    target.crs = this.crs;
-    target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);
-    return target;
-  }
-
-  /**
-  * Returns the dimension of the extent, in a `THREE.Vector2`.
-  *
-  * @param {THREE.Vector2} [target] - The target to assign the result in.
-  *
-  * @return {THREE.Vector2}
-  */
-  dimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector2();
-    console.warn('Extent.dimensions is deprecated, use planarDimensions, geodeticDimensions or spatialEuclideanDimensions');
-    target.x = Math.abs(this.east - this.west);
-    target.y = Math.abs(this.north - this.south);
-    return target;
-  }
-
-  /**
-   *  Planar dimensions are two planar distances west/east and south/north.
-   *  Planar distance straight-line Euclidean distance calculated in a 2D Cartesian coordinate system.
-   *
-   * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
-   * @return     {THREE.Vector2}  Planar dimensions
-   */
-  planarDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector2();
-    // Calculte the dimensions for x and y
-    return target.set(Math.abs(this.east - this.west), Math.abs(this.north - this.south));
-  }
-
-  /**
-   *  Geodetic dimensions are two planar distances west/east and south/north.
-   *  Geodetic distance is calculated in an ellispoid space as the distance
-   *  across the curved surface of the world.
-   *
-   * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
-   * @return     {THREE.Vector2}  geodetic dimensions
-   */
-  geodeticDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector2();
-    // set 3 corners extent
-    cNorthWest.crs = this.crs;
-    cSouthWest.crs = this.crs;
-    cNorthEast.crs = this.crs;
-    cNorthWest.setFromValues(this.west, this.north, 0);
-    cSouthWest.setFromValues(this.west, this.south, 0);
-    cNorthEast.setFromValues(this.east, this.north, 0);
-
-    // calcul geodetic distance northWest/northEast and northWest/southWest
-    return target.set(cNorthWest.geodeticDistanceTo(cNorthEast), cNorthWest.geodeticDistanceTo(cSouthWest));
-  }
-
-  /**
-   *  Spatial euclidean dimensions are two spatial euclidean distances between west/east corner and south/north corner.
-   *  Spatial euclidean distance chord is calculated in a ellispoid space.
-   *
-   * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
-   * @return     {THREE.Vector2}  spatial euclidean dimensions
-   */
-  spatialEuclideanDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector2();
-    // set 3 corners extent
-    cNorthWest.crs = this.crs;
-    cSouthWest.crs = this.crs;
-    cNorthEast.crs = this.crs;
-    cNorthWest.setFromValues(this.west, this.north, 0);
-    cSouthWest.setFromValues(this.west, this.south, 0);
-    cNorthEast.setFromValues(this.east, this.north, 0);
-
-    // calcul chord distance northWest/northEast and northWest/southWest
-    return target.set(cNorthWest.spatialEuclideanDistanceTo(cNorthEast), cNorthWest.spatialEuclideanDistanceTo(cSouthWest));
-  }
-
-  /**
-   * Return true if `coord` is inside the bounding box.
-   *
-   * @param {Coordinates} coord
-   * @param {number} [epsilon=0] - to take into account when comparing to the
-   * point.
-   *
-   * @return {boolean}
-   */
-  isPointInside(coord) {
-    let epsilon = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    if (this.crs == coord.crs) {
-      _c.copy(coord);
-    } else {
-      coord.as(this.crs, _c);
-    }
-
-    // TODO this ignores altitude
-    return _c.x <= this.east + epsilon && _c.x >= this.west - epsilon && _c.y <= this.north + epsilon && _c.y >= this.south - epsilon;
-  }
-
-  /**
-   * Return true if `extent` is inside this extent.
-   *
-   * @param {Extent} extent the extent to check
-   * @param {number} epsilon to take into account when comparing to the
-   * point.
-   *
-   * @return {boolean}
-   */
-  isInside(extent, epsilon) {
-    extent.as(this.crs, _extent);
-    epsilon = epsilon == undefined ? CRS.reasonnableEpsilon(this.crs) : epsilon;
-    return this.east - _extent.east <= epsilon && _extent.west - this.west <= epsilon && this.north - _extent.north <= epsilon && _extent.south - this.south <= epsilon;
-  }
-
-  /**
-   * Return the translation and scale to transform this extent to input extent.
-   *
-   * @param {Extent} extent input extent
-   * @param {THREE.Vector4} target copy the result to target.
-   * @return {THREE.Vector4} {x: translation on west-east, y: translation on south-north, z: scale on west-east, w: scale on south-north}
-   */
-  offsetToParent(extent) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector4();
-    if (this.crs != extent.crs) {
-      throw new Error('unsupported mix');
-    }
-    extent.planarDimensions(_dim);
-    this.planarDimensions(_dim2);
-    const originX = (this.west - extent.west) / _dim.x;
-    const originY = (extent.north - this.north) / _dim.y;
-    const scaleX = _dim2.x / _dim.x;
-    const scaleY = _dim2.y / _dim.y;
-    return target.set(originX, originY, scaleX, scaleY);
-  }
-
-  /**
-   * Return true if this bounding box intersect with the bouding box parameter
-   * @param {Extent} extent
-   * @returns {Boolean}
-   */
-  intersectsExtent(extent) {
-    return Extent.intersectsExtent(this, extent);
-  }
-  static intersectsExtent(/** @type {Extent} */extentA, /** @type {Extent} */extentB) {
-    // TODO don't work when is on limit
-    const other = extentB.crs == extentA.crs ? extentB : extentB.as(extentA.crs, _extent);
-    return !(extentA.west >= other.east || extentA.east <= other.west || extentA.south >= other.north || extentA.north <= other.south);
-  }
-
-  /**
-   * Return the intersection of this extent with another one
-   * @param {Extent} extent
-   * @returns {Extent}
-   */
-  intersect(extent) {
-    if (!this.intersectsExtent(extent)) {
-      return new Extent(this.crs, 0, 0, 0, 0);
-    }
-    if (extent.crs != this.crs) {
-      extent = extent.as(this.crs, _extent);
-    }
-    return new Extent(this.crs, Math.max(this.west, extent.west), Math.min(this.east, extent.east), Math.max(this.south, extent.south), Math.min(this.north, extent.north));
-  }
-
-  /**
-   * Set west, east, south and north values.
-   *
-   * @param {number|Array.<number>|Coordinates|Object|Extent} v0 west value,
-   * Array of values [west, east, south and north], Extent of same type (tiled
-   * or not), Coordinates of west-south corner or object {west, east, south
-   * and north}
-   * @param {number|Coordinates} [v1] east value, row value or Coordinates of
-   * east-north corner
-   * @param {number} [v2] south value or column value
-   * @param {number} [v3] north value
-   *
-   * @return {Extent}
-   */
-  set(v0, v1, v2, v3) {
-    if (v0 == undefined) {
-      throw new Error('No values to set in the extent');
-    }
-    if (v0.isExtent) {
-      v1 = v0.east;
-      v2 = v0.south;
-      v3 = v0.north;
-      v0 = v0.west;
-    }
-    if (v0.isCoordinates) {
-      // seem never used
-      this.west = v0.x;
-      this.east = v1.x;
-      this.south = v0.y;
-      this.north = v1.y;
-    } else if (v0.west !== undefined) {
-      this.west = v0.west;
-      this.east = v0.east;
-      this.south = v0.south;
-      this.north = v0.north;
-    } else if (v0.length == 4) {
-      this.west = v0[0];
-      this.east = v0[1];
-      this.south = v0[2];
-      this.north = v0[3];
-    } else if (v3 !== undefined) {
-      this.west = v0;
-      this.east = v1;
-      this.south = v2;
-      this.north = v3;
-    }
-    return this;
-  }
-
-  /**
-   * Copy to this extent to input extent.
-   * @param {Extent} extent
-   * @return {Extent} copied extent
-   */
-  copy(extent) {
-    this.crs = extent.crs;
-    return this.set(extent);
-  }
-
-  /**
-   * Union this extent with the input extent.
-   * @param {Extent} extent the extent to union.
-   */
-  union(extent) {
-    if (extent.crs != this.crs) {
-      throw new Error('unsupported union between 2 diff crs');
-    }
-    if (this.west === Infinity) {
-      this.copy(extent);
-    } else {
-      const west = extent.west;
-      if (west < this.west) {
-        this.west = west;
-      }
-      const east = extent.east;
-      if (east > this.east) {
-        this.east = east;
-      }
-      const south = extent.south;
-      if (south < this.south) {
-        this.south = south;
-      }
-      const north = extent.north;
-      if (north > this.north) {
-        this.north = north;
-      }
-    }
-  }
-
-  /**
-   * expandByCoordinates perfoms the minimal extension
-   * for the coordinates to belong to this Extent object
-   * @param {Coordinates} coordinates  The coordinates to belong
-   */
-  expandByCoordinates(coordinates) {
-    const coords = coordinates.crs == this.crs ? coordinates : coordinates.as(this.crs, _c);
-    this.expandByValuesCoordinates(coords.x, coords.y);
-  }
-
-  /**
-  * expandByValuesCoordinates perfoms the minimal extension
-  * for the coordinates values to belong to this Extent object
-  * @param {number} we  The coordinate on west-east
-  * @param {number} sn  The coordinate on south-north
-  *
-  */
-  expandByValuesCoordinates(we, sn) {
-    if (we < this.west) {
-      this.west = we;
-    }
-    if (we > this.east) {
-      this.east = we;
-    }
-    if (sn < this.south) {
-      this.south = sn;
-    }
-    if (sn > this.north) {
-      this.north = sn;
-    }
-  }
-
-  /**
-   * Instance Extent with THREE.Box3.
-   *
-   * If crs is a geocentric projection, the `box3.min` and `box3.max`
-   * should be the geocentric coordinates of `min` and `max` of a `box3`
-   * in local tangent plane.
-   *
-   * @param {string} crs Projection of extent to instancied.
-   * @param {THREE.Box3} box
-   * @return {Extent}
-   */
-  static fromBox3(crs, box) {
-    if (CRS.isGeocentric(crs)) {
-      // if geocentric reproject box on 'EPSG:4326'
-      crs = 'EPSG:4326';
-      box = _box.copy(box);
-      cSouthWest.crs = crs;
-      cSouthWest.setFromVector3(box.min).as(crs, cSouthWest).toVector3(box.min);
-      cNorthEast.crs = crs;
-      cNorthEast.setFromVector3(box.max).as(crs, cNorthEast).toVector3(box.max);
-    }
-    return new Extent(crs, {
-      west: box.min.x,
-      east: box.max.x,
-      south: box.min.y,
-      north: box.max.y
-    });
-  }
-
-  /**
-   * Return values of extent in string, separated by the separator input.
-   * @param {string} separator
-   * @return {string}
-   */
-  toString() {
-    let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    return `${this.east}${separator}${this.north}${separator}${this.west}${separator}${this.south}`;
-  }
-
-  /**
-   * Subdivide equally an extent from its center to return four extents:
-   * north-west, north-east, south-west and south-east.
-   *
-   * @returns {Extent[]} An array containing the four sections of the extent. The
-   * order of the sections is [NW, NE, SW, SE].
-   */
-  subdivision() {
-    return this.subdivisionByScheme();
-  }
-  /**
-   * subdivise extent by scheme.x on west-east and scheme.y on south-north.
-   *
-   * @param      {THREE.Vector2}  [scheme=Vector2(2,2)]  The scheme to subdivise.
-   * @return     {Array<Extent>}   subdivised extents.
-   */
-  subdivisionByScheme() {
-    let scheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultScheme;
-    const subdivisedExtents = [];
-    const dimSub = this.planarDimensions(_dim).divide(scheme);
-    for (let x = scheme.x - 1; x >= 0; x--) {
-      for (let y = scheme.y - 1; y >= 0; y--) {
-        const west = this.west + x * dimSub.x;
-        const south = this.south + y * dimSub.y;
-        subdivisedExtents.push(new Extent(this.crs, west, west + dimSub.x, south, south + dimSub.y));
-      }
-    }
-    return subdivisedExtents;
-  }
-
-  /**
-   * Multiplies all extent `coordinates` (with an implicit 1 in the 4th dimension) and `matrix`.
-   *
-   * @param      {THREE.Matrix4}  matrix  The matrix
-   * @return     {Extent}  return this extent instance.
-   */
-  applyMatrix4(matrix) {
-    southWest.set(this.west, this.south, 0).applyMatrix4(matrix);
-    northEast.set(this.east, this.north, 0).applyMatrix4(matrix);
-    this.west = southWest.x;
-    this.east = northEast.x;
-    this.south = southWest.y;
-    this.north = northEast.y;
-    if (this.west > this.east) {
-      const temp = this.west;
-      this.west = this.east;
-      this.east = temp;
-    }
-    if (this.south > this.north) {
-      const temp = this.south;
-      this.south = this.north;
-      this.north = temp;
-    }
-    return this;
-  }
-
-  /**
-   * clamp south and north values
-   *
-   * @param      {number}  [south=this.south]  The min south
-   * @param      {number}  [north=this.north]  The max north
-   * @return     {Extent}  this extent
-   */
-  clampSouthNorth() {
-    let south = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.south;
-    let north = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.north;
-    this.south = Math.max(this.south, south);
-    this.north = Math.min(this.north, north);
-    return this;
-  }
-
-  /**
-   * clamp west and east values
-   *
-   * @param      {number}  [west=this.west]  The min west
-   * @param      {number}  [east=this.east]  The max east
-   * @return     {Extent}  this extent
-   */
-  clampWestEast() {
-    let west = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.west;
-    let east = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.east;
-    this.west = Math.max(this.west, west);
-    this.east = Math.min(this.east, east);
-    return this;
-  }
-  /**
-   * clamp this extent by passed extent
-   *
-   * @param      {Extent}  extent  The maximum extent.
-   * @return     {Extent}  this extent.
-   */
-  clampByExtent(extent) {
-    this.clampSouthNorth(extent.south, extent.north);
-    return this.clampWestEast(extent.west, extent.east);
-  }
-}
-_extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
-export default Extent;

package/lib/Core/Geographic/GeoidGrid.js

@@ -1,109 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from "./Coordinates.js";
-import CRS from "./Crs.js";
-const coord = new Coordinates('EPSG:4326');
-const indexes = new THREE.Vector2();
-function biLinearInterpolation(indexes, getData) {
-  const j = Math.floor(indexes.x);
-  const i = Math.floor(indexes.y);
-  const u = indexes.x - j;
-  const v = indexes.y - i;
-  return (1 - u) * ((1 - v) * getData(i, j) + v * getData(i + 1, j)) + u * ((1 - v) * getData(i, j + 1) + v * getData(i + 1, j + 1));
-}
-
-/**
- * An instance of `GeoidGrid` allows accessing some geoid height grid data from geographic instances (like some
- * {@link Coordinates}). The geoid height grid data must contain geoid height values for a set of geographic points
- * regularly dispatched on a planar surface.
- *
- * @property    {Extent}        extent      The geographic extent of the geoid height grid data.
- * @property    {THREE.Vector2} step        The distance between two consecutive points of the geoid height grid. The
- * `x` value stands for the distance along the West-East direction, and the
- * `y` value stands for the distance along the South-North direction.
- * @property    {THREE.Vector2} dimensions  The planar dimensions of the geoid height grid data extent.
- * @property    {THREE.Vector2} dataSize    The number of values in the gridded data along the West-East direction (`x`
-                                            * axis) and the South-North direction (`y` axis).
- *
- * @example
- * // Create a set of gridded data.
- * const data = [
- *     [1, 2, 3],
- *     [2, 3, 4],
- *     [3, 4, 5],
- * ];
- * // This set of data presents the following spatial distribution of geoid heights values :
- * //
- * //    Latitudes  ^
- * //               |
- * //         41.0  |   3  4  5
- * //         40.5  |   2  3  4
- * //         40.0  |   1  2  3
- * //               |------------->
- * //                   1  2  3     Longitudes
- *
- * // Create a GeoidGrid allowing to access the gridded data.
- * const geoidGrid = new GeoidGrid(
- *     new Extent('EPSG:4326', 1, 3, 40, 41),
- *     new THREE.Vector2(1, 0.5),
- *     (verticalIndex, horizontalIndex) => data[verticalIndex][horizontalIndex],
- * );
- *
- * // Access a value of geoid height at some geographic coordinates.
- * // The value is interpolated from the gridded data.
- * const value = geoidGrid.getHeightAtCoordinates(
- *     new Coordinates('EPSG:4326', 1.5, 40.25)
- * );
- * // This should return 2.0, which is the result from the bi-linear
- * // interpolation at the center of the `[[1, 2], [2, 3]]` subsection
- * // of the grid data.
- */
-class GeoidGrid {
-  /**
-   * @param   {Extent}        extent      The geographic extent of the geoid height grid data.
-   * @param   {THREE.Vector2} step        The distance between two consecutive points of the geoid height grid. The
-   * `x` value stands for the distance along the West-East direction, and the
-   * `y` value stands for the distance along the South-North direction.
-   * @param   {function}      getData     A method that allows reading a value in the geoid height grid from its
-   * vertical and horizontal indexes. The lower an index, the lower the
-   * coordinate on the corresponding axis - 0 being the index of the minimal
-   * coordinate of the gridded data on a given axis. In other words :
-   * - `getData(0, 0)` must return the geoid height value at the SOUTH-WEST
-   *   corner of your data extent.
-   * - `getData(0, j)` must return a geoid height on the southern limit of your
-   *   data extent.
-   * - `getData(i, 0)` must return a geoid height on the western limit of your
-   *   data extent.
-   * - if your gridded data has dimensions (rowNumber, colNumber),
-   *   `getData(rowNumber - 1, colNumber - 1)` must return the geoid height at
-   *   the NORTH-EAST corner of your data extent.
-   */
-  constructor(extent, step, getData) {
-    CRS.isGeographic(extent.crs);
-    this.extent = extent;
-    this.step = new THREE.Vector2(step.x, step.y || step.x);
-    this.dimensions = this.extent.planarDimensions();
-    this.dataSize = new THREE.Vector2().addVectors(this.step, this.dimensions).divide(this.step).round();
-    this.getData = getData;
-  }
-
-  /**
-   * Get the value of the geoid height at given geographic {@link Coordinates}. The geoid height value is
-   * bi-linearly interpolated from the gridded data accessed by the `GeoidGrid` instance.
-   *
-   * @param   {Coordinates}   coordinates     Geographic coordinates to get the geoid height value at.
-   *
-   * @returns {number}    The geoid height value at the given {@link Coordinates}, bi-interpolated from the gridded
-                          * data accessed by the `GeoidGrid` instance.
-   */
-  getHeightAtCoordinates(coordinates) {
-    coordinates.as(this.extent.crs, coord);
-    indexes.set((this.dataSize.x - 1) * (coord.x - this.extent.west) / this.dimensions.x, (this.dataSize.y - 1) * (coord.y - this.extent.south) / this.dimensions.y);
-
-    // TODO : add management for global GeoidGrid.
-    if (indexes.x < 0 || indexes.x >= this.dataSize.x - 1 || indexes.y < 0 || indexes.y >= this.dataSize.y - 1) {
-      return 0;
-    }
-    return biLinearInterpolation(indexes, this.getData);
-  }
-}
-export default GeoidGrid;