@wemap/providers 9.1.0 → 9.1.1

package/package.json

@@ -9,13 +9,13 @@
   ],
   "dependencies": {
     "@wemap/camera": "^9.0.8",
-    "@wemap/geo": "^9.0.6",
+    "@wemap/geo": "^9.1.1",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^9.0.0",
-    "@wemap/map": "^9.0.6",
+    "@wemap/map": "^9.1.1",
     "@wemap/maths": "^9.0.0",
-    "@wemap/osm": "^9.0.6",
-    "@wemap/routers": "^9.0.6",
+    "@wemap/osm": "^9.1.1",
+    "@wemap/routers": "^9.1.1",
     "@wemap/utils": "^9.0.0"
   },
   "description": "A package using different geoloc systems",
@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.1.0",
-  "gitHead": "af24605a74542ee339618c979f24da61e194f6f0"
+  "version": "9.1.1",
+  "gitHead": "bf6a54cf4f886ebac773549339ada8f98c0b7f7f"
 }

package/src/mapmatching/MapMatchingHandler.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-statements */
 import {
-    AbsoluteHeading, GraphEdge, MapMatching, Network, GraphProjection, UserPosition
+    AbsoluteHeading, GraphEdge, Level, MapMatching, Network, GraphProjection, UserPosition
 } from '@wemap/geo';
 import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
 import { Itinerary } from '@wemap/routers';
@@ -40,6 +40,9 @@ class MapMatchingHandler extends Provider {
     /** @type {number} in meters */
     static DEFAULT_MM_HUGE_JUMP_DISTANCE = 3;
 
+    /** @type {number} in meters */
+    static DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE = 2;
+
     /** @type {number} */
     static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
@@ -67,6 +70,9 @@ class MapMatchingHandler extends Provider {
     /** @type {number} */
     _hugeJumpDistance = MapMatchingHandler.DEFAULT_MM_HUGE_JUMP_DISTANCE;
 
+    /** @type {number} */
+    _disableMMCloseToATurnDistance = MapMatchingHandler.DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE;
+
     /** @type {number} */
     _minStepsBetweenOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING;
 
@@ -364,6 +370,13 @@ class MapMatchingHandler extends Provider {
                 return true;
             }
 
+            // Detector to avoid map-matching close to network turns
+            if (this._disableMMCloseToATurnDistance > 0
+                && this._hasTurnInCircle(projection.projection, this._disableMMCloseToATurnDistance)) {
+                AbsolutePosition.notify(positionEvent);
+                return true;
+            }
+
             AbsolutePosition.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 projection.projection,
@@ -464,6 +477,41 @@ class MapMatchingHandler extends Provider {
         );
     }
 
+    /**
+     * @param {GraphNode} node
+     * @returns {boolean}
+     */
+    _nodeHasTurn(node) {
+        const { edges } = node;
+        for (let i = 0; i < edges.length; i++) {
+            for (let j = i + 1; j < edges.length; j++) {
+                const angle = diffAngleLines(edges[i].bearing, edges[j].bearing);
+                if (angle > MapMatchingHandler.DEFAULT_MM_MAX_ANGLE) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * @param {Coordinates} center
+     * @param {number} radius
+     * @returns {boolean}
+     */
+    _hasTurnInCircle(center, radius) {
+        /** @type {Network} */
+        const network = this._mapMatching.network;
+        if (!network) {
+            return false;
+        }
+
+        return network.nodes.filter(node =>
+            node.coords.distanceTo(center) <= radius
+            && Level.intersect(node.coords.level, center.level)
+        ).some(this._nodeHasTurn);
+    }
+
     /**
      * @param {Projection} projection
      */
@@ -560,6 +608,14 @@ class MapMatchingHandler extends Provider {
         this._hugeJumpDistance = hugeJumpDistance;
     }
 
+    get disableMMCloseToATurnDistance() {
+        return this._disableMMCloseToATurnDistance;
+    }
+
+    set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance) {
+        this._disableMMCloseToATurnDistance = disableMMCloseToATurnDistance;
+    }
+
     get useOrientationMatching() {
         return this._useOrientationMatching;
     }

package/src/mapmatching/MapMatchingHandler.spec.js

@@ -0,0 +1,136 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import { Coordinates, Network } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+import { Itinerary } from '@wemap/routers';
+import MMH from './MapMatchingHandler.js';
+
+
+const { expect } = chai;
+
+describe('MapMatchingHandler', () => {
+
+    const p0 = new Coordinates(0, 0, null, 0);
+    const p1 = p0.destinationPoint(5, 0);
+    const p2 = p1.destinationPoint(5, Math.PI / 2);
+    const p3 = p1.destinationPoint(10, 0);
+    const p4 = p0.destinationPoint(2, deg2rad(10));
+
+    const pos1 = p0.clone();
+    const pos2 = pos1.destinationPoint(3, 0);
+    const pos3 = pos2.destinationPoint(10, 0);
+
+    it('_hasTurnInCircle - itinerary', () => {
+
+        expect(MMH._hasTurnInCircle(pos1, Number.MAX_VALUE)).is.false;
+
+        // p4 -> p1 -> p2 is a turn
+        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p2]);
+
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p0))).is.false;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p2))).is.false;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
+
+        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
+
+        // Straight line
+        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p3]);
+
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.false;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
+
+        expect(MMH._hasTurnInCircle(pos1, 10)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
+        expect(MMH._hasTurnInCircle(pos3, 10)).is.false;
+
+    });
+
+
+    it('_hasTurnInCircle - network', () => {
+
+        // p1 has turns
+        MMH.network = Network.fromCoordinates([[p0, p4, p1], [p1, p2], [p3, p1]]);
+
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
+
+        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
+
+    });
+
+    const p10 = new Coordinates(0, 0, null, 1);
+    const p11 = p10.destinationPoint(5, 0);
+    const p12 = p11.destinationPoint(5, Math.PI / 2);
+    const p13 = p11.destinationPoint(10, 0);
+
+    const pos12 = p10.clone().destinationPoint(3, 0);
+    const pos012 = new Coordinates(0, 0, null, [0, 1]).destinationPoint(3, 0);
+
+    it('_hasTurnInCircle - multi-levels', () => {
+
+        // level 1 is a straight line
+        MMH.network = Network.fromCoordinates([
+            [p0, p4, p1], [p1, p2], [p3, p1],
+            [p10, p11, p13]
+        ]);
+
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p11))).is.false;
+
+        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos12, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos12, 10)).is.false;
+        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
+
+        // Changing level
+        // straight line
+        MMH.network = Network.fromCoordinates([
+            [p0, p4, p11], [p11, p13]
+        ]);
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
+        expect(MMH._hasTurnInCircle(pos2, Number.MAX_VALUE)).is.false;
+        expect(MMH._hasTurnInCircle(pos12, Number.MAX_VALUE)).is.false;
+        expect(MMH._hasTurnInCircle(pos012, Number.MAX_VALUE)).is.false;
+
+        // Changing level
+        // turn in p11
+        MMH.network = Network.fromCoordinates([
+            [p0, p4, p11], [p11, p12], [p11, p13]
+        ]);
+
+        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p11))).is.true;
+        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 3)).is.false;
+        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
+        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos12, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos12, 10)).is.true;
+        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
+        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
+        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
+
+    });
+
+});