@wemap/geo 7.0.0 → 7.2.0

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "7.0.0",
+    "version": "7.2.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -30,5 +30,5 @@
         "@wemap/logger": "^7.0.0",
         "@wemap/maths": "^7.0.0"
     },
-    "gitHead": "cfd70d1f998599c53689c1b1996a517247f04dce"
+    "gitHead": "a4a796c2870c6b1182a0c69fe753bc4012faf0c1"
 }

package/src/coordinates/Coordinates.js

@@ -18,8 +18,29 @@ import Level from './Level.js';
  */
 class Coordinates {
 
+    /** @type {Number} */
+    _lat;
+
+    /** @type {Number} */
+    _lng;
+
+    /** @type {Number|null} */
+    _alt = null;
+
+    /** @type {Level|null} */
+    _level = null;
+
+    /** @type {[Number, Number, Number]|null} */
+    _ecef;
+
     autoWrap = true;
 
+    /**
+     * @param {Number} lat
+     * @param {Number} lng
+     * @param {Number|null} alt
+     * @param {Level|null} level
+     */
     constructor(lat, lng, alt, level) {
         this.lat = lat;
         this.lng = lng;
@@ -28,23 +49,28 @@ class Coordinates {
         this._ecef = null;
     }
 
+    /** @type {Number} */
     get lat() {
         return this._lat;
     }
 
+    /** @type {Number} */
     get latitude() {
         return this._lat;
     }
 
+    /** @type {Number} */
     get lng() {
         return this._lng;
     }
 
+    /** @type {Number} */
     get longitude() {
         return this._lng;
     }
 
     /**
+     * @type {Number|null}
      * alt does not denote the altitude of a point but its height from
      *  the "level" field (if defined) or from the ground
      */
@@ -52,10 +78,12 @@ class Coordinates {
         return this._alt;
     }
 
+    /** @type {Level|null} */
     get level() {
         return this._level;
     }
 
+    /** @type {Number} */
     set lat(lat) {
         if (typeof lat === 'number' && Math.abs(lat) <= 90) {
             this._lat = lat;
@@ -65,10 +93,12 @@ class Coordinates {
         this._ecef = null;
     }
 
-    set latitude(lat) {
+    /** @type {Number} */
+    set latitude(_) {
         throw new Error('Please use Coordinate#lat setter instead of Coordinate#latitude');
     }
 
+    /** @type {Number} */
     set lng(lng) {
         if (typeof lng === 'number') {
             this._lng = lng;
@@ -81,10 +111,12 @@ class Coordinates {
         this._ecef = null;
     }
 
-    set longitude(lng) {
+    /** @type {Number} */
+    set longitude(_) {
         throw new Error('Please use Coordinate#lng setter instead of Coordinate#longitude');
     }
 
+    /** @type {Number|null} */
     set alt(alt) {
         if (typeof alt === 'number') {
             this._alt = alt;
@@ -97,6 +129,7 @@ class Coordinates {
         this._ecef = null;
     }
 
+    /** @type {Level|null} */
     set level(level) {
         if (level instanceof Level) {
             this._level = level;
@@ -108,6 +141,10 @@ class Coordinates {
         }
     }
 
+    /**
+     * Deep clone coordinates
+     * @returns {!Coordinates}
+     */
     clone() {
         const output = new Coordinates(this.lat, this.lng, this.alt);
         if (this.level) {
@@ -148,17 +185,35 @@ class Coordinates {
             && Level.equalsTo(pos1.level, pos2.level);
     }
 
+    /**
+     * @param {Coordinates} other
+     * @returns {!Boolean}
+     */
     equalsTo(other) {
         return Coordinates.equalsTo(this, other);
     }
 
+    /**
+     * @param {!Number} distance
+     * @param {!Number} bearing
+     * @param {?Number} elevation
+     * @returns {!Coordinates}
+     * @throws {Error} if elevation is defined and point altitude is not defined
+     */
     destinationPoint(distance, bearing, elevation) {
         const newPoint = this.clone();
         newPoint.move(distance, bearing, elevation);
         return newPoint;
     }
 
-    // Source: http://www.movable-type.co.uk/scripts/latlong.html#destPoint
+    /**
+     * Source: http://www.movable-type.co.uk/scripts/latlong.html#destPoint
+     * @param {!Number} distance
+     * @param {!Number} bearing
+     * @param {?Number} elevation
+     * @returns {!Coordinates}
+     * @throws {Error} if elevation is defined and point altitude is not defined
+     */
     move(distance, bearing, elevation) {
 
         const dR = distance / Constants.R_MAJOR;
@@ -187,7 +242,6 @@ class Coordinates {
             this.alt += elevation;
         }
 
-
         return this;
     }
 
@@ -222,10 +276,19 @@ class Coordinates {
         return Constants.R_MAJOR * cosn;
     }
 
+    /**
+     * @param {!Coordinates} point1
+     * @param {!Coordinates} point2
+     * @returns {!Number}
+     */
     static distanceBetween(point1, point2) {
         return point1.distanceTo(point2);
     }
 
+    /**
+     * @param {!Coordinates} location2
+     * @returns {!Number}
+     */
     bearingTo(location2) {
         const lat1 = deg2rad(this.lat);
         const lat2 = deg2rad(location2.lat);
@@ -235,6 +298,11 @@ class Coordinates {
             Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng));
     }
 
+    /**
+     * @param {!Coordinates} point1
+     * @param {!Coordinates} point2
+     * @returns {!Number}
+     */
     static bearingTo(point1, point2) {
         return point1.bearingTo(point2);
     }
@@ -246,20 +314,25 @@ class Coordinates {
      * as a sphere instead of an ellipse
      */
 
+    /** @type {![Number, Number, Number, Number]} */
     get enuToEcefRotation() {
         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);
     }
 
+    /** @type {![Number, Number, Number, Number]} */
     get ecefToEnuRotation() {
         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);
     }
 
-    // https://gist.github.com/klucar/1536194
-    // Adapted for spherical formula
+    /**
+     * https://gist.github.com/klucar/1536194
+     * Adapted for spherical formula
+     * @type {![Number, Number, Number]}
+     */
     get ecef() {
 
         if (!this._ecef) {
@@ -277,6 +350,10 @@ class Coordinates {
         return this._ecef;
     }
 
+    /**
+     * @param {![Number, Number, Number]} ecef
+     * @returns {!Coordinates}
+     */
     static fromECEF(ecef) {
 
         const x = ecef[0];
@@ -297,8 +374,13 @@ class Coordinates {
     }
 
 
-    // https://stackoverflow.com/questions/1299567/how-to-calculate-distance-from-a-point-to-a-line-segment-on-a-sphere
-    // Adapted to ECEF
+    /**
+     * https://stackoverflow.com/questions/1299567/how-to-calculate-distance-from-a-point-to-a-line-segment-on-a-sphere
+     * Adapted to ECEF
+     * @param {!Coordinates} p1
+     * @param {!Coordinates} p2
+     * @returns {Coordinates|null}
+     */
     getSegmentProjection(p1, p2) {
 
         const a = Vector3.normalize(p1.ecef);
@@ -338,6 +420,9 @@ class Coordinates {
      * Input / Output
      */
 
+    /**
+     * @returns {!String}
+     */
     toString() {
         let str = '[' + this._lat.toFixed(7) + ', ' + this._lng.toFixed(7);
         if (this._alt !== null) {
@@ -350,6 +435,9 @@ class Coordinates {
         return str;
     }
 
+    /**
+     * @returns {!Object}
+     */
     toJson() {
         const output = {
             lat: this.lat,
@@ -364,10 +452,17 @@ class Coordinates {
         return output;
     }
 
+    /**
+     * @param {!Object} json
+     * @returns {!Coordinates}
+     */
     static fromJson(json) {
         return new Coordinates(json.lat, json.lng, json.alt, Level.fromString(json.level));
     }
 
+    /**
+     * @returns {!Object}
+     */
     toCompressedJson() {
         const output = [this.lat, this.lng];
         if (this.alt !== null || this.level !== null) {
@@ -379,6 +474,10 @@ class Coordinates {
         return output;
     }
 
+    /**
+     * @param {!Object} json
+     * @returns {!Coordinates}
+     */
     static fromCompressedJson(json) {
         const coords = new Coordinates(json[0], json[1]);
         if (json.length > 2) {

package/src/graph/MapMatching.js

@@ -102,11 +102,11 @@ class MapMatching {
             checkEdge = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node1.coords.level) && !edge.node1.io) {
+        if (!Level.equalsTo(location.level, edge.node1.coords.level) && !(edge.node1.io && !location.level)) {
             checkNode1 = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node2.coords.level) && !edge.node2.io) {
+        if (!Level.equalsTo(location.level, edge.node2.coords.level) && !(edge.node2.io && !location.level)) {
             checkNode2 = false;
         }
 

package/src/router/GraphRouter.js

@@ -48,6 +48,10 @@ class GraphRouter {
 
         const createdNodes = [];
 
+        /**
+         * @param {GraphNode|Coordinates} point
+         * @returns {GraphNode}
+         */
         const retrieveOrCreateNearestNode = point => {
             if (point instanceof GraphNode) {
                 return point;
@@ -60,10 +64,13 @@ class GraphRouter {
 
             const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
             if (!proj) {
-                throw new NoRouteFoundError(start, end,
-                    `Point ${point.toString()} is too far from the network `
-                    + `> ${this._mapMatching.maxDistance.toFixed(0)} meters`
-                );
+                let message = `Point ${point.toString()} is too far from the network `
+                    + `> ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
+                if (point.level) {
+                    message += ' If it is a multi-level map, please verify if you have'
+                        + ` a network at level ${point.level.toString()}.`;
+                }
+                throw new NoRouteFoundError(start, end, message);
             }
             if (proj.nearestElement instanceof GraphNode) {
                 return proj.nearestElement;