@wemap/geo 0.3.7 → 0.3.9

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.3.7",
+    "version": "0.3.9",
     "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": "dfef19c363ee76ad4b4e23f9e36912034c10ccca"
+    "gitHead": "84a60e64b0968bc45f0f76cc26c08e165dbe6985"
 }

package/src/coordinates/Level.js

@@ -113,7 +113,7 @@ class Level {
             if (second.isInside(first.val)) {
                 return first;
             }
-            return first;
+            return null;
         }
         if (first.isRange && second.isRange) {
             const up = Math.min(first.up, second.up);

package/src/coordinates/Level.spec.js

@@ -119,6 +119,20 @@ describe('Level', () => {
         expect(Level.equalsTo(new Level(-1.5, 1).clone(), new Level(-1.5, 1))).true;
     });
 
+    it('isInside', () => {
+        expect(new Level(0).isInside(0)).true;
+        expect(new Level(1).isInside(0)).false;
+        expect(new Level(-1).isInside(0)).false;
+        expect(new Level(0).isInside(1)).false;
+        expect(new Level(0).isInside(-1)).false;
+        expect(new Level(0, 2).isInside(0)).true;
+        expect(new Level(0, 2).isInside(1)).true;
+        expect(new Level(0, 2).isInside(-1)).false;
+        expect(new Level(2, 0).isInside(0)).true;
+        expect(new Level(2, 0).isInside(1)).true;
+        expect(new Level(2, 0).isInside(-1)).false;
+    });
+
     it('intersect', () => {
         expect(Level.intersect(null, null)).is.null;
 
@@ -138,6 +152,8 @@ describe('Level', () => {
         expect(Level.equalsTo(Level.intersect(new Level(-3, -1), new Level(-1, 2)), new Level(-1)));
         expect(Level.intersect(new Level(-3, -2), new Level(-1, 2))).is.null;
         expect(Level.intersect(new Level(-1, 2), new Level(-3, -2))).is.null;
+        expect(Level.intersect(new Level(0), new Level(1, 2))).is.null;
+        expect(Level.intersect(new Level(1, 2), new Level(0))).is.null;
     });
 
     it('union', () => {
@@ -159,6 +175,8 @@ describe('Level', () => {
         expect(Level.equalsTo(Level.union(new Level(-3, -1), new Level(-1, 2)), new Level(-3, 2)));
         expect(Level.equalsTo(Level.union(new Level(-3, -2), new Level(-1, 2)), new Level(-3, 2)));
         expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(-3, -2)), new Level(-3, 2)));
+        expect(Level.equalsTo(Level.union(new Level(0), new Level(1, 2)), new Level(0, 2)));
+        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(0)), new Level(0, 2)));
     });
 
 });

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/MapMatching.spec.js

@@ -34,10 +34,6 @@ describe('MapMatching', () => {
     it('matching node levels', () => {
         let currentPosition, projection;
 
-        /**
-         * Projection on Nodes
-         */
-
         currentPosition = new WGS84(43.6091773, 3.8842584, null, null);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
@@ -57,10 +53,6 @@ describe('MapMatching', () => {
     it('matching edge levels', () => {
         let currentPosition, projection;
 
-        /**
-         * Projection on Edges
-         */
-
         currentPosition = new WGS84(43.6092811, 3.8842406, null, null);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
@@ -80,10 +72,6 @@ describe('MapMatching', () => {
     it('matching stairs nodes levels', () => {
         let currentPosition, projection;
 
-        /**
-         * Projection on Edges
-         */
-
         currentPosition = new WGS84(43.6093691, 3.8842057, null, null);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
@@ -103,10 +91,6 @@ describe('MapMatching', () => {
     it('matching stairs edge levels', () => {
         let currentPosition, projection;
 
-        /**
-         * Projection on Edges
-         */
-
         currentPosition = new WGS84(43.6093476, 3.8841978, null, null);
         projection = mapMatching.getProjection(currentPosition);
         expect(projection).is.null;
@@ -125,4 +109,25 @@ describe('MapMatching', () => {
 
     });
 
+    it('useMultiLevelSegments', () => {
+        let currentPosition, projection;
+
+        // On Nodes
+
+        currentPosition = new WGS84(43.6093691, 3.8842057, null, new Level(0));
+        projection = mapMatching.getProjection(currentPosition, true, false, false);
+        expect(projection).is.null;
+
+        // Next two are complex cases and not yet handled by our system
+
+        // currentPosition = new WGS84(43.6093691, 3.8842057, null, new Level(1));
+        // projection = mapMatching.getProjection(currentPosition, true, false, false);
+        // expect(projection.nearestElement).equals(nodes[14]);
+
+        // currentPosition = new WGS84(43.6093691, 3.8842057, null, new Level(2));
+        // projection = mapMatching.getProjection(currentPosition, true, false, false);
+        // expect(projection.nearestElement).equals(nodes[11]);
+
+    });
+
 });