@wemap/geo 2.7.9 → 3.0.0

package/index.js

@@ -2,18 +2,24 @@ import Constants from './src/Constants';
 import Utils from './src/Utils';
 
 import Attitude from './src/rotations/Attitude';
+import AbsoluteHeading from './src/rotations/AbsoluteHeading';
 
 import BoundingBox from './src/coordinates/BoundingBox';
+import GeoRelativePosition from './src/coordinates/GeoRelativePosition';
 import Level from './src/coordinates/Level';
-import WGS84 from './src/coordinates/WGS84';
-import WGS84UserPosition from './src/coordinates/WGS84UserPosition';
+import RelativePosition from './src/coordinates/RelativePosition';
+import Coordinates from './src/coordinates/Coordinates';
+import UserPosition from './src/coordinates/UserPosition';
 
 export {
+    AbsoluteHeading,
     Attitude,
     BoundingBox,
     Constants,
+    GeoRelativePosition,
     Level,
+    RelativePosition,
     Utils,
-    WGS84,
-    WGS84UserPosition
+    Coordinates,
+    UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "2.7.9",
+    "version": "3.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -27,11 +27,11 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^2.7.7",
-        "@wemap/maths": "^2.7.7",
+        "@wemap/logger": "^3.0.0",
+        "@wemap/maths": "^3.0.0",
         "lodash.isfinite": "^3.3.2",
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "a43db34e902c6c4d34051444bb385b82add08068"
+    "gitHead": "2bbb4840a99b90eaae989291cb728ac87cebade8"
 }

package/src/Utils.js

