itowns 2.35.0 → 2.37.0

package/lib/Core/Feature.js

@@ -7,7 +7,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.FeatureCollection = exports["default"] = exports.FeatureGeometry = exports.FeatureBuildingOptions = exports.FEATURE_TYPES = void 0;
+exports["default"] = exports.FeatureGeometry = exports.FeatureCollection = exports.FeatureBuildingOptions = exports.FEATURE_TYPES = void 0;
 
 var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 
@@ -57,6 +57,19 @@ function _extendBuffer(feature, size) {
   }
 }
 
+function _setGeometryValues(geom, feature, _long, lat, alt, normal) {
+  if (feature.normals) {
+    normal.toArray(feature.normals, feature._pos);
+  }
+
+  feature._pushValues(_long, lat, alt);
+
+  if (geom.size == 3) {
+    geom.altitude.min = Math.min(geom.altitude.min, alt);
+    geom.altitude.max = Math.max(geom.altitude.max, alt);
+  }
+}
+
 var coordOut = new _Coordinates["default"]('EPSG:4326', 0, 0, 0);
 var defaultNormal = new THREE.Vector3(0, 0, 1);
 var FEATURE_TYPES = {
@@ -68,25 +81,26 @@ exports.FEATURE_TYPES = FEATURE_TYPES;
 var typeToStyleProperty = ['point', 'stroke', 'fill'];
 /**
  * @property {string} crs - The CRS to convert the input coordinates to.
+ * @property {string} [structure='2d'] - data structure type : 2d or 3d.
+ * If the structure is 3d, the feature have 3 dimensions by vertices positions and
+ * a normal for each vertices.
  * @property {Extent|boolean} [filteringExtent=undefined] - Optional filter to reject
- * features outside of extent. Extent filetring is file extent if filteringExtent is true.
- * @property {boolean} [buildExtent=false] - If true the geometry will
+ * features outside of extent. Extent filtering is file extent if filteringExtent is true.
+ * @property {boolean} [buildExtent] - If true the geometry will
  * have an extent property containing the area covered by the geometry.
+ * Default value is false if `structure` parameter is set to '3d', and true otherwise.
  * True if the layer does not inherit from {@link GeometryLayer}.
  * @property {string} forcedExtentCrs - force feature extent crs if buildExtent is true.
  * @property {function} [filter] - Filter function to remove features
- * @property {boolean} [mergeFeatures=true] - If true all geometries are merged by type and multi-type
- * @property {string} [structure='2d'] - data structure type : 2d or 3d.
- * If the structure is 3d, the feature have 3 dimensions by vertices positions and
- * a normal for each vertices.
+ * @property {boolean} [mergeFeatures=true] - If true all geometries are merged by type and multi-type.
  * @property {Style} style - The style to inherit when creating
  * style for all new features.
  *
 */
 
-var FeatureBuildingOptions = function FeatureBuildingOptions() {
+var FeatureBuildingOptions = /*#__PURE__*/(0, _createClass2["default"])(function FeatureBuildingOptions() {
   (0, _classCallCheck2["default"])(this, FeatureBuildingOptions);
-};
+});
 /**
  * @property {Extent} extent - The 2D extent containing all the points
  * composing the geometry.
@@ -98,7 +112,6 @@ var FeatureBuildingOptions = function FeatureBuildingOptions() {
  * anything specified in the GeoJSON under the `properties` property.
  */
 
-
 exports.FeatureBuildingOptions = FeatureBuildingOptions;
 
 var FeatureGeometry = /*#__PURE__*/function () {
@@ -175,6 +188,12 @@ var FeatureGeometry = /*#__PURE__*/function () {
       var last = this.indices.length - 1;
       return this.indices[last];
     }
+  }, {
+    key: "baseAltitude",
+    value: function baseAltitude(feature, coordinates) {
+      var base_altitude = feature.style[typeToStyleProperty[feature.type]].base_altitude || 0;
+      return isNaN(base_altitude) ? base_altitude(this.properties, coordinates) : base_altitude;
+    }
     /**
      * Push new coordinates in vertices buffer.
      * @param {Coordinates} coordIn The coordinates to push.
@@ -184,30 +203,16 @@ var FeatureGeometry = /*#__PURE__*/function () {
   }, {
     key: "pushCoordinates",
     value: function pushCoordinates(coordIn, feature) {
-      if (this.size == 3) {
-        // set altitude from context
-        var base_altitude = feature.style[typeToStyleProperty[feature.type]].base_altitude;
-        coordIn.z = isNaN(base_altitude) ? base_altitude(this.properties, coordIn) : base_altitude;
-      }
-
+      coordIn.z = this.baseAltitude(feature, coordIn);
       coordIn.as(feature.crs, coordOut);
       feature.transformToLocalSystem(coordOut);
 
-      if (feature.normals) {
-        coordOut.geodesicNormal.toArray(feature.normals, feature._pos);
-      }
-
-      feature._pushValues(coordOut.x, coordOut.y, coordOut.z); // expand extent if present
+      _setGeometryValues(this, feature, coordOut.x, coordOut.y, coordOut.z, coordOut.geodesicNormal); // expand extent if present
 
 
       if (this._currentExtent) {
         this._currentExtent.expandByCoordinates(feature.useCrsOut ? coordOut : coordIn);
       }
-
-      if (this.size == 3) {
-        this.altitude.min = Math.min(this.altitude.min, coordIn.z);
-        this.altitude.max = Math.max(this.altitude.max, coordIn.z);
-      }
     }
     /**
      * Push new values coordinates in vertices buffer.
@@ -217,30 +222,20 @@ var FeatureGeometry = /*#__PURE__*/function () {
      * @param {Feature} feature - the feature containing the geometry
      * @param {number} long The longitude coordinate.
      * @param {number} lat The latitude coordinate.
-     * @param {number} [alt=0] The altitude coordinate.
      * @param {THREE.Vector3} [normal=THREE.Vector3(0,0,1)] the normal on coordinates.
      */
 
   }, {
     key: "pushCoordinatesValues",
-    value: function pushCoordinatesValues(feature, _long, lat) {
-      var alt = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-      var normal = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : defaultNormal;
-
-      if (feature.normals) {
-        normal.toArray(feature.normals, feature._pos);
-      }
+    value: function pushCoordinatesValues(feature, _long2, lat) {
+      var normal = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : defaultNormal;
+      var altitude = this.baseAltitude(feature);
 
-      feature._pushValues(_long, lat, alt); // expand extent if present
+      _setGeometryValues(this, feature, _long2, lat, altitude, normal); // expand extent if present
 
 
       if (this._currentExtent) {
-        this._currentExtent.expandByValuesCoordinates(_long, lat);
-      }
-
-      if (this.size == 3) {
-        this.altitude.min = Math.min(this.altitude.min, alt);
-        this.altitude.max = Math.max(this.altitude.max, alt);
+        this._currentExtent.expandByValuesCoordinates(_long2, lat);
       }
     }
     /**
@@ -469,7 +464,6 @@ var FeatureCollection = /*#__PURE__*/function (_THREE$Object3D) {
     _this.crs = _Crs["default"].formatToEPSG(options.crs);
     _this.features = [];
     _this.mergeFeatures = options.mergeFeatures === undefined ? true : options.mergeFeatures;
-    _this.extent = options.buildExtent ? defaultExtent(options.forcedExtentCrs || _this.crs) : undefined;
     _this.size = options.structure == '3d' ? 3 : 2;
     _this.filterExtent = options.filterExtent;
     _this.style = options.style;
@@ -478,6 +472,8 @@ var FeatureCollection = /*#__PURE__*/function (_THREE$Object3D) {
     _this.center = new _Coordinates["default"]('EPSG:4326', 0, 0);
 
     if (_this.size == 2) {
+      _this.extent = options.buildExtent === false ? undefined : defaultExtent(options.forcedExtentCrs || _this.crs);
+
       _this._setLocalSystem = function (center) {
         // set local system center
         center.as('EPSG:4326', _this.center); // set position to local system center
@@ -491,6 +487,8 @@ var FeatureCollection = /*#__PURE__*/function (_THREE$Object3D) {
 
       _this._transformToLocalSystem = transformToLocalSystem2D;
     } else {
+      _this.extent = options.buildExtent ? defaultExtent(options.forcedExtentCrs || _this.crs) : undefined;
+
       _this._setLocalSystem = function (center) {
         // set local system center
         center.as('EPSG:4326', _this.center);
@@ -686,6 +684,8 @@ var FeatureCollection = /*#__PURE__*/function (_THREE$Object3D) {
       ref.normals = feature.normals;
       ref.size = feature.size;
       ref.vertices = feature.vertices;
+      ref.altitude.min = feature.altitude.min;
+      ref.altitude.max = feature.altitude.max;
       ref._pos = feature._pos;
       this.features.push(ref);
       return ref;

package/lib/Core/Geographic/Coordinates.js

@@ -29,6 +29,10 @@ _proj["default"].defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs
 
 var ellipsoid = new _Ellipsoid["default"]();
 var projectionCache = {};
+var v0 = new THREE.Vector3();
+var v1 = new THREE.Vector3();
+var coord0;
+var coord1;
 
 function proj4cache(crsIn, crsOut) {
   if (!projectionCache[crsIn]) {
@@ -242,6 +246,56 @@ var Coordinates = /*#__PURE__*/function () {
       var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new THREE.Vector3();
       return target.copy(this);
     }
+    /**
+     * Calculate planar distance between this coordinates and `coord`.
+     * Planar distance is the straight-line euclidean distance calculated in a 2D cartesian coordinate system.
+     *
+     * @param  {Coordinates}  coord  The coordinate
+     * @return {number} planar distance
+     *
+     */
+
+  }, {
+    key: "planarDistanceTo",
+    value: function planarDistanceTo(coord) {
+      this.toVector3(v0).setZ(0);
+      coord.toVector3(v1).setZ(0);
+      return v0.distanceTo(v1);
+    }
+    /**
+     * Calculate geodetic distance between this coordinates and `coord`.
+     * **Geodetic distance** is calculated in an ellispoid space as the shortest distance
+     * across the curved surface of the world.
+     *
+     * => As the crow flies/ Orthodromy
+     *
+     * @param  {Coordinates}  coord  The coordinate
+     * @return {number} geodetic distance
+     *
+     */
+
+  }, {
+    key: "geodeticDistanceTo",
+    value: function geodeticDistanceTo(coord) {
+      this.as('EPSG:4326', coord0);
+      coord.as('EPSG:4326', coord1);
+      return ellipsoid.geodesicDistance(coord0, coord1);
+    }
+    /**
+     * Calculate earth euclidean distance between this coordinates and `coord`.
+     *
+     * @param  {Coordinates}  coord  The coordinate
+     * @return {number} earth euclidean distance
+     *
+     */
+
+  }, {
+    key: "spatialEuclideanDistanceTo",
+    value: function spatialEuclideanDistanceTo(coord) {
+      this.as('EPSG:4978', coord0).toVector3(v0);
+      coord.as('EPSG:4978', coord1).toVector3(v1);
+      return v0.distanceTo(v1);
+    }
     /**
      * Multiplies this `coordinates` (with an implicit 1 in the 4th dimension) and `mat`.
      *
@@ -302,5 +356,7 @@ var Coordinates = /*#__PURE__*/function () {
   return Coordinates;
 }();
 
+coord0 = new Coordinates('EPSG:4326', 0, 0, 0);
+coord1 = new Coordinates('EPSG:4326', 0, 0, 0);
 var _default = Coordinates;
 exports["default"] = _default;

package/lib/Core/Geographic/Crs.js

@@ -36,6 +36,12 @@ function is4326(crs) {
   return crs === 'EPSG:4326';
 }
 
+function isGeocentric(crs) {
+  var projection = _proj["default"].defs(crs);
+
+  return !projection ? false : projection.projName == 'geocent';
+}
+
 function _unitFromProj4Unit(projunit) {
   if (projunit === 'degrees') {
     return UNIT.DEGREE;
@@ -140,6 +146,15 @@ var _default = {
    */
   is4326: is4326,
 
+  /**
+   * Is the CRS geocentric ?
+   * if crs isn't defined the method returns false.
+   *
+   * @param {string} crs - The CRS to test.
+   * @return {boolean}
+   */
+  isGeocentric: isGeocentric,
+
   /**
    * Give a reasonnable epsilon to use with this CRS.
    *

package/lib/Core/Geographic/Extent.js

@@ -7,7 +7,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = exports.schemeTiles = exports.globalExtentTMS = void 0;
+exports.schemeTiles = exports.globalExtentTMS = exports["default"] = void 0;
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
@@ -33,6 +33,8 @@ var _dim2 = new THREE.Vector2();
 
 var _countTiles = new THREE.Vector2();
 
+var _box = new THREE.Box3();
+
 var tmsCoord = new THREE.Vector2();
 var dimensionTile = new THREE.Vector2();
 var defaultScheme = new THREE.Vector2(2, 2);
@@ -41,6 +43,9 @@ var r = {
   col: 0,
   invDiff: 0
 };
+var cNorthWest = new _Coordinates["default"]('EPSG:4326', 0, 0, 0);
+var cSouthWest = new _Coordinates["default"]('EPSG:4326', 0, 0, 0);
+var cNorthEast = new _Coordinates["default"]('EPSG:4326', 0, 0, 0);
 var southWest = new THREE.Vector3();
 var northEast = new THREE.Vector3();
 
@@ -74,7 +79,7 @@ function getInfoTms(crs) {
   var epsg = _Crs["default"].formatToEPSG(crs);
 
   var globalExtent = globalExtentTMS.get(epsg);
-  var globalDimension = globalExtent.dimensions(_dim2);
+  var globalDimension = globalExtent.planarDimensions(_dim2);
 
   var tms = _Crs["default"].formatToTms(crs);
 
@@ -109,6 +114,8 @@ var Extent = /*#__PURE__*/function () {
    * Extent is geographical bounding rectangle defined by 4 limits: west, east, south and north.
    * If crs is tiled projection (WMTS or TMS), the extent is defined by zoom, row and column.
    *
+   * 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, zoom
    * value, Array of values [west, east, south and north], Coordinates of
@@ -120,6 +127,11 @@ var Extent = /*#__PURE__*/function () {
    */
   function Extent(crs, v0, v1, v2, v3) {
     (0, _classCallCheck2["default"])(this, Extent);
+
+    if (_Crs["default"].isGeocentric(crs)) {
+      throw new Error("".concat(crs, " is a geocentric projection, it doesn't make sense with a geographical extent"));
+    }
+
     this.isExtent = true;
     this.crs = crs; // Scale/zoom
 
@@ -173,7 +185,7 @@ var Extent = /*#__PURE__*/function () {
             sTs = _getInfoTms.sTs;
 
         extent.clampByExtent(globalExtent);
-        extent.dimensions(dimensionTile);
+        extent.planarDimensions(dimensionTile);
         var zoom = this.zoom + 1 || Math.floor(Math.log2(Math.round(globalDimension.x / (dimensionTile.x * sTs.x))));
         var countTiles = getCountTiles(crs, zoom);
         var center = extent.center(_c);
@@ -199,7 +211,7 @@ var Extent = /*#__PURE__*/function () {
 
         var _center = this.center(_c);
 
-        this.dimensions(dimensionTile); // Each level has 2^n * 2^n tiles...
+        this.planarDimensions(dimensionTile); // Each level has 2^n * 2^n tiles...
         // ... so we count how many tiles of the same width as tile we can fit in the layer
         // ... 2^zoom = tilecount => zoom = log2(tilecount)
 
@@ -297,7 +309,7 @@ var Extent = /*#__PURE__*/function () {
         throw new Error('Invalid operation for WMTS bbox');
       }
 
-      this.dimensions(_dim);
+      this.planarDimensions(_dim);
       target.crs = this.crs;
       target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);
       return target;
@@ -314,10 +326,71 @@ var Extent = /*#__PURE__*/function () {
     key: "dimensions",
     value: function dimensions() {
       var 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
+     */
+
+  }, {
+    key: "planarDimensions",
+    value: function planarDimensions() {
+      var 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
+     */
+
+  }, {
+    key: "geodeticDimensions",
+    value: function geodeticDimensions() {
+      var 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
+     */
+
+  }, {
+    key: "spatialEuclideanDimensions",
+    value: function spatialEuclideanDimensions() {
+      var 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.
      *
@@ -394,8 +467,8 @@ var Extent = /*#__PURE__*/function () {
         return target.set(this.col * r.invDiff - r.col, this.row * r.invDiff - r.row, r.invDiff, r.invDiff);
       }
 
-      extent.dimensions(_dim);
-      this.dimensions(_dim2);
+      extent.planarDimensions(_dim);
+      this.planarDimensions(_dim2);
       var originX = (this.west - extent.west) / _dim.x;
       var originY = (extent.north - this.north) / _dim.y;
       var scaleX = _dim2.x / _dim.x;
@@ -609,9 +682,14 @@ var Extent = /*#__PURE__*/function () {
       }
     }
     /**
-     * Instance Extent with THREE.Box2
+     * 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.Box2} box
+     * @param {THREE.Box3} box
      * @return {Extent}
      */
 
@@ -657,7 +735,7 @@ var Extent = /*#__PURE__*/function () {
     value: function subdivisionByScheme() {
       var scheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultScheme;
       var subdivisedExtents = [];
-      var dimSub = this.dimensions(_dim).divide(scheme);
+      var dimSub = this.planarDimensions(_dim).divide(scheme);
 
       for (var x = scheme.x - 1; x >= 0; x--) {
         for (var y = scheme.y - 1; y >= 0; y--) {
@@ -680,8 +758,8 @@ var Extent = /*#__PURE__*/function () {
     key: "applyMatrix4",
     value: function applyMatrix4(matrix) {
       if (!_Crs["default"].isTms(this.crs)) {
-        southWest.set(this.west, this.south).applyMatrix4(matrix);
-        northEast.set(this.east, this.north).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;
@@ -752,6 +830,16 @@ var Extent = /*#__PURE__*/function () {
   }], [{
     key: "fromBox3",
     value: function fromBox3(crs, box) {
+      if (_Crs["default"].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,

package/lib/Core/Geographic/GeoidGrid.js

@@ -0,0 +1,143 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var THREE = _interopRequireWildcard(require("three"));
+
+var _Coordinates = _interopRequireDefault(require("./Coordinates"));
+
+var _Crs = _interopRequireDefault(require("./Crs"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var coord = new _Coordinates["default"]('EPSG:4326');
+var indexes = new THREE.Vector2();
+
+function biLinearInterpolation(indexes, getData) {
+  var j = Math.floor(indexes.x);
+  var i = Math.floor(indexes.y);
+  var u = indexes.x - j;
+  var 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.
+ */
+
+
+var GeoidGrid = /*#__PURE__*/function () {
+  /**
+   * @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.
+   */
+  function GeoidGrid(extent, step, getData) {
+    (0, _classCallCheck2["default"])(this, GeoidGrid);
+
+    _Crs["default"].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.
+   */
+
+
+  (0, _createClass2["default"])(GeoidGrid, [{
+    key: "getHeightAtCoordinates",
+    value: function 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);
+    }
+  }]);
+  return GeoidGrid;
+}();
+
+var _default = GeoidGrid;
+exports["default"] = _default;

package/lib/Core/MainLoop.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports["default"] = exports.MAIN_LOOP_EVENTS = exports.RENDERING_SCHEDULED = exports.RENDERING_PAUSED = void 0;
+exports["default"] = exports.RENDERING_SCHEDULED = exports.RENDERING_PAUSED = exports.MAIN_LOOP_EVENTS = void 0;
 
 var _three = require("three");