@wemap/geo 0.3.6 → 0.3.8

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.3.6",
+    "version": "0.3.8",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -31,5 +31,5 @@
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "32a1062949091aeb9ab107da3e75bc69589538ba"
+    "gitHead": "6e107eebc85ff97f17371feac903ddb53657678b"
 }

package/src/coordinates/WGS84UserPosition.js

@@ -19,16 +19,7 @@ class WGS84UserPosition extends WGS84 {
 
     // Create a WGS84UserPosition with lat, lng, alt from WGS84 coordinates and
     //   other fields from another WGS84UserPosition
-    static fromWGS84(wgs84Coordinates, userPosition) {
-
-        if (userPosition) {
-            return new WGS84UserPosition(
-                wgs84Coordinates.lat, wgs84Coordinates.lng,
-                wgs84Coordinates.alt, wgs84Coordinates.level,
-                userPosition.time, userPosition.accuracy,
-                userPosition.bearing, userPosition.provider);
-        }
-
+    static fromWGS84(wgs84Coordinates) {
         return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng,
             wgs84Coordinates.alt, wgs84Coordinates.level);
     }

package/src/graph/MapMatching.js

@@ -1,5 +1,5 @@
 /* eslint-disable max-statements */
-/* eslint-disable complexity */
+
 import isNumber from 'lodash.isnumber';
 
 import { rad2deg } from '@wemap/maths';
@@ -35,7 +35,53 @@ class MapMatching {
         this.network = network;
     }
 
-    getProjection(location, useDistance = false, useBearing = false, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
+    /**
+     * Check if the specified edge and its nodes can be used for projection
+     * @returns an array of two elements.
+     *  First is true if projection will be used on the specified edge, false otherwise.
+     *  Second is true if projection will be used on the nodes of the specified edge, false otherwise.
+     */
+    _shouldProjectOnEdgeAndNodes(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
+
+        if (!acceptEdgeFn(edge)) {
+            // if edge selection is not verified
+            return [false, false];
+        }
+
+        if (location.level && !location.level.intersect(edge.level)
+            || !location.level && edge.level) {
+            // if location level is defined and do not intersect targeted level
+            return [false, false];
+        }
+
+        // ignore MultiLevelSegments if option used
+        const checkEdge = !(!useMultiLevelSegments && edge.level && edge.level.isRange);
+
+        if (useBearing) {
+            // if mapmatching bearing is enabled do not use nodes matching
+            if (checkEdge) {
+                // condition for optimisation
+                const edgeBearing = rad2deg(edge.bearing);
+                const diffAngle = MapMatching.diffAngle90(edgeBearing, location.bearing);
+                if (diffAngle > this._maxAngleBearing) {
+                    // Do not try to project if angle is greater than the threshold
+                    return [false, false];
+                }
+            }
+            return [checkEdge, false];
+        }
+
+        return [checkEdge, true];
+    }
+
+    static _updateProjectionLevelFromEdge = (_edge, _projection) => {
+        if (_edge.level) {
+            _projection.level = _edge.level.clone();
+        }
+    };
+
+    getProjection(location, useDistance = false, useBearing = false,
+        useMultiLevelSegments = true, acceptEdgeFn = () => true) {
 
         if (!this.network) {
             return null;
@@ -49,70 +95,52 @@ class MapMatching {
             return null;
         }
 
-        const updateProjectionLevelFromEdge = (_edge, _projection) => {
-            if (_edge.level) {
-                _projection.level = _edge.level.clone();
-            }
-        };
-
         const projection = {};
         projection.origin = location;
         projection.distanceFromNearestElement = Number.MAX_VALUE;
 
+        const isProjectionBetter = (distanceOfNewProjection) => {
+            return distanceOfNewProjection < projection.distanceFromNearestElement
+                && (!useDistance || distanceOfNewProjection <= this._maxDistance);
+        };
+
         for (let i = 0; i < this.network.edges.length; i++) {
             const edge = this.network.edges[i];
 
-            if (!acceptEdgeFn(edge)) {
-                continue;
-            }
+            const [checkEdge, checkNodes] = this._shouldProjectOnEdgeAndNodes(
+                edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn);
 
-            if (!useMultiLevelSegments && edge.level && edge.level.isRange) {
-                continue;
-            }
-
-            if (location.level && !location.level.intersect(edge.level)
-                || !location.level && edge.level) {
-                continue;
-            }
-
-            if (useBearing) {
-                const edgeBearing = rad2deg(edge.bearing);
-                const diffAngle = MapMatching.diffAngle90(edgeBearing, location.bearing);
-                if (diffAngle > this._maxAngleBearing) {
-                    continue;
-                }
-            } else {
+            if (checkNodes) {
                 // Check node 1
                 const distNode1 = location.distanceTo(edge.node1.coords);
-                if (distNode1 < projection.distanceFromNearestElement
-                    && (!useDistance || distNode1 <= this._maxDistance)) {
+                if (isProjectionBetter(distNode1)) {
                     projection.distanceFromNearestElement = distNode1;
                     projection.nearestElement = edge.node1;
                     projection.projection = edge.node1.coords.clone();
-                    updateProjectionLevelFromEdge(edge, projection.projection);
+                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
                 }
 
                 // Check node 2
                 const distNode2 = location.distanceTo(edge.node2.coords);
-                if (distNode2 < projection.distanceFromNearestElement
-                    && (!useDistance || distNode2 <= this._maxDistance)) {
+                if (isProjectionBetter(distNode2)) {
                     projection.distanceFromNearestElement = distNode2;
                     projection.nearestElement = edge.node2;
                     projection.projection = edge.node2.coords.clone();
-                    updateProjectionLevelFromEdge(edge, projection.projection);
+                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
                 }
             }
 
-            // Check edge
-            const segmentProjection = location.getProjection(edge);
-            if (segmentProjection) {
-                updateProjectionLevelFromEdge(edge, segmentProjection);
-                const distEdge = location.distanceTo(segmentProjection);
-                if (distEdge < projection.distanceFromNearestElement
-                    && (!useDistance || distEdge <= this._maxDistance)) {
-                    projection.distanceFromNearestElement = distEdge;
-                    projection.nearestElement = edge;
-                    projection.projection = segmentProjection.clone();
+            if (checkEdge) {
+                // Check edge
+                const segmentProjection = location.getProjection(edge);
+                if (segmentProjection) {
+                    const distEdge = location.distanceTo(segmentProjection);
+                    if (isProjectionBetter(distEdge)) {
+                        projection.distanceFromNearestElement = distEdge;
+                        projection.nearestElement = edge;
+                        projection.projection = segmentProjection.clone();
+                        MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
+                    }
                 }
             }
         }

package/src/graph/Network.js

@@ -23,7 +23,7 @@ class Network {
         );
     }
 
-    toString(_nodeToStringFn, _edgeToStringFn) {
+    toDetailedString(_nodeToStringFn, _edgeToStringFn) {
 
         let nodeToStringFn = _nodeToStringFn;
         if (!nodeToStringFn) {