@@ -1,10 +1,10 @@
-import WGS84 from './coordinates/WGS84';
+import Coordinates from './coordinates/Coordinates';
 
 class Utils {
 
     /**
-     * Sample a route of WGS84
-     * @param {Array.<WGS84>} route ordered points
+     * Sample a route of Coordinates
+     * @param {Array.<Coordinates>} route ordered points
      * @param {*} stepSize step size to sample
      * @param {*} maxLength max route length to sample
      */

package/src/Utils.spec.js

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 
 import Utils from './Utils';
-import WGS84 from './coordinates/WGS84';
+import Coordinates from './coordinates/Coordinates';
 
 
 describe('Geo Utils', () => {
@@ -11,10 +11,10 @@ describe('Geo Utils', () => {
         let samples;
 
         const route = [
-            new WGS84(45.0, 5.0),
-            new WGS84(45.000735, 5.0007303),
-            new WGS84(45.000735, 5.0007303),
-            new WGS84(45.0003702, 5.0011008)
+            new Coordinates(45.0, 5.0),
+            new Coordinates(45.000735, 5.0007303),
+            new Coordinates(45.000735, 5.0007303),
+            new Coordinates(45.0003702, 5.0011008)
         ];
 
         samples = Utils.sampleRoute(route, 10);

package/src/coordinates/BoundingBox.js

@@ -1,4 +1,4 @@
-import WGS84 from './WGS84';
+import Coordinates from './Coordinates';
 import isNumber from 'lodash.isnumber';
 import isFinite from 'lodash.isfinite';
 
@@ -23,18 +23,18 @@ class BoundingBox {
     /**
      * Returns the geographical coordinate equidistant from the bounding box's corners.
      *
-     * @returns {WGS84} The bounding box's center.
+     * @returns {Coordinates} The bounding box's center.
      */
     get center() {
         const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
         const lngCenter = (this.northEast.lng + this.southWest.lng) / 2;
-        return new WGS84(latCenter, lngCenter);
+        return new Coordinates(latCenter, lngCenter);
     }
 
     /**
      * Check if a point is contained in the bounding box.
      *
-     * @returns {WGS84} The point to analyze.
+     * @returns {Coordinates} The point to analyze.
      */
     contains(point) {
         return point.lat <= this.northEast.lat
@@ -46,7 +46,7 @@ class BoundingBox {
     /**
      * Extend the bounds to include a given LngLat or LngLatBounds.
      *
-     * @param {WGS84|BoundingBox} obj object to extend to
+     * @param {Coordinates|BoundingBox} obj object to extend to
      * @returns {BoundingBox} `this`
      */
     extend(obj) {
@@ -54,7 +54,7 @@ class BoundingBox {
             ne = this.northEast;
         let sw2, ne2;
 
-        if (obj instanceof WGS84) {
+        if (obj instanceof Coordinates) {
             sw2 = obj;
             ne2 = obj;
 
@@ -70,15 +70,15 @@ class BoundingBox {
         }
 
         if (!sw && !ne) {
-            this.southWest = new WGS84(sw2.lat, sw2.lng);
-            this.northEast = new WGS84(ne2.lat, ne2.lng);
+            this.southWest = new Coordinates(sw2.lat, sw2.lng);
+            this.northEast = new Coordinates(ne2.lat, ne2.lng);
 
         } else {
-            this.southWest = new WGS84(
+            this.southWest = new Coordinates(
                 Math.min(sw2.lat, sw.lat),
                 Math.min(sw2.lng, sw.lng)
             );
-            this.northEast = new WGS84(
+            this.northEast = new Coordinates(
                 Math.max(ne2.lat, ne.lat),
                 Math.max(ne2.lng, ne.lng)
             );
@@ -112,7 +112,7 @@ class BoundingBox {
     /**
      * Returns the southwest corner of the bounding box.
      *
-     * @returns {WGS84} The southwest corner of the bounding box.
+     * @returns {Coordinates} The southwest corner of the bounding box.
      */
     getSouthWest() {
         return this.southWest;
@@ -121,7 +121,7 @@ class BoundingBox {
     /**
     * Returns the northeast corner of the bounding box.
     *
-    * @returns {WGS84} The northeast corner of the bounding box.
+    * @returns {Coordinates} The northeast corner of the bounding box.
      */
     getNorthEast() {
         return this.northEast;
@@ -130,10 +130,10 @@ class BoundingBox {
     /**
     * Returns the northwest corner of the bounding box.
     *
-    * @returns {WGS84} The northwest corner of the bounding box.
+    * @returns {Coordinates} The northwest corner of the bounding box.
      */
     getNorthWest() {
-        return new WGS84(this.getNorth(), this.getWest());
+        return new Coordinates(this.getNorth(), this.getWest());
     }
 
     /**
@@ -142,7 +142,7 @@ class BoundingBox {
     * @returns {LngLat} The southeast corner of the bounding box.
      */
     getSouthEast() {
-        return new WGS84(this.getSouth(), this.getEast());
+        return new Coordinates(this.getSouth(), this.getEast());
     }
 
     /**
@@ -182,8 +182,8 @@ class BoundingBox {
     }
 
     static equalsTo(bb1, bb2) {
-        return WGS84.equalsTo(bb1.northEast, bb2.northEast)
-            && WGS84.equalsTo(bb1.southWest, bb2.southWest);
+        return Coordinates.equalsTo(bb1.northEast, bb2.northEast)
+            && Coordinates.equalsTo(bb1.southWest, bb2.southWest);
     }
 
     equalsTo(other) {

package/src/coordinates/BoundingBox.spec.js

@@ -4,15 +4,15 @@ import chaiAlmost from 'chai-almost';
 
 import BoundingBox from './BoundingBox';
 import Logger from '@wemap/logger';
-import WGS84 from './WGS84';
+import Coordinates from './Coordinates';
 
 const expect = chai.expect;
 chai.use(chaiAlmost());
 Logger.enable(false);
 
 let boundingBox;
-const northEast = new WGS84(10, 40);
-const southWest = new WGS84(-5, -20);
+const northEast = new Coordinates(10, 40);
+const southWest = new Coordinates(-5, -20);
 
 const checkBounds = (bb, [north, east, south, west]) => {
     return north === bb.northEast.lat
@@ -28,7 +28,7 @@ describe('Bounding Box', () => {
         expect(boundingBox.northEast).is.null;
         expect(boundingBox.southWest).is.null;
 
-        expect(() => new BoundingBox(new WGS84(10, -20), new WGS84(-5, 40))).is.throw(Error);
+        expect(() => new BoundingBox(new Coordinates(10, -20), new Coordinates(-5, 40))).is.throw(Error);
 
         boundingBox = new BoundingBox(northEast, southWest);
         expect(boundingBox.northEast).equals(northEast);
@@ -39,16 +39,16 @@ describe('Bounding Box', () => {
     it('equalsTo', () => {
         boundingBox = new BoundingBox(northEast, southWest);
         expect(boundingBox.equalsTo(new BoundingBox(
-            new WGS84(10, 40), new WGS84(-5, -20)
+            new Coordinates(10, 40), new Coordinates(-5, -20)
         ))).true;
         expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
-            new WGS84(10, 40), new WGS84(-5, -20)
+            new Coordinates(10, 40), new Coordinates(-5, -20)
         ))).true;
         expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
-            new WGS84(10, 10), new WGS84(-5, -20)
+            new Coordinates(10, 10), new Coordinates(-5, -20)
         ))).false;
         expect(BoundingBox.equalsTo(boundingBox, new BoundingBox(
-            new WGS84(10, 40), new WGS84(-15, -20)
+            new Coordinates(10, 40), new Coordinates(-15, -20)
         ))).false;
     });
 
@@ -59,12 +59,12 @@ describe('Bounding Box', () => {
         expect(boundingBox.getEast()).equals(northEast.lng);
         expect(boundingBox.getSouth()).equals(southWest.lat);
         expect(boundingBox.getWest()).equals(southWest.lng);
-        expect(WGS84.equalsTo(boundingBox.getNorthEast(), northEast)).true;
-        expect(WGS84.equalsTo(boundingBox.getSouthWest(), southWest)).true;
-        expect(WGS84.equalsTo(boundingBox.getNorthWest(),
-            new WGS84(northEast.lat, southWest.lng))).true;
-        expect(WGS84.equalsTo(boundingBox.getSouthEast(),
-            new WGS84(southWest.lat, northEast.lng))).true;
+        expect(Coordinates.equalsTo(boundingBox.getNorthEast(), northEast)).true;
+        expect(Coordinates.equalsTo(boundingBox.getSouthWest(), southWest)).true;
+        expect(Coordinates.equalsTo(boundingBox.getNorthWest(),
+            new Coordinates(northEast.lat, southWest.lng))).true;
+        expect(Coordinates.equalsTo(boundingBox.getSouthEast(),
+            new Coordinates(southWest.lat, northEast.lng))).true;
     });
 
 
@@ -81,47 +81,47 @@ describe('Bounding Box', () => {
 
     it('contains', () => {
         boundingBox = new BoundingBox();
-        expect(() => boundingBox.contains(new WGS84(0, 0))).is.throw(Error);
+        expect(() => boundingBox.contains(new Coordinates(0, 0))).is.throw(Error);
 
         boundingBox = new BoundingBox(northEast, southWest);
         expect(() => boundingBox.contains(null)).is.throw(Error);
-        expect(boundingBox.contains(new WGS84(0, 0))).true;
-        expect(boundingBox.contains(new WGS84(10, 0))).true;
-        expect(boundingBox.contains(new WGS84(0, 10))).true;
-        expect(boundingBox.contains(new WGS84(-10, 0))).false;
-        expect(boundingBox.contains(new WGS84(0, -10))).true;
-        expect(boundingBox.contains(new WGS84(50, 50))).false;
-        expect(boundingBox.contains(new WGS84(-50, 50))).false;
-        expect(boundingBox.contains(new WGS84(50, -50))).false;
-        expect(boundingBox.contains(new WGS84(-50, -50))).false;
+        expect(boundingBox.contains(new Coordinates(0, 0))).true;
+        expect(boundingBox.contains(new Coordinates(10, 0))).true;
+        expect(boundingBox.contains(new Coordinates(0, 10))).true;
+        expect(boundingBox.contains(new Coordinates(-10, 0))).false;
+        expect(boundingBox.contains(new Coordinates(0, -10))).true;
+        expect(boundingBox.contains(new Coordinates(50, 50))).false;
+        expect(boundingBox.contains(new Coordinates(-50, 50))).false;
+        expect(boundingBox.contains(new Coordinates(50, -50))).false;
+        expect(boundingBox.contains(new Coordinates(-50, -50))).false;
     });
 
     it('extend', () => {
         boundingBox = new BoundingBox();
-        expect(() => boundingBox.extend(new WGS84(0, 0))).is.throw;
+        expect(() => boundingBox.extend(new Coordinates(0, 0))).is.throw;
 
         boundingBox = new BoundingBox(northEast, southWest);
         expect(() => boundingBox.extend(null)).is.throw(Error);
         expect(checkBounds(
-            boundingBox.extend(new WGS84(0, 0)),
+            boundingBox.extend(new Coordinates(0, 0)),
             [10, 40, -5, -20]
         )).true;
         expect(checkBounds(
-            boundingBox.extend(new WGS84(20, 0)),
+            boundingBox.extend(new Coordinates(20, 0)),
             [20, 40, -5, -20]
         )).true;
         expect(checkBounds(
-            boundingBox.extend(new WGS84(20, 40)),
+            boundingBox.extend(new Coordinates(20, 40)),
             [20, 40, -5, -20]
         )).true;
         expect(checkBounds(
-            boundingBox.extend(new WGS84(30, 40)),
+            boundingBox.extend(new Coordinates(30, 40)),
             [30, 40, -5, -20]
         )).true;
 
         boundingBox = new BoundingBox(northEast, southWest);
         boundingBox.extend(new BoundingBox(
-            new WGS84(10, 10), new WGS84(-10, -10)
+            new Coordinates(10, 10), new Coordinates(-10, -10)
         ));
         expect(checkBounds(boundingBox, [10, 40, -10, -20])).true;
 
@@ -147,26 +147,26 @@ describe('Bounding Box', () => {
         boundingBox = new BoundingBox(northEast, southWest);
         measure = 50000;
         extended = boundingBox.extendsWithMeasure(measure);
-        expect(new WGS84(extended.northEast.lat, northEast.lng).distanceTo(northEast))
+        expect(new Coordinates(extended.northEast.lat, northEast.lng).distanceTo(northEast))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(northEast.lat, extended.northEast.lng).distanceTo(northEast))
+        expect(new Coordinates(northEast.lat, extended.northEast.lng).distanceTo(northEast))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(extended.southWest.lat, southWest.lng).distanceTo(southWest))
+        expect(new Coordinates(extended.southWest.lat, southWest.lng).distanceTo(southWest))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(southWest.lat, extended.southWest.lng).distanceTo(southWest))
+        expect(new Coordinates(southWest.lat, extended.southWest.lng).distanceTo(southWest))
             .be.closeTo(measure, 0.05 * measure);
 
 
         boundingBox = new BoundingBox(northEast, southWest);
         measure = 50;
         extended = boundingBox.extendsWithMeasure(measure);
-        expect(new WGS84(extended.northEast.lat, northEast.lng).distanceTo(northEast))
+        expect(new Coordinates(extended.northEast.lat, northEast.lng).distanceTo(northEast))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(northEast.lat, extended.northEast.lng).distanceTo(northEast))
+        expect(new Coordinates(northEast.lat, extended.northEast.lng).distanceTo(northEast))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(extended.southWest.lat, southWest.lng).distanceTo(southWest))
+        expect(new Coordinates(extended.southWest.lat, southWest.lng).distanceTo(southWest))
             .be.closeTo(measure, 0.05 * measure);
-        expect(new WGS84(southWest.lat, extended.southWest.lng).distanceTo(southWest))
+        expect(new Coordinates(southWest.lat, extended.southWest.lng).distanceTo(southWest))
             .be.closeTo(measure, 0.05 * measure);
     });
 

package/src/coordinates/{WGS84.js → Coordinates.js}

@@ -7,17 +7,17 @@ import isFinite from 'lodash.isfinite';
 import Level from './Level';
 
 /**
- * A WGS84 position using at least latitude (lat) and longitude (lng).
+ * A Coordinates position using at least latitude (lat) and longitude (lng).
  * Optionnal fields are: altitude (alt) and level.
  *
  * Basic geo methods are directly accessibles from here:
  * distanceTo, bearingTo, toEcef...
  *
  * /!\ This class has been adapted to use earth as a sphere and not as an ellipsoid
- * /!\ So, this class does not stricly represent WGS84 coordinates anymore
+ * /!\ So, this class does not stricly represent Coordinates coordinates anymore
  * /!\ This modifications have been made for computational improvements.
  */
-class WGS84 {
+class Coordinates {
 
     constructor(lat, lng, alt, level) {
         this.lat = lat;
@@ -89,7 +89,7 @@ class WGS84 {
     }
 
     clone() {
-        const output = new WGS84(this.lat, this.lng, this.alt);
+        const output = new Coordinates(this.lat, this.lng, this.alt);
         if (this.level) {
             output.level = this.level.clone();
         }
@@ -97,9 +97,9 @@ class WGS84 {
     }
 
     /**
-     * Compares two WGS84
-     * @param {WGS84} pos1 position 1
-     * @param {WGS84} pos2 position 2
+     * Compares two Coordinates
+     * @param {Coordinates} pos1 position 1
+     * @param {Coordinates} pos2 position 2
      * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
      * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
      */
@@ -110,7 +110,7 @@ class WGS84 {
             return true;
         }
 
-        if (!(pos1 instanceof WGS84) || !(pos2 instanceof WGS84)) {
+        if (!(pos1 instanceof Coordinates) || !(pos2 instanceof Coordinates)) {
             return false;
         }
 
@@ -123,7 +123,7 @@ class WGS84 {
     }
 
     equalsTo(other) {
-        return WGS84.equalsTo(this, other);
+        return Coordinates.equalsTo(this, other);
     }
 
     destinationPoint(distance, bearing, elevation) {
@@ -167,7 +167,7 @@ class WGS84 {
 
     /**
      * Returns a distance between two points in meters
-     * @param  {WGS84} location2 latitude / longitude point
+     * @param  {Coordinates} location2 latitude / longitude point
      * @return {Number} distance in meters
      */
     distanceTo(location2) {
@@ -265,7 +265,7 @@ class WGS84 {
 
         lng = lng % (2 * Math.PI);
 
-        const newPoint = new WGS84(rad2deg(lat), rad2deg(lng), alt);
+        const newPoint = new Coordinates(rad2deg(lat), rad2deg(lng), alt);
         newPoint._ecef = ecef;
         return newPoint;
     }
@@ -288,9 +288,9 @@ class WGS84 {
         const t = Vector3.normalize(Vector3.cross(G, F));
 
         const posECEF = Vector3.multiplyScalar(t, Constants.R_MAJOR);
-        const poseWGS84 = WGS84.fromECEF(posECEF);
+        const poseCoordinates = Coordinates.fromECEF(posECEF);
 
-        // poseWGS84.alt is not 0 here due to the ECEF transformation residual.
+        // poseCoordinates.alt is not 0 here due to the ECEF transformation residual.
         // So if p1.alt and p2.alt are defined we take the middle elevation between p1 and p2.
         // Otherwise we remove alt from projection because the residual has no sense.
         let alt;
@@ -298,7 +298,7 @@ class WGS84 {
             // This formula is maybe not the best one.
             alt = (p1.alt + p2.alt) / 2;
         }
-        const projection = new WGS84(poseWGS84.lat, poseWGS84.lng,
+        const projection = new Coordinates(poseCoordinates.lat, poseCoordinates.lng,
             alt, Level.intersect(p1.level, p2.level));
 
         if (Math.abs((p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection))) > 1e-6) {
@@ -339,9 +339,9 @@ class WGS84 {
     }
 
     static fromJson(json) {
-        return new WGS84(json.lat, json.lng, json.alt, Level.fromString(json.level));
+        return new Coordinates(json.lat, json.lng, json.alt, Level.fromString(json.level));
     }
 
 }
 
-export default WGS84;
+export default Coordinates;