itowns 2.44.3-next.8 → 2.45.0

package/lib/Core/Label.js

@@ -1,222 +0,0 @@
-import * as THREE from 'three';
-import DEMUtils from "../Utils/DEMUtils.js";
-import Coordinates from "./Geographic/Coordinates.js";
-const coord = new Coordinates('EPSG:4326');
-let rect;
-
-// set it once
-let STYLE_TRANSFORM = '';
-if (document.documentElement.style.transform !== undefined) {
-  STYLE_TRANSFORM = 'transform';
-} else if (document.documentElement.style.webkitTransform !== undefined) {
-  STYLE_TRANSFORM = 'webkitTransform';
-} else if (document.documentElement.style.mozTransform !== undefined) {
-  STYLE_TRANSFORM = 'mozTransform';
-} else if (document.documentElement.style.oTransform !== undefined) {
-  STYLE_TRANSFORM = 'oTransform';
-} else {
-  STYLE_TRANSFORM = 'transform';
-}
-
-/**
- * An object that handles the display of a text and/or an icon, linked to a 3D
- * position. The content of the `Label` is managed through a DOM object, in a
- * `<div>` handled by the `Label2DRenderer`.
- *
- * @property {boolean} isLabel - Used to checkout whether this object is a
- * Label. Default is true. You should not change this, as it is used internally
- * for optimisation.
- * @property {Element} content - The DOM object that contains the content of the
- * label. The style and the position are applied on this object. All labels
- * contain the `itowns-label` class, as well as a specific class related to the
- * layer linked to it: `itowns-label-[layer-id]` (replace `[layer-id]` by the
- * correct string).
- * @property {THREE.Vector3} position - The position in the 3D world of the
- * label.
- * @property {number} padding - sets the padding area on all four sides of an element at once.
- * @property {Coordinates} coordinates - The coordinates of the label.
- * @property {number} order - Order of the label that will be read from the
- * style. It helps sorting and prioritizing a Label during render.
- */
-class Label extends THREE.Object3D {
-  /**
-   * @param {Element|string} content - The content; can be a
-   * string, with or without HTML tags in it, or it can be an Element.
-   * @param {Coordinates} coordinates - The world coordinates, where to place
-   * the Label.
-   * @param {Style} style - The style to apply to the content. Once the style
-   * is applied, it cannot be changed directly. However, if it really needed,
-   * it can be accessed through `label.content.style`, but it is highly
-   * discouraged to do so.
-   */
-  constructor() {
-    let content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-    let coordinates = arguments.length > 1 ? arguments[1] : undefined;
-    let style = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    if (coordinates == undefined) {
-      throw new Error('coordinates are mandatory to add a Label');
-    }
-    if (arguments.length > 3) {
-      console.warn('Deprecated argument sprites in Label constructor. Sprites must be configured in style argument.');
-    }
-    super();
-    let _visible = this.visible;
-    // can't do an ES6 setter/getter here
-    Object.defineProperty(this, 'visible', {
-      set(v) {
-        if (v != _visible) {
-          // avoid changing the style
-          _visible = v;
-          this.content.style.display = v ? 'block' : 'none';
-          // TODO: add smooth transition for fade in/out
-        }
-      },
-      get() {
-        return _visible;
-      }
-    });
-    this.isLabel = true;
-    this.coordinates = coordinates;
-    this.projectedPosition = {
-      x: 0,
-      y: 0
-    };
-    this.boundaries = {
-      left: 0,
-      right: 0,
-      top: 0,
-      bottom: 0
-    };
-    if (typeof content === 'string') {
-      this.content = document.createElement('div');
-      this.content.textContent = style.text.field;
-    } else {
-      this.content = content.cloneNode(true);
-    }
-    this.content.classList.add('itowns-label');
-    this.content.style.userSelect = 'none';
-    this.content.style.position = 'absolute';
-    if (style.isStyle) {
-      this.anchor = style.getTextAnchorPosition();
-      this.styleOffset = style.text.offset;
-      if (typeof content === 'string') {
-        if (style.text.haloWidth > 0) {
-          this.content.classList.add('itowns-stroke-single');
-        }
-        style.applyToHTML(this.content).then(icon => {
-          if (icon) {
-            // Not sure if that test is needed...
-            this.icon = icon;
-          }
-        });
-      }
-    } else {
-      this.anchor = [0, 0];
-      this.styleOffset = [0, 0];
-    }
-    this.iconOffset = {
-      left: 0,
-      right: 0,
-      top: 0,
-      bottom: 0
-    };
-    this.zoom = {
-      min: style.zoom && style.zoom.min != undefined ? style.zoom.min : 2,
-      max: style.zoom && style.zoom.max != undefined ? style.zoom.max : 24
-    };
-    this.order = style.order || 0;
-    // Padding value, to avoid labels being too close to each other.
-    this.padding = 2;
-  }
-
-  /**
-   * Moves a label on the screen, using screen coordinates. It updates the
-   * boundaries as it moves it.
-   *
-   * @param {number} x - X coordinates in pixels, from left.
-   * @param {number} y - Y coordinates in pixels, from top.
-   */
-  updateProjectedPosition(x, y) {
-    const X = Math.round(x);
-    const Y = Math.round(y);
-    if (X != this.projectedPosition.x || Y != this.projectedPosition.y) {
-      this.projectedPosition.x = X;
-      this.projectedPosition.y = Y;
-      this.boundaries.left = x + this.offset.left - this.padding;
-      this.boundaries.right = x + this.offset.right + this.padding;
-      this.boundaries.top = y + this.offset.top - this.padding;
-      this.boundaries.bottom = y + this.offset.bottom + this.padding;
-
-      // The boundaries of the label are the union of the boundaries of the text
-      // and the boundaries of the icon, if it exists.
-      // Checking if this.icon is not only zeros is mandatory, to prevent case
-      // when a boundary is set to x or y coordinate
-      if (this.iconOffset.left !== 0 || this.iconOffset.right !== 0 || this.iconOffset.top !== 0 || this.iconOffset.bottom !== 0) {
-        this.boundaries.left = Math.min(this.boundaries.left, x + this.iconOffset.left);
-        this.boundaries.right = Math.max(this.boundaries.right, x + this.iconOffset.right);
-        this.boundaries.top = Math.min(this.boundaries.top, y + this.iconOffset.top);
-        this.boundaries.bottom = Math.max(this.boundaries.bottom, y + this.iconOffset.bottom);
-      }
-    }
-  }
-  updateCSSPosition() {
-    // translate all content according to its given anchor
-    this.content.style[STYLE_TRANSFORM] = `translate(${this.projectedPosition.x + this.offset.left}px, ${this.projectedPosition.y + this.offset.top}px)`;
-
-    // translate possible icon inside content to cancel anchoring on it, so that it can later be positioned
-    // according to its own anchor
-    if (this.icon) {
-      this.icon.style[STYLE_TRANSFORM] = `translate(${-this.offset.left}px, ${-this.offset.top}px)`;
-    }
-  }
-
-  /**
-   * Updates the screen dimensions of the label, using
-   * `getBoundingClientRect`.  It updates `width` and `height` property of the
-   * label, and the boundaries.
-   */
-  initDimensions() {
-    if (!this.offset) {
-      rect = this.content.getBoundingClientRect();
-      const width = Math.round(rect.width);
-      const height = Math.round(rect.height);
-      this.offset = {
-        left: width * this.anchor[0] + this.styleOffset[0],
-        top: height * this.anchor[1] + this.styleOffset[1]
-      };
-      this.offset.right = this.offset.left + width;
-      this.offset.bottom = this.offset.top + height;
-      if (this.icon) {
-        rect = this.icon.getBoundingClientRect();
-        this.iconOffset = {
-          left: Math.floor(rect.x),
-          top: Math.floor(rect.y),
-          right: Math.ceil(rect.x + rect.width),
-          bottom: Math.ceil(rect.y + rect.height)
-        };
-      }
-    }
-  }
-  update3dPosition(crs) {
-    this.coordinates.as(crs, coord).toVector3(this.position);
-    this.updateMatrixWorld();
-  }
-  updateElevationFromLayer(layer, nodes) {
-    if (layer.attachedLayers.filter(l => l.isElevationLayer).length == 0) {
-      return;
-    }
-    let elevation = Math.max(0, DEMUtils.getElevationValueAt(layer, this.coordinates, DEMUtils.FAST_READ_Z, nodes));
-    if (isNaN(elevation)) {
-      elevation = Math.max(0, DEMUtils.getElevationValueAt(layer, this.coordinates, DEMUtils.FAST_READ_Z));
-    }
-    if (!isNaN(elevation) && elevation != this.coordinates.z) {
-      this.coordinates.z = elevation;
-    }
-  }
-  updateHorizonCullingPoint() {
-    if (this.horizonCullingPoint) {
-      this.getWorldPosition(this.horizonCullingPoint);
-    }
-  }
-}
-export default Label;

