@wemap/geo 4.0.0 → 4.0.3

package/index.js

@@ -20,6 +20,7 @@ export { default as Itinerary } from './src/graph/Itinerary.js';
 export { default as Network } from './src/graph/Network.js';
 export { default as Node } from './src/graph/Node.js';
 export { default as MapMatching } from './src/graph/MapMatching.js';
+export { default as Projection } from './src/graph/Projection.js';
 export { default as Step } from './src/graph/Step.js';
 export * as GraphUtils from './src/graph/Utils.js';
 export { default as NoRouteFoundError } from './src/graph/NoRouteFoundError.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "4.0.0",
+    "version": "4.0.3",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -28,7 +28,7 @@
     "license": "ISC",
     "dependencies": {
         "@wemap/logger": "^4.0.0",
-        "@wemap/maths": "^4.0.0"
+        "@wemap/maths": "^4.0.3"
     },
-    "gitHead": "8b72858590fc2ff33fbea4f090de8cd353a7445f"
+    "gitHead": "91a82028ddda32038999582da381d1d0d8acd091"
 }

package/src/graph/MapMatching.js

@@ -1,3 +1,4 @@
+/* eslint-disable complexity */
 /* eslint-disable max-statements */
 import { diffAngleLines } from '@wemap/maths';
 
@@ -6,6 +7,7 @@ import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
 
 import Network from './Network.js';
