@wemap/providers 9.0.0-alpha.6 → 9.0.0-alpha.8

package/package.json

@@ -15,7 +15,7 @@
     "@wemap/map": "^9.0.0-alpha.5",
     "@wemap/maths": "^9.0.0-alpha.5",
     "@wemap/osm": "^9.0.0-alpha.5",
-    "@wemap/routers": "^9.0.0-alpha.5",
+    "@wemap/routers": "^9.0.0-alpha.7",
     "@wemap/utils": "^8.1.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.0.0-alpha.6",
-  "gitHead": "83720aadf51038f8d98d87d57ff8652d9cab92d6"
+  "version": "9.0.0-alpha.8",
+  "gitHead": "c97c40263762c8c8739e5b3855fea1f59a5d9083"
 }

package/src/mapmatching/MapMatchingHandler.js

@@ -256,6 +256,7 @@ class MapMatchingHandler extends Provider {
 
     /**
      * @param {ProviderEvent<UserPosition>} positionEvent
+     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
      */
     notifyPositionFromAbsolute(positionEvent) {
 
@@ -273,7 +274,7 @@ class MapMatchingHandler extends Provider {
                 // In this case, the newPosition is far enough and can be used safely.
                 AbsolutePosition.notify(positionEvent);
             }
-            return;
+            return true;
         }
 
         // newPosition must not be used after this line
@@ -282,12 +283,12 @@ class MapMatchingHandler extends Provider {
 
         // In case of a huge jump, be sure the user is in a straight line
         if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
-            return;
+            return false;
         }
 
         // Detector to avoid big jumps in the wrong direction
         if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
-            return;
+            return false;
         }
 
         AbsolutePosition.notify(this.createEvent(
@@ -297,12 +298,13 @@ class MapMatchingHandler extends Provider {
         ));
 
         this.tryOrientationMatching(projectionWithBearing);
-
+        return true;
     }
 
 
     /**
      * @param {ProviderEvent<UserPosition>} positionEvent
+     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
      */
     notifyPositionFromRelative(positionEvent) {
 
@@ -310,7 +312,7 @@ class MapMatchingHandler extends Provider {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
             this._lastProjections = [];
             AbsolutePosition.notify(positionEvent);
-            return;
+            return true;
         }
 
         const newPosition = positionEvent.data;
@@ -328,19 +330,19 @@ class MapMatchingHandler extends Provider {
             // In case of a huge jump, be sure the user is in a straight line
             if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
                 AbsolutePosition.notify(positionEvent);
-                return;
+                return true;
             }
 
             // Detector to avoid big jumps in the wrong direction
             if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
                 AbsolutePosition.notify(positionEvent);
-                return;
+                return true;
             }
 
             // Do not use projection if the neareast element is not the same direction than previous
             if (!this._areLastProjectionsInTheSameDirection()) {
                 AbsolutePosition.notify(positionEvent);
-                return;
+                return true;
             }
 
             AbsolutePosition.notify(this.createEvent(
@@ -350,55 +352,60 @@ class MapMatchingHandler extends Provider {
             ));
             this.tryOrientationMatching(projection);
 
-        } else {
-
-            // Sometimes, the newPosition.bearing diverges due to the Absolute Attitude offset
-            // and the Orientation Matching. So, we created this detector to check if projection
-            // with bearing from "AbsoluteAttitudeFromBrowser" is better than the current bearing.
-            // /!\ This works only if the user is waking in the same direction than the smartphone orientation /!\
-            if (StraightLineDetector.isStraight()) {
+            return true;
 
-                const testedPosition = newPosition.clone();
-                testedPosition.bearing = AbsoluteAttitudeFromBrowser.lastEvent.data.heading;
-                const projectionWithAbs = this.getProjection(testedPosition, true, true);
+        }
+        // else {
 
-                if (projectionWithAbs) {
+        // Sometimes, the newPosition.bearing diverges due to the Absolute Attitude offset
+        // and the Orientation Matching. So, we created this detector to check if projection
+        // with bearing from "AbsoluteAttitudeFromBrowser" is better than the current bearing.
+        // /!\ This works only if the user is waking in the same direction than the smartphone orientation /!\
+        if (StraightLineDetector.isStraight()) {
 
-                    this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
-                    if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
-                        AbsolutePosition.notify(positionEvent);
-                        return;
-                    }
+            const testedPosition = newPosition.clone();
+            testedPosition.bearing = AbsoluteAttitudeFromBrowser.lastEvent.data.heading;
+            const projectionWithAbs = this.getProjection(testedPosition, true, true);
 
-                    this._lastProjections.push(projectionWithAbs);
-                    if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
-                        this._lastProjections.shift();
-                    }
+            if (projectionWithAbs) {
 
+                this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
+                if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
+                    AbsolutePosition.notify(positionEvent);
+                    return true;
+                }
 
-                    if (!this._areLastProjectionsInTheSameDirection()) {
-                        AbsolutePosition.notify(positionEvent);
-                        return;
-                    }
+                this._lastProjections.push(projectionWithAbs);
+                if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
+                    this._lastProjections.shift();
+                }
 