package/lib/Core/MainLoop.js

@@ -1,211 +0,0 @@
-import { EventDispatcher } from 'three';
-export const RENDERING_PAUSED = 0;
-export const RENDERING_SCHEDULED = 1;
-
-/**
- * MainLoop's update events list that are fired using
- * {@link View#execFrameRequesters}.
- *
- * @property UPDATE_START {string} fired at the start of the update
- * @property BEFORE_CAMERA_UPDATE {string} fired before the camera update
- * @property AFTER_CAMERA_UPDATE {string} fired after the camera update
- * @property BEFORE_LAYER_UPDATE {string} fired before the layer update
- * @property AFTER_LAYER_UPDATE {string} fired after the layer update
- * @property BEFORE_RENDER {string} fired before the render
- * @property AFTER_RENDER {string} fired after the render
- * @property UPDATE_END {string} fired at the end of the update
- */
-
-export const MAIN_LOOP_EVENTS = {
-  UPDATE_START: 'update_start',
-  BEFORE_CAMERA_UPDATE: 'before_camera_update',
-  AFTER_CAMERA_UPDATE: 'after_camera_update',
-  BEFORE_LAYER_UPDATE: 'before_layer_update',
-  AFTER_LAYER_UPDATE: 'after_layer_update',
-  BEFORE_RENDER: 'before_render',
-  AFTER_RENDER: 'after_render',
-  UPDATE_END: 'update_end'
-};
-function updateElements(context, geometryLayer, elements) {
-  if (!elements) {
-    return;
-  }
-  for (const element of elements) {
-    // update element
-    // TODO find a way to notify attachedLayers when geometryLayer deletes some elements
-    // and then update Debug.js:addGeometryLayerDebugFeatures
-    const newElementsToUpdate = geometryLayer.update(context, geometryLayer, element);
-    const sub = geometryLayer.getObjectToUpdateForAttachedLayers(element);
-    if (sub) {
-      if (sub.element) {
-        // update attached layers
-        for (const attachedLayer of geometryLayer.attachedLayers) {
-          if (attachedLayer.ready) {
-            attachedLayer.update(context, attachedLayer, sub.element, sub.parent);
-            attachedLayer.cache.flush();
-          }
-        }
-      } else if (sub.elements) {
-        for (let i = 0; i < sub.elements.length; i++) {
-          if (!sub.elements[i].isObject3D) {
-            throw new Error(`
-                            Invalid object for attached layer to update.
-                            Must be a THREE.Object and have a THREE.Material`);
-          }
-          // update attached layers
-          for (const attachedLayer of geometryLayer.attachedLayers) {
-            if (attachedLayer.ready) {
-              attachedLayer.update(context, attachedLayer, sub.elements[i], sub.parent);
-              attachedLayer.cache.flush();
-            }
-          }
-        }
-      }
-    }
-    updateElements(context, geometryLayer, newElementsToUpdate);
-  }
-}
-function filterChangeSources(updateSources, geometryLayer) {
-  let fullUpdate = false;
-  const filtered = new Set();
-  updateSources.forEach(src => {
-    if (src === geometryLayer || src.isCamera) {
-      geometryLayer.info.clear();
-      fullUpdate = true;
-    } else if (src.layer === geometryLayer) {
-      filtered.add(src);
-    }
-  });
-  return fullUpdate ? new Set([geometryLayer]) : filtered;
-}
-class MainLoop extends EventDispatcher {
-  #needsRedraw = false;
-  #updateLoopRestarted = true;
-  #lastTimestamp = 0;
-  constructor(scheduler, engine) {
-    super();
-    this.renderingState = RENDERING_PAUSED;
-    this.scheduler = scheduler;
-    this.gfxEngine = engine; // TODO: remove me
-  }
-  scheduleViewUpdate(view, forceRedraw) {
-    this.#needsRedraw |= forceRedraw;
-    if (this.renderingState !== RENDERING_SCHEDULED) {
-      this.renderingState = RENDERING_SCHEDULED;
-      // TODO Fix asynchronization between xr and MainLoop render loops.
-      // WebGLRenderer#setAnimationLoop must be used for WebXR projects.
-      // (see WebXR#initializeWebXR).
-      if (!this.gfxEngine.renderer.xr.isPresenting) {
-        requestAnimationFrame(timestamp => {
-          this.step(view, timestamp);
-        });
-      }
-    }
-  }
-  #update(view, updateSources, dt) {
-    const context = {
-      camera: view.camera,
-      engine: this.gfxEngine,
-      scheduler: this.scheduler,
-      view
-    };
-
-    // replace layer with their parent where needed
-    updateSources.forEach(src => {
-      const layer = src.layer || src;
-      if (layer.isLayer && layer.parent) {
-        updateSources.add(layer.parent);
-      }
-    });
-    for (const geometryLayer of view.getLayers((x, y) => !y)) {
-      context.geometryLayer = geometryLayer;
-      if (geometryLayer.ready && geometryLayer.visible && !geometryLayer.frozen) {
-        view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_LAYER_UPDATE, dt, this.#updateLoopRestarted, geometryLayer);
-
-        // Filter updateSources that are relevant for the geometryLayer
-        const srcs = filterChangeSources(updateSources, geometryLayer);
-        if (srcs.size > 0) {
-          // pre update attached layer
-          for (const attachedLayer of geometryLayer.attachedLayers) {
-            if (attachedLayer.ready && attachedLayer.preUpdate) {
-              attachedLayer.preUpdate(context, srcs);
-            }
-          }
-          // `preUpdate` returns an array of elements to update
-          const elementsToUpdate = geometryLayer.preUpdate(context, srcs);
-          // `update` is called in `updateElements`.
-          updateElements(context, geometryLayer, elementsToUpdate);
-          // `postUpdate` is called when this geom layer update process is finished
-          geometryLayer.postUpdate(context, geometryLayer, updateSources);
-        }
-
-        // Clear the cache of expired resources
-        geometryLayer.cache.flush();
-        view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_LAYER_UPDATE, dt, this.#updateLoopRestarted, geometryLayer);
-      }
-    }
-  }
-  step(view, timestamp) {
-    const dt = timestamp - this.#lastTimestamp;
-    view._executeFrameRequestersRemovals();
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_START, dt, this.#updateLoopRestarted);
-    const willRedraw = this.#needsRedraw;
-    this.#lastTimestamp = timestamp;
-
-    // Reset internal state before calling _update (so future calls to View.notifyChange()
-    // can properly change it)
-    this.#needsRedraw = false;
-    this.renderingState = RENDERING_PAUSED;
-    const updateSources = new Set(view._changeSources);
-    view._changeSources.clear();
-
-    // update camera
-    const dim = this.gfxEngine.getWindowSize();
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_CAMERA_UPDATE, dt, this.#updateLoopRestarted);
-    view.camera.update(dim.x, dim.y);
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_CAMERA_UPDATE, dt, this.#updateLoopRestarted);
-
-    // Disable camera's matrix auto update to make sure the camera's
-    // world matrix is never updated mid-update.
-    // Otherwise inconsistencies can appear because object visibility
-    // testing and object drawing could be performed using different
-    // camera matrixWorld.
-    // Note: this is required at least because WEBGLRenderer calls
-    // camera.updateMatrixWorld()
-    const oldAutoUpdate = view.camera3D.matrixAutoUpdate;
-    view.camera3D.matrixAutoUpdate = false;
-
-    // update data-structure
-    this.#update(view, updateSources, dt);
-    if (this.scheduler.commandsWaitingExecutionCount() == 0) {
-      this.dispatchEvent({
-        type: 'command-queue-empty'
-      });
-    }
-
-    // Redraw *only* if needed.
-    // (redraws only happen when this.#needsRedraw is true, which in turn only happens when
-    // view.notifyChange() is called with redraw=true)
-    // As such there's no continuous update-loop, instead we use a ad-hoc update/render
-    // mechanism.
-    if (willRedraw) {
-      this.#renderView(view, dt);
-    }
-
-    // next time, we'll consider that we've just started the loop if we are still PAUSED now
-    this.#updateLoopRestarted = this.renderingState === RENDERING_PAUSED;
-    view.camera3D.matrixAutoUpdate = oldAutoUpdate;
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.UPDATE_END, dt, this.#updateLoopRestarted);
-  }
-  #renderView(view, dt) {
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.BEFORE_RENDER, dt, this.#updateLoopRestarted);
-    if (view.render) {
-      view.render();
-    } else {
-      // use default rendering method
-      this.gfxEngine.renderView(view);
-    }
-    view.execFrameRequesters(MAIN_LOOP_EVENTS.AFTER_RENDER, dt, this.#updateLoopRestarted);
-  }
-}
-export default MainLoop;