+import Projection from './Projection.js';
 
 class MapMatching {
 
@@ -104,8 +106,7 @@ class MapMatching {
             // if mapmatching bearing is enabled do not use nodes matching
             if (checkEdge) {
                 // condition for optimisation
-                const diffAngle = diffAngleLines(
-                    edge.bearing, location.bearing);
+                const diffAngle = diffAngleLines(edge.bearing, location.bearing);
                 if (diffAngle > this._maxAngleBearing) {
                     // Do not try to project if angle is greater than the threshold
                     checkEdge = false;
@@ -118,6 +119,21 @@ class MapMatching {
         return [checkEdge, checkNode1, checkNode2];
     }
 
+
+    /**
+     * @param {Coordinates} fromCoordinates
+     * @param {Coordinates} toCoordinates
+     */
+    static _assignLatLngLevel(fromCoordinates, toCoordinates) {
+        toCoordinates.lat = fromCoordinates.lat;
+        toCoordinates.lng = fromCoordinates.lng;
+        toCoordinates.level = fromCoordinates.level;
+    }
+
+    /**
+     * @param {Edge} _edge
+     * @param {Coordinates} _projection
+     */
     static _updateProjectionLevelFromEdge = (_edge, _projection) => {
         if (_edge.level) {
             _projection.level = _edge.level.clone();
@@ -130,6 +146,7 @@ class MapMatching {
      * @param {boolean} useBearing
      * @param {boolean} useMultiLevelSegments
      * @param {function} acceptEdgeFn
+     * @returns {Projection}
      */
     getProjection(location, useDistance = false, useBearing = false,
         useMultiLevelSegments = true, acceptEdgeFn = () => true) {
@@ -146,9 +163,10 @@ class MapMatching {
             return null;
         }
 
-        const projection = {};
+        const projection = new Projection();
         projection.origin = location;
         projection.distanceFromNearestElement = Number.MAX_VALUE;
+        projection.projection = location.clone();
 
         const isProjectionBetter = (distanceOfNewProjection) => {
             return distanceOfNewProjection < projection.distanceFromNearestElement
@@ -167,10 +185,11 @@ class MapMatching {
                 if (isProjectionBetter(distNode1) || distNode1 <= Constants.EPS_MM) {
                     projection.distanceFromNearestElement = distNode1;
                     projection.nearestElement = edge.node1;
-                    projection.projection = edge.node1.coords.clone();
+                    MapMatching._assignLatLngLevel(edge.node1.coords, projection.projection);
                     MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
 
-                    if (distNode1 <= Constants.EPS_MM) {
+                    if (distNode1 <= Constants.EPS_MM
+                        && location.level === edge.node1.coords.level) {
                         break;
                     }
                 }
@@ -183,10 +202,11 @@ class MapMatching {
 
                     projection.distanceFromNearestElement = distNode2;
                     projection.nearestElement = edge.node2;
-                    projection.projection = edge.node2.coords.clone();
+                    MapMatching._assignLatLngLevel(edge.node2.coords, projection.projection);
                     MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
 
-                    if (distNode2 <= Constants.EPS_MM) {
+                    if (distNode2 <= Constants.EPS_MM
+                        && location.level === edge.node2.coords.level) {
                         break;
                     }
                 }
@@ -199,19 +219,23 @@ class MapMatching {
                     if (isProjectionBetter(distEdge)) {
                         projection.distanceFromNearestElement = distEdge;
                         projection.nearestElement = edge;
-                        projection.projection = segmentProjection.clone();
+                        MapMatching._assignLatLngLevel(segmentProjection, projection.projection);
                         MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
                     }
                 }
             }
         }
 
-        if (!projection.projection) {
+
+        if (!projection.nearestElement) {
             return null;
         }
 
+        projection.projection.accuracy += projection.distanceFromNearestElement;
+
         return projection;
     }
+
 }
 
 export default MapMatching;

package/src/graph/MapMatching.spec.js

@@ -85,7 +85,7 @@ describe('MapMatching', () => {
         const owMapMatching = new MapMatching(owNetwork);
         result = owMapMatching.getProjection(new Coordinates(43.6092086, 3.8842598, 10));
         expect(result).is.not.null;
-        expect(result.projection.alt).equals(7.5);
+        expect(result.projection.alt).equals(10);
     });
 
     it('with bearing', () => {

package/src/graph/Projection.js

@@ -0,0 +1,21 @@
+import Coordinates from '../coordinates/Coordinates.js';
+import Edge from './Edge.js';
+import Node from './Node.js';
+
+class Projection {
+
+    /** @type {Coordinates} */
+    origin;
+
+    /** @type {number} */
+    distanceFromNearestElement;
+
+    /** @type {Coordinates} */
+    projection;
+
+    /** @type {Node|Edge} */
+    nearestElement;
+
+}
+
+export default Projection;

package/src/graph/Step.js

@@ -36,6 +36,16 @@ class Step {
     /** @type {number} */
     _length = 0;
 
+
+    /**
+     * @param {object} obj
+     */
+    constructor(obj) {
+        if (typeof obj === 'object') {
+            Object.assign(this, obj);
+        }
+    }
+
     /** @type {Node} */
     get node() {
         return this.nodes[0];

package/src/rotations/Attitude.js

@@ -12,9 +12,9 @@ class Attitude {
 
     /**
      *
-     * @param {Number[]} quaternion
-     * @param {Number} time
-     * @param {Number} accuracy
+     * @param {number[]} quaternion
+     * @param {number} time
+     * @param {number} accuracy
      */
     constructor(quaternion, time, accuracy) {
         this.quaternion = quaternion;
@@ -27,14 +27,14 @@ class Attitude {
     }
 
     /**
-     * @returns {Number[]}
+     * @returns {number[]}
      */
     get quaternion() {
         return this._quaternion;
     }
 
     /**
-     * @param {Number[]} quaternion
+     * @param {number[]} quaternion
      */
     set quaternion(quaternion) {
         if (!Array.isArray(quaternion)
@@ -48,14 +48,14 @@ class Attitude {
     }
 
     /**
-     * @returns {Number}
+     * @returns {number}
      */
     get time() {
         return this._time;
     }
 
     /**
-     * @param {Number} time
+     * @param {number} time
      */
     set time(time) {
         if (typeof time === 'number') {
@@ -69,14 +69,14 @@ class Attitude {
     }
 
     /**
-     * @returns {Number}
+     * @returns {number}
      */
     get accuracy() {
         return this._accuracy;
     }
 
     /**
-     * @param {Number} accuracy
+     * @param {number} accuracy
      */
     set accuracy(accuracy) {
         if (typeof accuracy === 'number' && accuracy >= 0 && accuracy <= Math.PI) {
@@ -89,6 +89,7 @@ class Attitude {
         }
     }
 
+    /** @type {number[]} */
     get eulerAngles() {
         if (this._eulerAngles === null) {
             this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
@@ -96,10 +97,12 @@ class Attitude {
         return this._eulerAngles;
     }
 
+    /** @type {number[]} */
     get eulerAnglesDegrees() {
         return this.eulerAngles.map(x => rad2deg(x));
     }
 
+    /** @type {number} */
     get heading() {
         if (this._heading === null) {
             let offset = 0;
@@ -111,6 +114,7 @@ class Attitude {
         return this._heading;
     }
 
+    /** @type {number} */
     get headingDegrees() {
         return rad2deg(this.heading);
     }
@@ -124,6 +128,7 @@ class Attitude {
 
         // Handle null comparison
         if (att1 === null && att1 === att2) {
+            // TODO not sure to return true here.
             return true;
         }
 
@@ -131,21 +136,39 @@ class Attitude {
             return false;
         }
 
+        if (att1 === att2) {
+            return true;
+        }
+
         return Quaternion.equalsTo(att1.quaternion, att2.quaternion);
     }
 
+    /**
+     * @param {Attitude} other
+     * @returns {boolean}
+     */
     equalsTo(other) {
         return Attitude.equalsTo(this, other);
     }
 
+    /**
+     * @returns {object}
+     */
     toJson() {
         return this.quaternion;
     }
 
+    /**
+     * @param {object} json
+     * @returns {Attitude}
+     */
     static fromJson(json) {
         return new Attitude(json);
     }
 
+    /**
+     * @returns {Attitude}
+     */
     clone() {
         return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
     }