-                    AbsolutePosition.notify(this.createEvent(
-                        EventType.AbsolutePosition,
-                        projectionWithAbs.projection,
-                        [positionEvent]
-                    ));
 
-                    this.tryOrientationMatching(projectionWithAbs);
-                    return;
+                if (!this._areLastProjectionsInTheSameDirection()) {
+                    AbsolutePosition.notify(positionEvent);
+                    return true;
                 }
-            }
 
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections = [];
+                AbsolutePosition.notify(this.createEvent(
+                    EventType.AbsolutePosition,
+                    projectionWithAbs.projection,
+                    [positionEvent]
+                ));
 
-            // If no projection found with both projection methods, simply use the newPosition.
-            AbsolutePosition.notify(positionEvent);
+                this.tryOrientationMatching(projectionWithAbs);
+                return true;
+            }
         }
 
+        this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+        this._lastProjections = [];
+
+        // If no projection found with both projection methods, simply use the newPosition.
+        AbsolutePosition.notify(positionEvent);
+        return true;
+
+        // }
+
     }
 
     /**

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

@@ -1,5 +1,5 @@
 import { UserPosition, GeoRelativePosition } from '@wemap/geo';
-import { PromiseUtils } from '@wemap/utils';
+import { PromiseUtils, TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
@@ -20,6 +20,12 @@ class AbsolutePosition extends Provider {
     /** @type {boolean} */
     static USE_MM_FOR_FEED = true;
 
+    // /** @type {number} */
+    // static POLESTAR_TIME_DISCARD_GNSSWIFI_FROM_LAST_FIX = 3000;
+
+    // /** @type {number} */
+    // static GNSSWIFI_DISCARD_POLESTAR_IF_ACCURACY_RATIO_BETTER_THAN = 2;
+
 
     /** @type {number?} */
     _gnssWifiProviderId;