package/lib/Core/Math/Ellipsoid.js

@@ -1,144 +0,0 @@
-import * as THREE from 'three';
-import proj4 from 'proj4';
-import Coordinates from "../Geographic/Coordinates.js";
-export const ellipsoidSizes = new THREE.Vector3(proj4.WGS84.a, proj4.WGS84.a, proj4.WGS84.b);
-const normal = new THREE.Vector3();
-class Ellipsoid {
-  constructor() {
-    let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ellipsoidSizes;
-    this.size = new THREE.Vector3();
-    this._radiiSquared = new THREE.Vector3();
-    this._invRadiiSquared = new THREE.Vector3();
-    this.eccentricity = 0;
-    this.setSize(size);
-  }
-  geodeticSurfaceNormal(cartesian) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
-    return cartesian.toVector3(target).multiply(this._invRadiiSquared).normalize();
-  }
-  geodeticSurfaceNormalCartographic(coordCarto) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
-    const longitude = THREE.MathUtils.degToRad(coordCarto.longitude);
-    const latitude = THREE.MathUtils.degToRad(coordCarto.latitude);
-    const cosLatitude = Math.cos(latitude);
-    return target.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude));
-  }
-  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.eccentricity = Math.sqrt(this._radiiSquared.x - this._radiiSquared.z) / this.size.x;
-  }
-  cartographicToCartesian(coordCarto) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector3();
-    normal.copy(coordCarto.geodesicNormal);
-    target.multiplyVectors(this._radiiSquared, normal);
-    const gamma = Math.sqrt(normal.dot(target));
-    target.divideScalar(gamma);
-    normal.multiplyScalar(coordCarto.altitude);
-    return target.add(normal);
-  }
-
-  /**
-   * 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
-   */
-  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?
-    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
-    const e = Math.abs((a * a - b * b) / (a * a));
-    const f = 1 - Math.sqrt(1 - e);
-    const rsqXY = Math.sqrt(position.x * position.x + position.y * position.y);
-    const theta = Math.atan2(position.y, position.x);
-    const nu = Math.atan(position.z / rsqXY * (1 - f + e * a / R));
-    const sinu = Math.sin(nu);
-    const cosu = Math.cos(nu);
-    const phi = Math.atan((position.z * (1 - f) + e * a * sinu * sinu * sinu) / ((1 - f) * (rsqXY - e * a * cosu * cosu * cosu)));
-    const h = rsqXY * Math.cos(phi) + position.z * Math.sin(phi) - a * Math.sqrt(1 - e * Math.sin(phi) * Math.sin(phi));
-    return target.setFromValues(THREE.MathUtils.radToDeg(theta), THREE.MathUtils.radToDeg(phi), h);
-  }
-  cartographicToCartesianArray(coordCartoArray) {
-    const cartesianArray = [];
-    for (let i = 0; i < coordCartoArray.length; i++) {
-      cartesianArray.push(this.cartographicToCartesian(coordCartoArray[i]));
-    }
-    return cartesianArray;
-  }
-  intersection(ray) {
-    const EPSILON = 0.0001;
-    const O_C = ray.origin;
-    const dir = ray.direction;
-    // normalizeVector( dir );
-
-    const a = dir.x * dir.x * this._invRadiiSquared.x + dir.y * dir.y * this._invRadiiSquared.y + dir.z * dir.z * this._invRadiiSquared.z;
-    const b = 2 * O_C.x * dir.x * this._invRadiiSquared.x + 2 * O_C.y * dir.y * this._invRadiiSquared.y + 2 * O_C.z * dir.z * this._invRadiiSquared.z;
-    const c = O_C.x * O_C.x * this._invRadiiSquared.x + O_C.y * O_C.y * this._invRadiiSquared.y + O_C.z * O_C.z * this._invRadiiSquared.z - 1;
-    let d = b * b - 4 * a * c;
-    if (d < 0 || a === 0 || b === 0 || c === 0) {
-      return false;
-    }
-    d = Math.sqrt(d);
-    const t1 = (-b + d) / (2 * a);
-    const t2 = (-b - d) / (2 * a);
-    if (t1 <= EPSILON && t2 <= EPSILON) {
-      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;
-    } else if (t2 <= EPSILON) {
-      t = t1;
-    } else {
-      t = t1 < t2 ? t1 : t2;
-    }
-    if (t < EPSILON) {
-      return false;
-    } // Too close to intersection
-
-    const inter = new THREE.Vector3();
-    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 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.
-   */
-  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
-    const longitude1 = THREE.MathUtils.degToRad(coordCarto1.longitude);
-    const latitude1 = THREE.MathUtils.degToRad(coordCarto1.latitude);
-    const longitude2 = THREE.MathUtils.degToRad(coordCarto2.longitude);
-    const latitude2 = THREE.MathUtils.degToRad(coordCarto2.latitude);
-    const distRad = Math.acos(Math.sin(latitude1) * Math.sin(latitude2) + Math.cos(latitude1) * Math.cos(latitude2) * Math.cos(longitude2 - longitude1));
-    const e = this.eccentricity;
-    const es = (e * Math.sin((latitude1 + latitude2) * 0.5)) ** 2;
-    const rho = this.size.x * (1 - e ** 2) / (1 - es) ** (3 / 2);
-    const N = this.size.x / Math.sqrt(1 - es);
-    return distRad * Math.sqrt(rho * N);
-  }
-}
-export default Ellipsoid;