@wemap/providers 3.1.17 → 3.1.19

package/package.json

@@ -8,11 +8,11 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^3.1.15",
-    "@wemap/graph": "^3.1.15",
+    "@wemap/geo": "^3.1.19",
+    "@wemap/graph": "^3.1.19",
     "@wemap/logger": "^3.0.0",
     "@wemap/maths": "^3.1.15",
-    "@wemap/osm": "^3.1.15",
+    "@wemap/osm": "^3.1.19",
     "@wemap/utils": "^3.1.5",
     "geomagnetism": "^0.1.0",
     "lodash.isempty": "^4.4.0",
@@ -65,6 +65,6 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "3.1.17",
-  "gitHead": "86f10be874c865261ae07521d64c31d7db1445f4"
+  "version": "3.1.19",
+  "gitHead": "4a4167fd2159c856b90e6a566595ae5945f92d2e"
 }

package/src/providers/position/absolute/AbsolutePositionProvider.js

@@ -19,13 +19,14 @@ import ProvidersOptions from '../../../ProvidersOptions';
 const ACCURACY_NEW_POS_EPS_RATIO = 1.5;
 const ACCURACY_RELOC_RATIO = 2;
 const MM_MAX_ANGLE = deg2rad(20);
-const MM_MAX_DIST = 15;
-const MM_MIN_DIST = 1;
+const MM_MAX_DIST = 30;
+const MM_MIN_DIST = 0;
 const MM_MIN_TIME = 0.4;
 
 class AbsolutePositionProvider extends MetaProvider {
 
     lastMMAttempt = -Infinity;
+    lastEventBearing = null;
 
     constructor() {
         super();
@@ -94,22 +95,47 @@ class AbsolutePositionProvider extends MetaProvider {
     }
 
     onAbsolutePosition(newPositionEvent, canContainLevel = true) {
-        if (this.lastEvent) {
+        let newPosition = newPositionEvent.data;
 
-            const newPosition = newPositionEvent.data;
-            const lastPosition = this.lastEvent.data;
+        if (!this._useNewAbsolutePosition(newPosition)) {
+            return;
+        }
+
+        if (this.lastEvent && !canContainLevel) {
+            newPosition.level = this.lastEvent.data.level;
+        }
+
+        if (this.lastEventBearing !== null) {
+            newPosition.bearing = this.lastEventBearing;
+        }
+
+        if (this._shouldHandleMapMatching()) {
+
+            let projectedPosition = null;
 
-            if (newPosition.distanceTo(lastPosition) < newPosition.accuracy * ACCURACY_NEW_POS_EPS_RATIO
-                && newPosition.accuracy > lastPosition.accuracy / ACCURACY_RELOC_RATIO) {
-                return;
+            // Firstly, if lastEvent bearing is known, try to use map-matching with bearing
+            if (newPosition.bearing !== null) {
+                projectedPosition = this._calcMapMatchingPosition(newPosition, true);
             }
 
-            if (!canContainLevel) {
-                newPosition.level = lastPosition.level;
+            // Secondly, if map-matching with bearing did not work, try MM on nodes (without bearing).
+            if (!projectedPosition) {
+                projectedPosition = this._calcMapMatchingPosition(newPosition, false);
             }
+
+            if (projectedPosition) {
+                newPosition = projectedPosition;
+            }
+        } else {
+            newPosition = newPosition.clone();
         }
 
-        this.notify(newPositionEvent.clone());
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            newPosition,
+            newPositionEvent
+        ));
+
     }
 
     /**
@@ -117,43 +143,76 @@ class AbsolutePositionProvider extends MetaProvider {
      */
     onAbsolutePositionFromRel(newPositionEvent) {
 
-        /**
-         * If map matching is not used or not set, raw position is returned
-         */
-        if (!ProvidersOptions.useMapMatching
-            || !this.mapMatching.network
-            || newPositionEvent.data.time - this.lastMMAttempt < MM_MIN_TIME) {
-            this.notify(newPositionEvent.clone());
-            return;
-        }
-        this.lastMMAttempt = newPositionEvent.data.time;
+        let newPosition = newPositionEvent.data;
 
-        const newPosition = newPositionEvent.data;
-        const projection = this.mapMatching.getProjection(newPosition, true, true);
-        if (!projection || !projection.projection) {
-            // If no projection has been found, returns the position without map-matching
-            this.notify(newPositionEvent.clone());
-            return;
-        }
+        this.lastEventBearing = newPosition.bearing;
 
-        const projectedPosition = newPosition.clone();
+        if (this._shouldHandleMapMatching()
+            && newPositionEvent.data.time - this.lastMMAttempt > MM_MIN_TIME) {
 
-        // Anyway, the projected level is used for new position
-        projectedPosition.level = projection.projection.level;
+            // Firstly, try map matching with bearing
+            const projectedPosition = this._calcMapMatchingPosition(newPosition, true);
+            if (projectedPosition) {
+                newPosition = projectedPosition;
+            }
+            // map matching without bearing is not used to allow user to leave the network.
 
-        // Do not use projection if it too close from itinerary,
-        //  this allows left/right movements (ie with ArCore)
-        if (projection.distanceFromNearestElement > this._mapMatchingMinDistance) {
-            projectedPosition.lat = projection.projection.lat;
-            projectedPosition.lng = projection.projection.lng;
+            this.lastMMAttempt = newPositionEvent.data.time;
+        } else {
+            newPosition = newPosition.clone();
         }
 
         this.notify(this.createEvent(
             EventType.AbsolutePosition,
-            projectedPosition,
+            newPosition,
             newPositionEvent
         ));
+    }
+
+    _useNewAbsolutePosition(newPosition) {
 
+        if (!this.lastEvent) {
+            return true;
+        }
+
+        const lastPosition = this.lastEvent.data;
+
+        if (newPosition.accuracy <= newPosition.distanceTo(lastPosition) / ACCURACY_NEW_POS_EPS_RATIO) {
+            return true;
+        }
+
+        if (newPosition.accuracy <= lastPosition.accuracy / ACCURACY_RELOC_RATIO) {
+            return true;
+        }
+
+        return false;
+
+    }
+
+    _shouldHandleMapMatching() {
+        return ProvidersOptions.useMapMatching && this.mapMatching.network;
+    }
+
+    _calcMapMatchingPosition(position, useBearing = true) {
+
+        const projection = this.mapMatching.getProjection(position, true, useBearing);
+        if (!projection || !projection.projection) {
+            return null;
+        }
+
+        // Do not use projection if it too close from itinerary,
+        //  this allows left/right movements (ie with ArCore)
+        if (projection.distanceFromNearestElement < this._mapMatchingMinDistance) {
+            return null;
+        }
+
+        // Do not user projection.projection directly, because position has some specific properties like bearing
+        const projectedPosition = position.clone();
+        projectedPosition.lat = projection.projection.lat;
+        projectedPosition.lng = projection.projection.lng;
+        projectedPosition.level = projection.projection.level;
+
+        return projectedPosition;
     }
 
     /**
@@ -175,6 +234,31 @@ class AbsolutePositionProvider extends MetaProvider {
             ));
         } else if (data instanceof Network || eventType === EventType.Network) {
             this.mapMatching.network = data;
+
+            if (this._shouldHandleMapMatching() && this.lastEvent) {
+
+                const position = this.lastEvent.data;
+                let projectedPosition = null;
+
+                // Firstly, if lastEvent bearing is known, try to use map-matching with bearing
+                if (position.bearing !== null) {
+                    projectedPosition = this._calcMapMatchingPosition(position, true);
+                }
+
+                // Secondly, if map-matching with bearing did not work, try MM on nodes (without bearing).
+                if (!projectedPosition) {
+                    projectedPosition = this._calcMapMatchingPosition(position, false);
+                }
+
+                if (projectedPosition) {
+                    this.notify(this.createEvent(
+                        EventType.AbsolutePosition,
+                        projectedPosition,
+                        this.lastEvent
+                    ));
+                }
+            }
+
         } else {
             throw new Error('Unknown feed object');
         }