itowns 2.44.3-next.3 → 2.44.3-next.30

package/lib/Core/Geographic/Extent.js

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
+import * as CRS from "./Crs.js";
 import Coordinates from "./Coordinates.js";
-import CRS from "./Crs.js";
 
 /**
  * Extent is a SIG-area (so 2D)
@@ -9,82 +9,34 @@ import CRS from "./Crs.js";
 
 const _dim = new THREE.Vector2();
 const _dim2 = new THREE.Vector2();
-const _countTiles = new THREE.Vector2();
 const _box = new THREE.Box3();
-const tmsCoord = new THREE.Vector2();
-const dimensionTile = new THREE.Vector2();
 const defaultScheme = new THREE.Vector2(2, 2);
-const r = {
-  row: 0,
-  col: 0,
-  invDiff: 0
-};
 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();
-function _rowColfromParent(extent, zoom) {
-  const diffLevel = extent.zoom - zoom;
-  const diff = 2 ** diffLevel;
-  r.invDiff = 1 / diff;
-  r.row = (extent.row - extent.row % diff) * r.invDiff;
-  r.col = (extent.col - extent.col % diff) * r.invDiff;
-  return r;
-}
+
+/** @type {Extent} */
 let _extent;
-let _extent2;
 const cardinals = new Array(8);
 for (let i = cardinals.length - 1; i >= 0; i--) {
-  cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0, 0);
+  cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0);
 }
 const _c = new Coordinates('EPSG:4326', 0, 0);
