@wemap/geo 3.2.17 → 4.0.1

package/src/coordinates/Coordinates.js

@@ -1,5 +1,5 @@
 import {
-    Utils, Vector3, Quaternion, rad2deg
+    deg2rad, Vector3, Quaternion, rad2deg, wrap
 } from '@wemap/maths';
 
 import Constants from '../Constants.js';
@@ -13,7 +13,7 @@ import Level from './Level.js';
  * 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 Coordinates coordinates anymore
+ * /!\ So, this class does not stricly represent WGS84 coordinates anymore
  * /!\ This modifications have been made for computational improvements.
  */
 class Coordinates {
@@ -65,6 +65,10 @@ class Coordinates {
         this._ecef = null;
     }
 
+    set latitude(lat) {
+        throw new Error('Please use Coordinate#lat setter instead of Coordinate#latitude');
+    }
+
     set lng(lng) {
         if (typeof lng === 'number') {
             this._lng = lng;
@@ -77,6 +81,10 @@ class Coordinates {
         this._ecef = null;
     }
 
+    set longitude(lng) {
+        throw new Error('Please use Coordinate#lng setter instead of Coordinate#longitude');
+    }
+
     set alt(alt) {
         if (typeof alt === 'number') {
             this._alt = alt;
@@ -110,7 +118,7 @@ class Coordinates {
 
     wrap() {
         if (this._lng <= -180 || this._lng > 180) {
-            this._lng = Utils.wrap(this._lng, -180, 180);
+            this._lng = wrap(this._lng, -180, 180);
         }
     }
 
@@ -157,8 +165,8 @@ class Coordinates {
         const cosDr = Math.cos(dR);
         const sinDr = Math.sin(dR);
 
-        const phi1 = Utils.deg2rad(this.lat);
-        const lambda1 = Utils.deg2rad(this.lng);
+        const phi1 = deg2rad(this.lat);
+        const lambda1 = deg2rad(this.lng);
 
         const phi2 = Math.asin(
             Math.sin(phi1) * cosDr
@@ -169,8 +177,8 @@ class Coordinates {
             cosDr - Math.sin(phi1) * Math.sin(phi2)
         );
 
-        this.lat = Utils.rad2deg(phi2);
-        this.lng = Utils.rad2deg(lambda2);
+        this.lat = rad2deg(phi2);
+        this.lng = rad2deg(lambda2);
 
         if (typeof elevation === 'number') {
             if (this.alt === null) {
@@ -195,14 +203,14 @@ class Coordinates {
         const lat2 = location2.lat;
         const lng2 = location2.lng;
 
-        const dlat = Utils.deg2rad(lat2 - lat1);
-        const dlng = Utils.deg2rad(lng2 - lng1);
+        const dlat = deg2rad(lat2 - lat1);
+        const dlng = deg2rad(lng2 - lng1);
 
         const dlngsin = Math.sin(dlng / 2);
         const dlatsin = Math.sin(dlat / 2);
-        const lat1rad = Utils.deg2rad(lat1);
+        const lat1rad = deg2rad(lat1);
         const lat1cos = Math.cos(lat1rad);
-        const lat2rad = Utils.deg2rad(lat2);
+        const lat2rad = deg2rad(lat2);
         const lat2cos = Math.cos(lat2rad);
         const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
 
@@ -219,9 +227,9 @@ class Coordinates {
     }
 
     bearingTo(location2) {
-        const lat1 = Utils.deg2rad(this.lat);
-        const lat2 = Utils.deg2rad(location2.lat);
-        const diffLng = Utils.deg2rad(location2.lng - this.lng);
+        const lat1 = deg2rad(this.lat);
+        const lat2 = deg2rad(location2.lat);
+        const diffLng = deg2rad(location2.lng - this.lng);
 
         return Math.atan2(Math.sin(diffLng) * Math.cos(lat2),
             Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng));
@@ -239,14 +247,14 @@ class Coordinates {
      */
 
     get enuToEcefRotation() {
-        const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + Utils.deg2rad(this.lng));
-        const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - Utils.deg2rad(this.lat));
+        const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + deg2rad(this.lng));
+        const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - deg2rad(this.lat));
         return Quaternion.multiply(rot1, rot2);
     }
 
     get ecefToEnuRotation() {
-        const rot1 = Quaternion.fromAxisAngle([1, 0, 0], Utils.deg2rad(this.lat) - Math.PI / 2);
-        const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -Utils.deg2rad(this.lng) - Math.PI / 2);
+        const rot1 = Quaternion.fromAxisAngle([1, 0, 0], deg2rad(this.lat) - Math.PI / 2);
+        const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -deg2rad(this.lng) - Math.PI / 2);
         return Quaternion.multiply(rot1, rot2);
     }
 
@@ -255,8 +263,8 @@ class Coordinates {
     get ecef() {
 
         if (!this._ecef) {
-            const lat = Utils.deg2rad(this.lat);
-            const lng = Utils.deg2rad(this.lng);
+            const lat = deg2rad(this.lat);
+            const lng = deg2rad(this.lng);
             const alt = this.alt || 0;
 
             const x = (Constants.R_MAJOR + alt) * Math.cos(lat) * Math.cos(lng);
@@ -361,11 +369,25 @@ class Coordinates {
     }
 
     toCompressedJson() {
-        return [this.lat, this.lng, this.alt, this.level === null ? null : this.level.toString()];
+        const output = [this.lat, this.lng];
+        if (this.alt !== null || this.level !== null) {
+            output.push(this.alt);
+        }
+        if (this.level !== null) {
+            output.push(this.level.toString());
+        }
+        return output;
     }
 
     static fromCompressedJson(json) {
-        return new Coordinates(json[0], json[1], json[2], Level.fromString(json[3]));
+        const coords = new Coordinates(json[0], json[1]);
+        if (json.length > 2) {
+            coords.alt = json[2];
+        }
+        if (json.length > 3) {
+            coords.level = Level.fromString(json[3]);
+        }
+        return coords;
     }
 }
 

package/src/coordinates/Coordinates.spec.js

@@ -33,7 +33,9 @@ describe('Coordinates', () => {
         const level = new Level(2);
         const position = new Coordinates(45, 5, 0, level);
         expect(position.lat).equals(45);
+        expect(position.latitude).equals(45);
         expect(position.lng).equals(5);
+        expect(position.longitude).equals(5);
         expect(position.alt).equals(0);
         expect(position.level).equals(level);
 
@@ -57,6 +59,9 @@ describe('Coordinates', () => {
 
         position.lng = -202;
         expect(position.lng).equals(158);
+
+        expect(() => (position.latitude = 45)).throw(Error);
+        expect(() => (position.longitude = 5)).throw(Error);
     });
 
     it('clone', () => {

package/src/coordinates/RelativePosition.js

@@ -25,7 +25,7 @@ class RelativePosition {
     set x(x) {
         if (typeof x === 'number') {
             this._x = x;
-        } else if (typeof x !== 'undefined' && x !== null) {
+        } else {
             throw new Error('x argument is not a number');
         }
     }
@@ -37,7 +37,7 @@ class RelativePosition {
     set y(y) {
         if (typeof y === 'number') {
             this._y = y;
-        } else if (typeof y !== 'undefined' && y !== null) {
+        } else {
             throw new Error('y argument is not a number');
         }
     }
@@ -49,7 +49,7 @@ class RelativePosition {
     set z(z) {
         if (typeof z === 'number') {
             this._z = z;
-        } else if (typeof z !== 'undefined' && z !== null) {
+        } else {
             throw new Error('z argument is not a number');
         }
     }

package/src/coordinates/RelativePosition.spec.js

@@ -0,0 +1,166 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import RelativePosition from './RelativePosition.js';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('RelativePosition', () => {
+
+    it('creation', () => {
+
+        expect(() => new RelativePosition()).throw(Error);
+
+        expect(() => new RelativePosition(1)).throw(Error);
+        expect(() => new RelativePosition('a')).throw(Error);
+        expect(() => new RelativePosition(1, 2)).throw(Error);
+        expect(() => new RelativePosition(1, 'a')).throw(Error);
+        expect(() => new RelativePosition(1, 2, 3)).not.throw(Error);
+        expect(() => new RelativePosition(1, 2, 'a')).throw(Error);
+
+        expect(() => new RelativePosition(1, 2, 3, 123456)).not.throw(Error);
+        expect(() => new RelativePosition(1, 2, 3, 'a')).throw(Error);
+        expect(() => new RelativePosition(1, 2, 3, 123456, 10)).not.throw(Error);
+        expect(() => new RelativePosition(1, 2, 3, 123456, 'a')).throw(Error);
+        expect(() => new RelativePosition(1, 2, 3, 123456, 10, Math.PI)).not.throw(Error);
+        expect(() => new RelativePosition(1, 2, 3, 123456, 10, 'a')).throw(Error);
+
+        const position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
+        expect(position.x).equals(1);
+        expect(position.y).equals(2);
+        expect(position.z).equals(3);
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+
+    });
+
+    it('update', () => {
+        const position = new RelativePosition(0, 0, 0);
+        position.x = 1;
+        position.y = 2;
+        position.z = 3;
+        position.time = 123456;
+        position.accuracy = 10;
+        position.bearing = Math.PI;
+        expect(position.x).equals(1);
+        expect(position.y).equals(2);
+        expect(position.z).equals(3);
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+
+    });
+
+    it('clone', () => {
+        const position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
+        const clonePosition = position.clone();
+
+        expect(clonePosition.x).equals(1);
+        expect(clonePosition.y).equals(2);
+        expect(clonePosition.z).equals(3);
+        expect(clonePosition.time).equals(123456);
+        expect(clonePosition.accuracy).equals(10);
+        expect(clonePosition.bearing).equals(Math.PI);
+
+        expect(clonePosition).not.equal(position);
+    });
+
+
+    it('equalsTo', () => {
+        let position, position2;
+
+        expect(RelativePosition.equalsTo(null, null)).true;
+
+        position = new RelativePosition(1, 2, 3);
+        expect(RelativePosition.equalsTo(position, new RelativePosition(1, 2, 3))).true;
+        expect(RelativePosition.equalsTo(position, {})).false;
+        expect(RelativePosition.equalsTo({}, position)).false;
+
+        position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
+        expect(RelativePosition.equalsTo(position,
+            new RelativePosition(1, 2, 3, 123456, 10, Math.PI)
+        )).true;
+
+        position2 = position.clone();
+        position2.x = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.y = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.z = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.time = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.accuracy = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.bearing = 0;
+        expect(RelativePosition.equalsTo(position, position2)).false;
+
+        expect(position.equalsTo(new RelativePosition(1, 2, 3, 123456, 10, Math.PI))).true;
+        expect(position.equalsTo(new RelativePosition(1, 2, 3, 123456, 0, Math.PI))).false;
+    });
+
+    it('json', () => {
+        let position;
+
+        position = new RelativePosition(1, 2, 3);
+        expect(position.toJson()).to.deep.equal({
+            x: 1,
+            y: 2,
+            z: 3
+        });
+
+        position = new RelativePosition(1, 2, 3);
+        position.time = 10;
+        expect(position.toJson()).to.deep.equal({
+            x: 1,
+            y: 2,
+            z: 3,
+            time: 10
+        });
+
+        position = new RelativePosition(1, 2, 3);
+        position.accuracy = 10;
+        expect(position.toJson()).to.deep.equal({
+            x: 1,
+            y: 2,
+            z: 3,
+            accuracy: 10
+        });
+
+        position = new RelativePosition(1, 2, 3);
+        position.bearing = Math.PI;
+        expect(position.toJson()).to.deep.equal({
+            x: 1,
+            y: 2,
+            z: 3,
+            bearing: Math.PI
+        });
+
+        position = new RelativePosition(1, 2, 3);
+        expect(RelativePosition.equalsTo(
+            RelativePosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+        position = new RelativePosition(1, 2, 3, 123456, 10, Math.PI);
+        expect(RelativePosition.equalsTo(
+            RelativePosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+    });
+
+});

package/src/coordinates/UserPosition.spec.js

@@ -24,11 +24,13 @@ describe('UserPosition', () => {
         expect(() => new UserPosition(45, 5, null, null, 0)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, 10)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, -10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, 'a')).throw(Error);
 
         expect(() => new UserPosition(45, 5, null, null, null, null)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, null, 0)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, null, 10)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, null, -10)).throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null, 'a')).throw(Error);
 
         expect(() => new UserPosition(45, 5, null, null, null,
             null, null)).not.throw(Error);
@@ -38,6 +40,8 @@ describe('UserPosition', () => {
             null, 10)).not.throw(Error);
         expect(() => new UserPosition(45, 5, null, null, null,
             null, -10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, 'a')).throw(Error);
 
         const position = new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo');
         expect(position.lat).equals(45);

package/src/graph/Edge.js

@@ -0,0 +1,235 @@
+import Level from '../coordinates/Level.js';
+import Node from './Node.js';
+
+/**
+ * An Edge is a segment composed of two Node
+ * An edge is mostly issued from an OsmWay, but this is not always the case.
+ * For example, edges created by mapmatching.
+ */
+class Edge {
+
+    /** @type {Node} */
+    _node1 = null;
+
+    /** @type {Node} */
+    _node2 = null;
+
+    /** @type {?Level} */
+    _level = null;
+
+    /** @type {?number} */
+    _bearing;
+
+    /** @type {?number} */
+    _length;
+
+    /** @type {boolean} */
+    _computedSizeAndBearing;
+
+    /** @type {boolean} */
+    isStairs = false;
+
+    /** @type {boolean} */
+    isElevator = false;
+
+    /** @type {boolean} */
+    isOneway = false;
+
+    /** @type {boolean} */
+    isConveying = false;
+
+    /** @type {string} */
+    name = null;
+
+    /**
+     * @param {!Node} node1
+     * @param {!Node} node2
+     * @param {?Level} level
+     * @param {?string} name
+     */
+    constructor(node1, node2, level, name = null) {
+
+        this.node1 = node1;
+        this.node2 = node2;
+        this.level = level;
+        this.name = name || null;
+
+        this._computedSizeAndBearing = false;
+    }
+
+    /** @type {!Node} */
+    get node1() {
+        return this._node1;
+    }
+
+    /** @type {!Node} */
+    set node1(node) {
+
+        if (!(node instanceof Node)) {
+            throw new TypeError('node1 is not a Node');
+        }
+
+        if (this._node1 !== null && this._node2 !== this._node1) {
+            this._node1.edges = this._node1.edges.filter(edge => edge !== this);
+        }
+
+        node.edges.push(this);
+
+        this._node1 = node;
+        this._computedSizeAndBearing = false;
+    }
+
+    /** @type {!Node} */
+    get node2() {
+        return this._node2;
+    }
+
+    /** @type {!Node} */
+    set node2(node) {
+
+        if (!(node instanceof Node)) {
+            throw new TypeError('node2 is not a Node');
+        }
+
+        if (this._node2 !== null && this._node2 !== this._node1) {
+            this._node2.edges = this._node2.edges.filter(edge => edge !== this);
+        }
+
+        node.edges.push(this);
+
+        this._node2 = node;
+        this._computedSizeAndBearing = false;
+    }
+
+    /** @type {?Level} */
+    get level() {
+        return this._level;
+    }
+
+    /** @type {?Level} */
+    set level(level) {
+        if (level instanceof Level) {
+            this._level = level;
+        } else {
+            if (typeof level !== 'undefined' && level !== null) {
+                throw new Error('level argument is not a Level object');
+            }
+            this._level = null;
+        }
+    }
+
+    /**
+     * Get edge bearing from node1 to node2
+     * @type {number}
+     */
+    get bearing() {
+        if (!this._computedSizeAndBearing) {
+            this._computeSizeAndBearing();
+        }
+        return this._bearing;
+    }
+
+    /**
+     * get edge length
+     * @type {number}
+     */
+    get length() {
+        if (!this._computedSizeAndBearing) {
+            this._computeSizeAndBearing();
+        }
+        return this._length;
+    }
+
+    _computeSizeAndBearing() {
+        this._length = this.node1.distanceTo(this.node2);
+        this._bearing = this.node1.bearingTo(this.node2);
+        this._computedSizeAndBearing = true;
+    }
+
+    /**
+     * @param {Edge} other
+     * @returns {boolean}
+     */
+    equalsTo(other) {
+
+        if (!(other instanceof Edge)) {
+            return false;
+        }
+
+        return other.node1.equalsTo(this.node1)
+            && other.node2.equalsTo(this.node2)
+            && Level.equalsTo(other.level, this.level)
+            && other.name === this.name
+            && other.isConveying === this.isConveying
+            && other.isElevator === this.isElevator
+            && other.isOneway === this.isOneway
+            && other.isStairs === this.isStairs;
+    }
+
+    /**
+     * @returns {Edge}
+     */
+    clone() {
+        const edge = new Edge(this.node1, this.node2);
+        edge.name = this.name;
+        edge.level = this.level;
+        edge.isConveying = this.isConveying;
+        edge.isElevator = this.isElevator;
+        edge.isOneway = this.isOneway;
+        edge.isStairs = this.isStairs;
+        return edge;
+    }
+
+    /**
+     * @returns {object}
+     */
+    extractProperties() {
+        const output = {};
+        if (this.level !== null) {
+            output.level = this.level.toString();
+        }
+        if (this.name !== null) {
+            output.name = this.name;
+        }
+        if (this.isConveying) {
+            output.isConveying = true;
+        }
+        if (this.isElevator) {
+            output.isElevator = true;
+        }
+        if (this.isOneway) {
+            output.isOneway = true;
+        }
+        if (this.isStairs) {
+            output.isStairs = true;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} properties
+     */
+    applyProperties(properties) {
+        if (properties.level) {
+            this.level = Level.fromString(properties.level);
+        }
+        if (properties.name) {
+            this.name = properties.name;
+        }
+        if (properties.isConveying) {
+            this.isConveying = true;
+        }
+        if (properties.isElevator) {
+            this.isElevator = true;
+        }
+        if (properties.isOneway) {
+            this.isOneway = true;
+        }
+        if (properties.isStairs) {
+            this.isStairs = true;
+        }
+        return this;
+    }
+}
+
+export default Edge;