@wemap/providers 9.0.8 → 9.0.10

package/package.json

@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.0.8",
-  "gitHead": "68d42075fd79592fb762747c41a86d930a800625"
+  "version": "9.0.10",
+  "gitHead": "5801f314c614dacef96bf837dc713716d5f17a5a"
 }

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

@@ -1,4 +1,4 @@
-import { UserPosition, GeoRelativePosition } from '@wemap/geo';
+import { UserPosition, GeoRelativePosition, Level } from '@wemap/geo';
 import { PromiseUtils, TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -20,6 +20,9 @@ class AbsolutePosition extends Provider {
     /** @type {boolean} */
     static USE_MM_FOR_FEED = true;
 
+    /** @type {boolean} */
+    useAllAbsolutePositions = false;
+
     /** @type {number?} */
     _gnssWifiProviderId;
 
@@ -50,10 +53,18 @@ class AbsolutePosition extends Provider {
      * @override
      */
     get _availability() {
-        return PromiseUtils.any([
+
+        const providersToCheck = [
             GeoRelativePositionProvider.availability,
             GnssWifi.availability
-        ]);
+        ];
+        if (ProvidersOptions.hasPoleStar) {
+            providersToCheck.push(PoleStar.availability);
+        }
+        if (ProvidersOptions.hasVps) {
+            providersToCheck.push(Vps.availability);
+        }
+        return PromiseUtils.any(providersToCheck);
     }
 
 
@@ -146,6 +157,54 @@ class AbsolutePosition extends Provider {
         MapMatchingHandler.removeEventListener(this._mapMatchingHandlerId);
     }
 
+    /**
+     * @param {ProviderEvent<UserPosition>} newPositionEvent
+     * @param {boolean} canContainLevel
+     * @returns {boolean}
+     */
+    _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent, canContainLevel = true) {
+
+        const newPosition = newPositionEvent.data;
+        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
+
+        // 1. Verifiy if it is the first known absolute position
+        if (!lastPosition) {
+            return true;
+        }
+
+        // 2. Is the new position accuracy is better enough than the last position accuracy
+        const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+        if (isBetterEnough) {
+            return true;
+        }
+
+        // 3.a. Is the new position is far from the new one (regarding accuracy)
+        // This condition return true if the two positions accuracy circles does not intersect.
+        // This is important if the person put the current page in the background during a while. But,
+        //  could be dangerous if two providers do not provide close positions (ping-pong effect). This
+        //  is why the 3.b. condition has been added.
+        // TODO: add a routine to augment the current position accuracy when the page is in background
+        const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
+
+        // 3.b. Added on 16/06/22
+        // The goal of this condition is to avoid continuous jumps between positions from two providers
+        // (i.e. GnssWifi and PoleStar)
+        const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy <= lastPosition.accuracy;
+
+        if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
+            return true;
+        }
+
+        // 4. Added on 23/06/22
+        // The goal of this condition is to take into account levels change when map-matching is not enabled / set
+        const isChangingLevel = canContainLevel && !Level.equals(newPosition.level, lastPosition.level);
+        if (isChangingLevel) {
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * @param {ProviderEvent<UserPosition>} positionEvent
      * @param {boolean} canContainLevel
@@ -153,22 +212,15 @@ class AbsolutePosition extends Provider {
      */
     _onAbsolutePosition(positionEvent, canContainLevel = true) {
 
+        if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel)
+            && !this.useAllAbsolutePositions) {
+            return false;
+        }
+
         const newPosition = positionEvent.data.clone();
         const lastPosition = this.lastEvent ? this.lastEvent.data : null;
 
         if (lastPosition) {
-
-            // Is the new position accuracy is better enough than the last position accuracy
-            const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
-
-            // Is the new position is far from the new one (regarding accuracy)
-            // This is important if the person put the current page in the background during a while
-            const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
-
-            if (!isBetterEnough && !isFarEnough) {
-                return false;
-            }
-
             if (!canContainLevel) {
                 newPosition.level = lastPosition.level;
             }

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

@@ -1,6 +1,7 @@
 /* eslint-disable no-bitwise */
 
 import { UserPosition } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -97,7 +98,7 @@ class PoleStar extends Provider {
                     json.alt / 5,
                     timestamp,
                     json.accuracy,
-                    json.bearing,
+                    deg2rad(json.bearing),
                     this.pname);
 
                 this.notify(this.createEvent(

package/src/providers/vision/Vps.js

@@ -163,6 +163,14 @@ class Vps extends Provider {
             );
             const attitude = new Attitude(deviceQuaternion, res.attitude.time, res.attitude.accuracy);
 
+            // [16/06/22] Force VPS accuracy to 5m if the information does not exist
+            // this allows to correctly fuse positions from different providers (VPS,
+            // GnssWifi, Pole Star...)
+            const devicePosition = res.userPosition.clone();
+            if (devicePosition.accuracy === null) {
+                devicePosition.accuracy = 5;
+            }
+
             // 5. Finally, notify the listeners if the VPS is not stopped
             if (this.state === ProviderState.STOPPED) {
                 break;
@@ -170,7 +178,7 @@ class Vps extends Provider {
 
             this.notify(
                 this.createEvent(EventType.AbsoluteAttitude, attitude),
-                this.createEvent(EventType.AbsolutePosition, res.userPosition)
+                this.createEvent(EventType.AbsolutePosition, devicePosition)
             );
 
         }