itowns 2.34.0 → 2.36.2

package/lib/Converter/Feature2Texture.js

@@ -176,7 +176,7 @@ function drawPoint(ctx, x, y) {
 var coord = new _Coordinates["default"]('EPSG:4326', 0, 0, 0);
 
 function drawFeature(ctx, feature, extent, style, invCtxScale) {
-  var extentDim = extent.dimensions();
+  var extentDim = extent.planarDimensions();
   var scaleRadius = extentDim.x / ctx.canvas.width;
   var globals = {
     zoom: extent.zoom
@@ -259,7 +259,7 @@ var _default = {
     if (collection) {
       // A texture is instancied drawn canvas
       // origin and dimension are used to transform the feature's coordinates to canvas's space
-      extent.dimensions(dimension);
+      extent.planarDimensions(dimension);
       var c = document.createElement('canvas');
       coord.crs = extent.crs;
       c.width = sizeTexture;

package/lib/Converter/convertToTile.js

@@ -41,7 +41,7 @@ function setTileFromTiledLayer(tile, tileLayer) {
     // If the point is below the horizon,
     // the tile is guaranteed to be below the horizon as well.
     tile.horizonCullingPoint = tile.extent.center().as('EPSG:4978').toVector3();
-    tile.extent.dimensions(dimensions).multiplyScalar(THREE.MathUtils.DEG2RAD); // alpha is maximum angle between two points of tile
+    tile.extent.planarDimensions(dimensions).multiplyScalar(THREE.MathUtils.DEG2RAD); // alpha is maximum angle between two points of tile
 
     var alpha = dimensions.length();
     var h = Math.abs(1.0 / Math.cos(alpha * 0.5));

package/lib/Core/AnimationPlayer.js

@@ -98,6 +98,9 @@ var AnimationPlayer = /*#__PURE__*/function (_THREE$EventDispatche) {
     _this.duration = 0;
     _this.state = PLAYER_STATE.STOP;
     _this.waitTimer = null;
+
+    _this.callback = function () {};
+
     return _this;
   }
 
@@ -117,6 +120,17 @@ var AnimationPlayer = /*#__PURE__*/function (_THREE$EventDispatche) {
       return this.state === PLAYER_STATE.END;
     } // Public functions
 
+    /**
+     * Set the Player `callback` property. This callback is executed at each animation frame.
+     *
+     * @param {function} callback - The callback to execute at each animation frame.
+     */
+
+  }, {
+    key: "setCallback",
+    value: function setCallback(callback) {
+      this.callback = callback;
+    }
     /**
      * Play one animation.
      * If another animation is playing, it's stopped and the new animation is played.
@@ -177,6 +191,7 @@ var AnimationPlayer = /*#__PURE__*/function (_THREE$EventDispatche) {
         this.dispatchEvent({
           type: 'animation-frame'
         });
+        this.callback();
       } else {
         this.state = PLAYER_STATE.END;
         finishAnimation(this);

package/lib/Core/Feature.js

@@ -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,17 +81,18 @@ 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.
  *
@@ -175,6 +189,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 +204,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 +223,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;
+    value: function pushCoordinatesValues(feature, _long2, lat) {
+      var normal = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : defaultNormal;
+      var altitude = this.baseAltitude(feature);
 
-      if (feature.normals) {
-        normal.toArray(feature.normals, feature._pos);
-      }
-
-      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 +465,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 +473,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 +488,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 +685,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

@@ -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/Label.js

@@ -262,7 +262,7 @@ var Label = /*#__PURE__*/function (_THREE$Object3D) {
   }, {
     key: "updateElevationFromLayer",
     value: function updateElevationFromLayer(layer) {
-      var elevation = _DEMUtils["default"].getElevationValueAt(layer, this.coordinates, _DEMUtils["default"].FAST_READ_Z);
+      var elevation = Math.max(0, _DEMUtils["default"].getElevationValueAt(layer, this.coordinates, _DEMUtils["default"].FAST_READ_Z));
 
       if (elevation && elevation != this.coordinates.z) {
         this.coordinates.z = elevation;

package/lib/Core/Math/Ellipsoid.js

@@ -34,6 +34,7 @@ var Ellipsoid = /*#__PURE__*/function () {
     this.size = new THREE.Vector3();
     this._radiiSquared = new THREE.Vector3();
     this._invRadiiSquared = new THREE.Vector3();
+    this.eccentricity = 0;
     this.setSize(size);
   }
 
@@ -62,6 +63,7 @@ var Ellipsoid = /*#__PURE__*/function () {
       this._invRadiiSquared.x = size.x == 0 ? 0 : 1 / this._radiiSquared.x;
       this._invRadiiSquared.y = size.y == 0 ? 0 : 1 / this._radiiSquared.y;
       this._invRadiiSquared.z = size.z == 0 ? 0 : 1 / this._radiiSquared.z;
+      this.eccentricity = Math.sqrt(this._radiiSquared.x - this._radiiSquared.z) / this.size.x;
     }
   }, {
     key: "cartographicToCartesian",
@@ -165,19 +167,35 @@ var Ellipsoid = /*#__PURE__*/function () {
   }, {
     key: "computeDistance",
     value: function computeDistance(coordCarto1, coordCarto2) {
+      console.warn('computeDistance is renamed to geodesicDistance');
+      this.geodesicDistance(coordCarto1, coordCarto2);
+    }
+    /**
+     * Calculate the geodesic distance, between coordCarto1 and coordCarto2.
+     * It's most short distance on ellipsoid surface between coordCarto1 and coordCarto2.
+     * It's called orthodromy.
+     *
+     * @param      {Coordinates}  coordCarto1  The coordinate carto 1
+     * @param      {Coordinates}  coordCarto2  The coordinate carto 2
+     * @return     {number}  The orthodromic distance between the two given coordinates.
+     */
+
+  }, {
+    key: "geodesicDistance",
+    value: function geodesicDistance(coordCarto1, coordCarto2) {
+      // The formula uses the distance on approximated sphere,
+      // with the nearest local radius of curvature of the ellipsoid
+      // https://geodesie.ign.fr/contenu/fichiers/Distance_longitude_latitude.pdf
       var longitude1 = THREE.MathUtils.degToRad(coordCarto1.longitude);
       var latitude1 = THREE.MathUtils.degToRad(coordCarto1.latitude);
       var longitude2 = THREE.MathUtils.degToRad(coordCarto2.longitude);
       var latitude2 = THREE.MathUtils.degToRad(coordCarto2.latitude);
       var distRad = Math.acos(Math.sin(latitude1) * Math.sin(latitude2) + Math.cos(latitude1) * Math.cos(latitude2) * Math.cos(longitude2 - longitude1));
-      var a = this.size.x;
-      var b = this.size.z;
-      var e = Math.sqrt((a * a - b * b) / (a * a));
-      var latMoy = (latitude1 + latitude2) / 2;
-      var rho = a * (1 - e * e) / Math.sqrt(1 - e * e * Math.sin(latMoy) * Math.sin(latMoy));
-      var N = a / Math.sqrt(1 - e * e * Math.sin(latMoy) * Math.sin(latMoy));
-      var distMeter = distRad * Math.sqrt(rho * N);
-      return distMeter;
+      var e = this.eccentricity;
+      var es = Math.pow(e * Math.sin((latitude1 + latitude2) * 0.5), 2);
+      var rho = this.size.x * (1 - Math.pow(e, 2)) / Math.pow(1 - es, 3 / 2);
+      var N = this.size.x / Math.sqrt(1 - es);
+      return distRad * Math.sqrt(rho * N);
     }
   }]);
   return Ellipsoid;

package/lib/Core/Prefab/Globe/BuilderEllipsoidTile.js

@@ -79,7 +79,7 @@ var BuilderEllipsoidTile = /*#__PURE__*/function () {
         longitude: 0,
         latitude: 0
       };
-      params.extent.dimensions(this.tmp.dimension);
+      params.extent.planarDimensions(this.tmp.dimension);
     } // get center tile in cartesian 3D
 
   }, {

package/lib/Core/Prefab/PlanarView.js

@@ -81,7 +81,7 @@ var PlanarView = /*#__PURE__*/function (_View) {
     _this = _super.call(this, extent.crs, viewerDiv, options);
     _this.isPlanarView = true; // Configure camera
 
-    var dim = extent.dimensions();
+    var dim = extent.planarDimensions();
     var max = Math.max(dim.x, dim.y);
     var camera3D = _this.camera.camera3D;
     camera3D.near = 0.1;

package/lib/Core/Style.js

@@ -472,6 +472,7 @@ var Style = /*#__PURE__*/function () {
         mapPropertiesFromContext('icon', this, style, context);
       }
 
+      style.order = this.order;
       return style;
     }
     /**

package/lib/Core/TileMesh.js

@@ -113,10 +113,11 @@ var TileMesh = /*#__PURE__*/function (_THREE$Mesh) {
     value: function setBBoxZ(min, max, scale) {
       if (min == null && max == null) {
         return;
-      } // FIXME: Why the floors ? This is not conservative : the obb may be too short by almost 1m !
+      } // update bbox if min or max have changed by at least one decimal
+      // or if scale changed
 
 
-      if (Math.floor(min) !== Math.floor(this.obb.z.min) || Math.floor(max) !== Math.floor(this.obb.z.max)) {
+      if (min.toFixed(1) !== this.obb.z.min.toFixed(1) || max.toFixed(1) !== this.obb.z.max.toFixed(1) || scale != this.obb.z.scale) {
         this.obb.updateZ(min, max, scale);
 
         if (this.horizonCullingPointElevationScaled) {