@wemap/providers 3.1.16 → 3.1.18

package/package.json

@@ -65,6 +65,6 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "3.1.16",
-  "gitHead": "8238894f4e451bc5bf0b9e1ebaf32053c237e64c"
+  "version": "3.1.18",
+  "gitHead": "faa44f5a027616ce6b61be6bb90be996543e133c"
 }

package/src/ProvidersInterface.js

@@ -129,27 +129,27 @@ class ProvidersInterface {
     }
 
     static get mapMatchingMaxDistance() {
-        return AbsolutePosition.mapMatching.maxDistance;
+        return AbsolutePosition.mapMatchingMaxDistance;
     }
 
     static set mapMatchingMaxDistance(maxDistance) {
-        AbsolutePosition.mapMatching.maxDistance = maxDistance;
+        AbsolutePosition.mapMatchingMaxDistance = maxDistance;
     }
 
     static get mapMatchingMinDistance() {
-        return AbsolutePosition.mapMatching.minDistance;
+        return AbsolutePosition.mapMatchingMinDistance;
     }
 
     static set mapMatchingMinDistance(minDistance) {
-        AbsolutePosition.mapMatching.minDistance = minDistance;
+        AbsolutePosition.mapMatchingMinDistance = minDistance;
     }
 
     static get mapMatchingMaxAngleBearing() {
-        return AbsolutePosition.mapMatching.maxAngleBearing;
+        return AbsolutePosition.mapMatchingMaxAngleBearing;
     }
 
     static set mapMatchingMaxAngleBearing(maxAngleBearing) {
-        AbsolutePosition.mapMatching.maxAngleBearing = maxAngleBearing;
+        AbsolutePosition.mapMatchingMaxAngleBearing = maxAngleBearing;
     }
 }
 

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

@@ -19,19 +19,21 @@ 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();
         this.mapMatching = new MapMatching();
         this.mapMatching.maxDistance = MM_MAX_DIST;
         this.mapMatching.maxAngleBearing = MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MM_MIN_DIST;
     }
 
     /**
@@ -93,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 (newPosition.distanceTo(lastPosition) < newPosition.accuracy * ACCURACY_NEW_POS_EPS_RATIO
-                && newPosition.accuracy > lastPosition.accuracy / ACCURACY_RELOC_RATIO) {
-                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;
+
+            // 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
+        ));
+
     }
 
     /**
@@ -116,45 +143,78 @@ 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 > MM_MIN_DIST) {
-            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;
+    }
+
     /**
      * @override
      * @param {UserPosition | Network} data
@@ -174,12 +234,60 @@ 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');
         }
 
     }
 
+    get mapMatchingMaxDistance() {
+        return this.mapMatching.maxDistance;
+    }
+
+    set mapMatchingMaxDistance(maxDistance) {
+        this.mapMatching.maxDistance = maxDistance;
+    }
+
+    get mapMatchingMinDistance() {
+        return this._mapMatchingMinDistance;
+    }
+
+    set mapMatchingMinDistance(minDistance) {
+        this._mapMatchingMinDistance = minDistance;
+    }
+
+    get mapMatchingMaxAngleBearing() {
+        return this.mapMatching.maxAngleBearing;
+    }
+
+    set mapMatchingMaxAngleBearing(maxAngleBearing) {
+        this.mapMatching.maxAngleBearing = maxAngleBearing;
+    }
 }
 
 export default AbsolutePositionProvider;