@@ -28,11 +34,14 @@ class AbsolutePosition extends Provider {
     _relativePositionProviderId;
 
     /** @type {number?} */
-    _mapMatchingHandlerId
+    _mapMatchingHandlerId;
 
     /** @type {boolean?} */
     _waitUntilNextVpsPosition = false;
 
+    // /** @type {?number} */
+    // _lastPolestarFix;
+
     /**
     * @override
     */
@@ -84,6 +93,25 @@ class AbsolutePosition extends Provider {
 
             this._gnssWifiProviderId = GnssWifi.addEventListener(
                 events => {
+                    // const useLevel = false;
+                    // if (typeof this._lastPolestarFix !== 'undefined'
+                    //     && TimeUtils.preciseTime() - this._lastPolestarFix < AbsolutePosition.POLESTAR_TIME_DISCARD_GNSSWIFI_FROM_LAST_FIX) {
+                    //     // Discard the GNSSWifi position if the last Polestar position is too recent
+                    //     console.log(`[Dev] Formula - PS: ${PoleStar.lastEvent.data.accuracy},
+                    //         GNSSWifi: ${events[0].data.accuracy},
+                    //         ratio: ${PoleStar.lastEvent.data.accuracy / events[0].data.accuracy}`);
+                    //     if (PoleStar.lastEvent.data.accuracy / events[0].data.accuracy > AbsolutePosition.GNSSWIFI_DISCARD_POLESTAR_IF_ACCURACY_RATIO_BETTER_THAN) {
+                    //         // Except if the accuracy of the Polestar position is really better than the GNSSWifi position
+                    //         // In this case we add the level provided by Pole Star to the position
+                    //         console.log(`[Dev] Apply PS level ${PoleStar.lastEvent.data.level} to GnssWifi`);
+                    //         events[0].data.level = PoleStar.lastEvent.data.level;
+                    //         useLevel = true;
+                    //     } else {
+                    //         console.log('[Dev] Discard GnssWifi fix with accuracy: ', events[0].data.accuracy);
+                    //         return;
+                    //     }
+                    // }
+                    // console.log('[Dev] Use GnssWifi fix with accuracy: ', events[0].data.accuracy);
                     // bearing from GnssWifi is not reliable for our usecase
                     events[0].data.bearing = null;
                     this._onAbsolutePosition(events[0], false);
@@ -94,7 +122,28 @@ class AbsolutePosition extends Provider {
 
         if (ProvidersOptions.hasPoleStar) {
             this._polestarProviderId = PoleStar.addEventListener(events => {
-                this._onAbsolutePosition(events.find(event => event.dataType === EventType.AbsolutePosition));
+
+                const polestarPositionEvent = events.find(event => event.dataType === EventType.AbsolutePosition);
+
+                this._lastPolestarFix = TimeUtils.preciseTime();
+                const psPositionUsed = this._onAbsolutePosition(polestarPositionEvent);
+
+                /**
+                 * In the case of a degraded position from PoleStar and a good position from GnssWifi,
+                 *  we still need to retrieve the level from PoleStar.
+                 * To do so, we duplicate lastEvent and add the level from PoleStar to the current
+                 *  position, then we notify with the new position.
+                 */
+                if (!psPositionUsed && this.lastEvent.data.level === null) {
+                    const lastPositionWithLevel = this.lastEvent.data.clone();
+                    lastPositionWithLevel.level = polestarPositionEvent.data.level;
+                    const leveledEvent = this.createEvent(
+                        EventType.AbsolutePosition,
+                        lastPositionWithLevel,
+                        [...this.lastEvent.providersStack, ...polestarPositionEvent.providersStack]
+                    );
+                    this.notify(leveledEvent);
+                }
             });
         }
 
@@ -129,6 +178,7 @@ class AbsolutePosition extends Provider {
     /**
      * @param {ProviderEvent<UserPosition>} positionEvent
      * @param {boolean} canContainLevel
+     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
      */
     _onAbsolutePosition(positionEvent, canContainLevel = true) {
 
@@ -145,7 +195,7 @@ class AbsolutePosition extends Provider {
             const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
 
             if (!isBetterEnough && !isFarEnough) {
-                return;
+                return false;
             }
 
             if (!canContainLevel) {
@@ -169,19 +219,20 @@ class AbsolutePosition extends Provider {
         // If the position bearing is null, do not use MM, it is too dangerous.
         if (!MapMatchingHandler.canUseMapMatching()) {
             this.notify(newPositionEvent);
-            return;
+            return true;
         }
 
-        MapMatchingHandler.notifyPositionFromAbsolute(newPositionEvent);
+        return MapMatchingHandler.notifyPositionFromAbsolute(newPositionEvent);
     }
 
     /**
      * @param {ProviderEvent<GeoRelativePosition>} relativeEvent
+     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
      */
     _onRelativePosition(relativeEvent) {
 
         if (!this.lastEvent || this._waitUntilNextVpsPosition) {
-            return;
+            return false;
         }
 
         const lastPosition = this.lastEvent.data;
@@ -207,10 +258,10 @@ class AbsolutePosition extends Provider {
 
         if (!MapMatchingHandler.canUseMapMatching()) {
             this.notify(newPositionEvent);
-            return;
+            return true;
         }
 
-        MapMatchingHandler.notifyPositionFromRelative(newPositionEvent);
+        return MapMatchingHandler.notifyPositionFromRelative(newPositionEvent);
     }
 
 

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

@@ -96,8 +96,7 @@ class PoleStar extends Provider {
                     Constants.DEFAULT_ALTITUDE,
                     json.alt / 5,
                     timestamp,
-                    // Hack to take more positions from PoleStar
-                    json.accuracy / 2,
+                    json.accuracy,
                     json.bearing,
                     this.pname);