-
-/** @private */
-export const globalExtentTMS = new Map();
-/** @private */
-export const schemeTiles = new Map();
-function getInfoTms(crs) {
-  const epsg = CRS.formatToEPSG(crs);
-  const globalExtent = globalExtentTMS.get(epsg);
-  const globalDimension = globalExtent.planarDimensions(_dim2);
-  const tms = CRS.formatToTms(crs);
-  const sTs = schemeTiles.get(tms) || schemeTiles.get('default');
-  // The isInverted parameter is to be set to the correct value, true or false
-  // (default being false) if the computation of the coordinates needs to be
-  // inverted to match the same scheme as OSM, Google Maps or other system.
-  // See link below for more information
-  // https://alastaira.wordpress.com/2011/07/06/converting-tms-tile-coordinates-to-googlebingosm-tile-coordinates/
-  // in crs includes ':NI' => tms isn't inverted (NOT INVERTED)
-  const isInverted = !tms.includes(':NI');
-  return {
-    epsg,
-    globalExtent,
-    globalDimension,
-    sTs,
-    isInverted
-  };
-}
-function getCountTiles(crs, zoom) {
-  const sTs = schemeTiles.get(CRS.formatToTms(crs)) || schemeTiles.get('default');
-  const count = 2 ** zoom;
-  _countTiles.set(count, count).multiply(sTs);
-  return _countTiles;
-}
 class Extent {
   /**
    * 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
-   * west-south corner or object {west, east, south and north}
-   * @param {number|Coordinates} [v1] east value, row value or Coordinates of
+   * @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 or column value
+   * @param {number} [v2] south value
    * @param {number} [v3] north value
    */
   constructor(crs, v0, v1, v2, v3) {
@@ -93,17 +45,10 @@ class Extent {
     }
     this.isExtent = true;
     this.crs = crs;
-    // Scale/zoom
-    this.zoom = 0;
-    if (CRS.isTms(this.crs)) {
-      this.row = 0;
-      this.col = 0;
-    } else {
-      this.west = 0;
-      this.east = 0;
-      this.south = 0;
-      this.north = 0;
-    }
+    this.west = 0;
+    this.east = 0;
+    this.south = 0;
+    this.north = 0;
     this.set(v0, v1, v2, v3);
   }
 
@@ -112,126 +57,48 @@ class Extent {
    * @return {Extent} cloned extent
    */
   clone() {
-    if (CRS.isTms(this.crs)) {
-      return new Extent(this.crs, this.zoom, this.row, this.col);
-    } else {
-      return new Extent(this.crs, this.west, this.east, this.south, this.north);
-    }
-  }
-
-  /**
-   * get tiled extents convering this extent
-   *
-   * @param      {string}  crs WMTS, TMS crs
-   * @return     {Array<Extent>}   array of extents covering
-   */
-  tiledCovering(crs) {
-    if (this.crs == 'EPSG:4326' && crs == CRS.tms_3857) {
-      const extents_WMTS_PM = [];
-      const extent = _extent.copy(this).as(CRS.formatToEPSG(crs), _extent2);
-      const {
-        globalExtent,
-        globalDimension,
-        sTs
-      } = getInfoTms(CRS.formatToEPSG(crs));
-      extent.clampByExtent(globalExtent);
-      extent.planarDimensions(dimensionTile);
-      const zoom = this.zoom + 1 || Math.floor(Math.log2(Math.round(globalDimension.x / (dimensionTile.x * sTs.x))));
-      const countTiles = getCountTiles(crs, zoom);
-      const center = extent.center(_c);
-      tmsCoord.x = center.x - globalExtent.west;
-      tmsCoord.y = globalExtent.north - extent.north;
-      tmsCoord.divide(globalDimension).multiply(countTiles).floor();
-
-      // ]N; N+1] => N
-      const maxRow = Math.ceil((globalExtent.north - extent.south) / globalDimension.x * countTiles.y) - 1;
-      for (let r = maxRow; r >= tmsCoord.y; r--) {
-        extents_WMTS_PM.push(new Extent(crs, zoom, r, tmsCoord.x));
-      }
-      return extents_WMTS_PM;
-    } else {
-      const target = new Extent(crs, 0, 0, 0);
-      const {
-        globalExtent,
-        globalDimension,
-        sTs,
-        isInverted
-      } = getInfoTms(this.crs);
-      const center = this.center(_c);
-      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)
-      const zoom = Math.floor(Math.log2(Math.round(globalDimension.x / (dimensionTile.x * sTs.x))));
-      const countTiles = getCountTiles(crs, zoom);
-
-      // Now that we have computed zoom, we can deduce x and y (or row / column)
-      tmsCoord.x = center.x - globalExtent.west;
-      tmsCoord.y = isInverted ? globalExtent.north - center.y : center.y - globalExtent.south;
-      tmsCoord.divide(globalDimension).multiply(countTiles).floor();
-      target.set(zoom, tmsCoord.y, tmsCoord.x);
-      return [target];
-    }
+    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.
+   * @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 (CRS.isTms(this.crs)) {
-      const {
-        epsg,
-        globalExtent,
-        globalDimension
-      } = getInfoTms(this.crs);
-      const countTiles = getCountTiles(this.crs, this.zoom);
-      dimensionTile.set(1, 1).divide(countTiles).multiply(globalDimension);
-      target.west = globalExtent.west + (globalDimension.x - dimensionTile.x * (countTiles.x - this.col));
-      target.east = target.west + dimensionTile.x;
-      target.south = globalExtent.south + dimensionTile.y * (countTiles.y - this.row - 1);
-      target.north = target.south + dimensionTile.y;
-      target.crs = epsg;
-      target.zoom = this.zoom;
-      return crs == epsg ? target : target.as(crs, target);
-    } else if (CRS.isEpsg(crs)) {
-      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.zoom = this.zoom;
-        target.crs = crs;
-        return target;
+    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;
-      target.zoom = this.zoom;
-      target.set(this.west, this.east, this.south, this.north);
       return target;
     }
+    target.crs = crs;
+    target.set(this.west, this.east, this.south, this.north);
+    return target;
   }
 
   /**
@@ -241,9 +108,6 @@ class Extent {
    */
   center() {
     let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Coordinates(this.crs);
-    if (CRS.isTms(this.crs)) {
-      throw new Error('Invalid operation for WMTS bbox');
-    }
     this.planarDimensions(_dim);
     target.crs = this.crs;
     target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);
@@ -352,20 +216,9 @@ class Extent {
    * @return {boolean}
    */
   isInside(extent, epsilon) {
-    if (CRS.isTms(this.crs)) {
-      if (this.zoom == extent.zoom) {
-        return this.row == extent.row && this.col == extent.col;
-      } else if (this.zoom < extent.zoom) {
-        return false;
-      } else {
-        _rowColfromParent(this, extent.zoom);
-        return r.row == extent.row && r.col == extent.col;
-      }
-    } else {
-      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;
-    }
+    extent.as(this.crs, _extent);
+    epsilon = epsilon ?? CRS.reasonableEpsilon(this.crs);
+    return this.east - _extent.east <= epsilon && _extent.west - this.west <= epsilon && this.north - _extent.north <= epsilon && _extent.south - this.south <= epsilon;
   }
 
   /**
@@ -380,10 +233,6 @@ class Extent {
     if (this.crs != extent.crs) {
       throw new Error('unsupported mix');
     }
-    if (CRS.isTms(this.crs)) {
-      _rowColfromParent(this, extent.zoom);
-      return target.set(this.col * r.invDiff - r.col, this.row * r.invDiff - r.row, r.invDiff, r.invDiff);
-    }
     extent.planarDimensions(_dim);
     this.planarDimensions(_dim2);
     const originX = (this.west - extent.west) / _dim.x;
@@ -393,21 +242,6 @@ class Extent {
     return target.set(originX, originY, scaleX, scaleY);
   }
 
-  /**
-   * Return parent tiled extent with input level
-   *
-   * @param {number} levelParent level of parent.
-   * @return {Extent}
-   */
-  tiledExtentParent(levelParent) {
-    if (levelParent && levelParent < this.zoom) {
-      _rowColfromParent(this, levelParent);
-      return new Extent(this.crs, levelParent, r.row, r.col);
-    } else {
-      return this;
-    }
-  }
-
   /**
    * Return true if this bounding box intersect with the bouding box parameter
    * @param {Extent} extent
@@ -416,7 +250,7 @@ class Extent {
   intersectsExtent(extent) {
     return Extent.intersectsExtent(this, extent);
   }
-  static intersectsExtent(extentA, extentB) {
+  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);
@@ -425,7 +259,7 @@ class Extent {
   /**
    * Return the intersection of this extent with another one
    * @param {Extent} extent
-   * @returns {Boolean}
+   * @returns {Extent}
    */
   intersect(extent) {
     if (!this.intersectsExtent(extent)) {
@@ -439,12 +273,11 @@ class Extent {
 
   /**
    * Set west, east, south and north values.
-   * Or if tiled extent, set zoom, row and column values
    *
    * @param {number|Array.<number>|Coordinates|Object|Extent} v0 west value,
-   * zoom 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}
+   * 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
@@ -457,22 +290,12 @@ class Extent {
       throw new Error('No values to set in the extent');
     }
     if (v0.isExtent) {
-      if (CRS.isTms(v0.crs)) {
-        v1 = v0.row;
-        v2 = v0.col;
-        v0 = v0.zoom;
-      } else {
-        v1 = v0.east;
-        v2 = v0.south;
-        v3 = v0.north;
-        v0 = v0.west;
-      }
+      v1 = v0.east;
+      v2 = v0.south;
+      v3 = v0.north;
+      v0 = v0.west;
     }
-    if (CRS.isTms(this.crs)) {
-      this.zoom = v0;
-      this.row = v1;
-      this.col = v2;
-    } else if (v0.isCoordinates) {
+    if (v0.isCoordinates) {
       // seem never used
       this.west = v0.x;
       this.east = v1.x;
@@ -605,11 +428,7 @@ class Extent {
    */
   toString() {
     let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    if (CRS.isTms(this.crs)) {
-      return `${this.zoom}${separator}${this.row}${separator}${this.col}`;
-    } else {
-      return `${this.east}${separator}${this.north}${separator}${this.west}${separator}${this.south}`;
-    }
+    return `${this.east}${separator}${this.north}${separator}${this.west}${separator}${this.south}`;
   }
 
   /**
@@ -625,7 +444,7 @@ class Extent {
   /**
    * subdivise extent by scheme.x on west-east and scheme.y on south-north.
    *
-   * @param      {Vector2}  [scheme=Vector2(2,2)]  The scheme to subdivise.
+   * @param      {THREE.Vector2}  [scheme=Vector2(2,2)]  The scheme to subdivise.
    * @return     {Array<Extent>}   subdivised extents.
    */
   subdivisionByScheme() {
@@ -649,25 +468,23 @@ class Extent {
    * @return     {Extent}  return this extent instance.
    */
   applyMatrix4(matrix) {
-    if (!CRS.isTms(this.crs)) {
-      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;
+    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;
   }
 
   /**
@@ -711,16 +528,4 @@ class Extent {
   }
 }
 _extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
-_extent2 = new Extent('EPSG:4326', [0, 0, 0, 0]);
-globalExtentTMS.set('EPSG:4326', new Extent('EPSG:4326', -180, 180, -90, 90));
-
-// Compute global extent of TMS in EPSG:3857
-// It's square whose a side is between -180° to 180°.
-// So, west extent, it's 180 convert in EPSG:3857
-const extent3857 = globalExtentTMS.get('EPSG:4326').as('EPSG:3857');
-extent3857.clampSouthNorth(extent3857.west, extent3857.east);
-globalExtentTMS.set('EPSG:3857', extent3857);
-schemeTiles.set('default', new THREE.Vector2(1, 1));
-schemeTiles.set(CRS.tms_3857, schemeTiles.get('default'));
-schemeTiles.set(CRS.tms_4326, new THREE.Vector2(2, 1));
 export default Extent;

package/lib/Core/Geographic/GeoidGrid.js

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
+import * as CRS from "./Crs.js";
 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) {

package/lib/Core/Math/Ellipsoid.js

@@ -1,9 +1,26 @@
 import * as THREE from 'three';
 import proj4 from 'proj4';
 import Coordinates from "../Geographic/Coordinates.js";
+
+/**
+ * Length of the semi-axes of the WGS84 ellipsoid.
+ * @internal
+ */
 export const ellipsoidSizes = new THREE.Vector3(proj4.WGS84.a, proj4.WGS84.a, proj4.WGS84.b);
 const normal = new THREE.Vector3();
 class Ellipsoid {
+  /**
+   * Length of the semi-axes of the ellipsoid.
+   */
+
+  /**
+   * Eccentricity of the ellipsoid.
+   */
+
+  /**
+   * @param size - Length of the semi-axes of the ellipsoid. Defaults to those
+   * defined by the WGS84 ellipsoid.
+   */
   constructor() {
     let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ellipsoidSizes;
     this.size = new THREE.Vector3();
@@ -12,10 +29,28 @@ class Ellipsoid {
     this.eccentricity = 0;
     this.setSize(size);
   }
+
+  /**
+   * Computes the normal vector to an ellipsoid at the given cartesian
+   * coordinate `(x, y, z)`.
+   *
+   * @param cartesian - The given cartesian coordinate.
+   * @param target - An object to store this vector to. If this is not
+   * specified, a new vector will be created.
+   */
   geodeticSurfaceNormal(cartesian) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
     return cartesian.toVector3(target).multiply(this._invRadiiSquared).normalize();
   }
+
+  /**
+   * Computes the normal vector to an ellipsoid at the given geographic
+   * coordinate `(longitude, latitude, altitude)`.
+   *
+   * @param coordCarto - The given geographic coordinate.
+   * @param target - An object to store this vector to. If this is not
+   * specified, a new vector will be created.
+   */
   geodeticSurfaceNormalCartographic(coordCarto) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
     const longitude = THREE.MathUtils.degToRad(coordCarto.longitude);
@@ -23,13 +58,22 @@ class Ellipsoid {
     const cosLatitude = Math.cos(latitude);
     return target.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude));
   }
+
+  /**
+   * Sets the length of the semi-axes of this ellipsoid from a 3-dimensional
+   * vector-like object. The object shall have both `x`, `y` and `z`
+   * properties.
+   *
+   * @param size - The source vector.
+   */
   setSize(size) {
     this.size.set(size.x, size.y, size.z);
     this._radiiSquared.multiplyVectors(size, size);
-    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._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;
+    return this;
   }
   cartographicToCartesian(coordCarto) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
@@ -42,18 +86,18 @@ class Ellipsoid {
   }
 
   /**
-   * Convert cartesian coordinates to geographic according to the current ellipsoid of revolution.
-   * @param {Object} position - The coordinate to convert
-   * @param {number} position.x
-   * @param {number} position.y
-   * @param {number} position.z
-   * @param {Coordinate} [target] coordinate to copy result
-   * @returns {Coordinate} an object describing the coordinates on the reference ellipsoid, angles are in degree
+   * Convert cartesian coordinates to geographic according to the current
+   * ellipsoid of revolution.
+   * @param position - The coordinate to convert
+   * @param target - coordinate to copy result
+   * @returns an object describing the coordinates on the reference ellipsoid,
+   * angles are in degree
    */
   cartesianToCartographic(position) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Coordinates('EPSG:4326', 0, 0, 0);
     // for details, see for example http://www.linz.govt.nz/data/geodetic-system/coordinate-conversion/geodetic-datum-conversions/equations-used-datum
-    // TODO the following is only valable for oblate ellipsoid of revolution. do we want to support triaxial ellipsoid?
+    // TODO the following is only valable for oblate ellipsoid of
+    // revolution. do we want to support triaxial ellipsoid?
     const R = Math.sqrt(position.x * position.x + position.y * position.y + position.z * position.z);
     const a = this.size.x; // x
     const b = this.size.z; // z
@@ -92,9 +136,9 @@ class Ellipsoid {
     const t1 = (-b + d) / (2 * a);
     const t2 = (-b - d) / (2 * a);
     if (t1 <= EPSILON && t2 <= EPSILON) {
+      // both intersections are behind the ray origin
       return false;
-    } // both intersections are behind the ray origin
-    // var back = (t1 <= EPSILON || t2 <= EPSILON); // If only one intersection (t>0) then we are inside the ellipsoid and the intersection is at the back of the ellipsoid
+    }
     let t = 0;
     if (t1 <= EPSILON) {
       t = t2;
@@ -111,19 +155,16 @@ class Ellipsoid {
     inter.addVectors(ray.origin, dir.clone().setLength(t));
     return inter;
   }
-  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 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.
+   * @param coordCarto1 - The coordinate carto 1
+   * @param coordCarto2 - The coordinate carto 2
+   * @returns The orthodromic distance between the two given coordinates.
    */
   geodesicDistance(coordCarto1, coordCarto2) {
     // The formula uses the distance on approximated sphere,

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

@@ -1,9 +1,3 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-
 import * as THREE from 'three';
 import GeometryLayer from "../../../Layer/GeometryLayer.js";
 import Coordinates from "../../Geographic/Coordinates.js";
@@ -31,6 +25,10 @@ const colorSky = new THREE.Color();
 const spaceColor = new THREE.Color(0x030508);
 const limitAlti = 600000;
 const mfogDistance = ellipsoidSizes.x * 160.0;
+
+/**
+ * @extends GeometryLayer
+ */
 class Atmosphere extends GeometryLayer {
   /**
   * It's layer to simulate Globe atmosphere.
@@ -40,8 +38,6 @@ class Atmosphere extends GeometryLayer {
   * * [Atmosphere Shader From Space (Atmospheric scattering)](http://stainlessbeer.weebly.com/planets-9-atmospheric-scattering.html)
   * * [Accurate Atmospheric Scattering (NVIDIA GPU Gems 2)](https://developer.nvidia.com/gpugems/gpugems2/part-ii-shading-lighting-and-shadows/chapter-16-accurate-atmospheric-scattering).
   *
-  * @extends GeometryLayer
-  *
   * @param {string} id - The id of the layer Atmosphere.
   * @param {Object} [options] - options layer.
   * @param {number} [options.Kr] - `Kr` is the rayleigh scattering constant.