@wemap/providers 3.3.0 → 4.0.0

package/src/providers/attitude/absolute/AbsoluteAttitudeFusedProvider.js

@@ -0,0 +1,166 @@
+import { Attitude, Edge } from '@wemap/geo';
+import {
+    Quaternion, diffAngle
+} from '@wemap/maths';
+
+import Provider from '../../Provider.js';
+import EventType from '../../../events/EventType.js';
+import { RelativeAttitude } from '../../../Providers.js';
+import ProviderState from '../../ProviderState.js';
+
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+class AbsoluteAttitudeFusedProvider extends Provider {
+
+    accuracy = 0;
+    isInitialized = false;
+
+    /** @type {number[]} quaternion */
+    zOffset = null;
+
+    /**
+     * @override
+     */
+    static get pname() {
+        return 'AbsoluteAttitudeFused';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        // TODO Enhance
+        return RelativeAttitude.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.relativeAttitudeProviderId = RelativeAttitude.addEventListener(
+            events => this.onRelativeAttitudeEvent(events[0]),
+            error => this.notifyError(error)
+        );
+
+
+        // this.onAbsoluteAttitudeEvent(AbsoluteAttitude.lastEvent);
+        // this.absoluteAttitudeProviderId = AbsoluteAttitude.addEventListener(
+        //     events => this.onAbsoluteAttitudeEvent(events[0]),
+        //     error => this.notifyError(error),
+        //     false
+        // );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        RelativeAttitude.removeEventListener(this.relativeAttitudeProviderId);
+        // AbsoluteAttitude.removeEventListener(this.absoluteAttitudeProviderId);
+    }
+
+    mapMatching(projection) {
+
+        if (this.state !== ProviderState.STARTED) {
+            return;
+        }
+
+        const {
+            nearestElement, origin
+        } = projection;
+        if (!(nearestElement instanceof Edge)) {
+            return;
+        }
+
+        let matchingDirection;
+        const matchingDirectionAngle1 = diffAngle(nearestElement.bearing, origin.bearing);
+        const matchingDirectionAngle2 = diffAngle(nearestElement.bearing + Math.PI, origin.bearing);
+
+        if (Math.abs(matchingDirectionAngle1) < Math.abs(matchingDirectionAngle2)) {
+            matchingDirection = nearestElement.bearing;
+        } else {
+            matchingDirection = (nearestElement.bearing + Math.PI) % (2 * Math.PI);
+        }
+
+        this.accuracy = 0;
+
+        // preprocess zOffset for "compute" function
+        const currentHeading = this.relativeAttitudeEvent ? this.relativeAttitudeEvent.data.heading : 0;
+        this.zOffset = Quaternion.fromAxisAngle([0, 0, 1], -matchingDirection + currentHeading);
+
+        this.compute();
+    }
+
+    onRelativeAttitudeEvent(relativeAttitudeEvent) {
+
+        /**
+         * Calculate relative accuracy
+         */
+        if (this.relativeAttitudeEvent) {
+            const {
+                accuracy, time
+            } = relativeAttitudeEvent.data;
+            const diffTime = time - this.relativeAttitudeEvent.data.time;
+            this.accuracy += diffTime * accuracy;
+        }
+
+        this.relativeAttitudeEvent = relativeAttitudeEvent;
+        this.compute();
+    }
+
+
+    // onAbsoluteAttitudeEvent = absoluteAttitudeEvent => {
+
+    //     if (!absoluteAttitudeEvent) {
+    //         return;
+    //     }
+
+    //     /**
+    //      * Use absolute attitude events only when they are not from this provider
+    //      */
+    //     if (absoluteAttitudeEvent.providersStack.includes(this.pname)
+    //         || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFromBrowser.pname)) {
+    //         return;
+    //     }
+    //     this.absoluteAttitudeEvent = absoluteAttitudeEvent;
+    //     this.accuracy = 0;
+
+    //     // preprocess zOffset for "compute" function
+    //     const currentHeading = this.relativeAttitudeEvent ? this.relativeAttitudeEvent.data.heading : 0;
+    //     this.zOffset = Quaternion.fromAxisAngle([0, 0, 1], -absoluteAttitudeEvent.data.heading + currentHeading);
+    // };
+
+
+    compute() {
+        if (!this.zOffset || !this.relativeAttitudeEvent) {
+            return;
+        }
+
+        const {
+            quaternion, time
+        } = this.relativeAttitudeEvent.data;
+
+        const absoluteQuat = Quaternion.multiply(this.zOffset, quaternion);
+        const newAccuracy = Math.min(this.accuracy, Math.PI);
+        const attitude = new Attitude(absoluteQuat, time, newAccuracy, this.pname);
+
+        this.notify(this.createEvent(
+            EventType.AbsoluteAttitude,
+            attitude,
+            [this.relativeAttitudeEvent]
+        ));
+
+    }
+
+}
+
+export default AbsoluteAttitudeFusedProvider;

package/src/providers/attitude/absolute/AbsoluteAttitudeProvider.js

@@ -6,7 +6,7 @@ import { PromiseUtils } from '@wemap/utils';
 import MetaProvider from '../../MetaProvider.js';
 import EventType from '../../../events/EventType.js';
 import {
-    AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFromRelAtt
+    AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFromRelAtt, AbsoluteAttitudeFused
 } from '../../../Providers.js';
 
 
@@ -20,6 +20,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
 
         this.attitudeFromBrowserErrored = false;
         this.attitudeFromRelAttErrored = false;
+        this.attitudeFusedErrored = false;
     }
 
     /**
@@ -42,7 +43,8 @@ class AbsoluteAttitudeProvider extends MetaProvider {
     get _availability() {
         return PromiseUtils.any([
             AbsoluteAttitudeFromBrowser.availability,
-            AbsoluteAttitudeFromRelAtt.availability
+            AbsoluteAttitudeFromRelAtt.availability,
+            AbsoluteAttitudeFused.availability
         ]);
     }
 
@@ -66,28 +68,59 @@ class AbsoluteAttitudeProvider extends MetaProvider {
                 this.onError(error);
             }
         );
+
+        this.fusedProviderId = AbsoluteAttitudeFused.addEventListener(
+            events => this.onAttitudeFused(events[0]),
+            error => {
+                this.attitudeFusedErrored = true;
+                this.onError(error);
+            }
+        );
     }
 
     onError(error) {
-        if (this.attitudeFromBrowserErrored && this.attitudeFromRelAttErrored) {
+        if (this.attitudeFromBrowserErrored
+            && this.attitudeFromRelAttErrored
+            && this.attitudeFusedErrored) {
             this.notifyError(error);
         }
     }
 
     onAttitudeFromBrowser(event) {
         this.eventFromBrowser = event;
-        if (!this.eventFromRelAtt
-            || event.data.accuracy <= this.eventFromRelAtt.data.accuracy) {
-            this.notify(event.clone());
+
+
+        if (this.eventFromRelAtt && this.eventFromRelAtt.data.accuracy < event.data.accuracy) {
+            return;
+        }
+        if (this.eventFromFused && this.eventFromFused.data.accuracy < event.data.accuracy) {
+            return;
         }
+        this.notify(event.clone());
     }
 
     onAttitudeFromRelAtt(event) {
         this.eventFromRelAtt = event;
-        if (!this.eventFromBrowser
-            || event.data.accuracy <= this.eventFromBrowser.data.accuracy) {
-            this.notify(event.clone());
+
+        if (this.eventFromBrowser && this.eventFromBrowser.data.accuracy < event.data.accuracy) {
+            return;
+        }
+        if (this.eventFromFused && this.eventFromFused.data.accuracy < event.data.accuracy) {
+            return;
+        }
+        this.notify(event.clone());
+    }
+
+    onAttitudeFused(event) {
+        this.eventFromFused = event;
+
+        if (this.eventFromBrowser && this.eventFromBrowser.data.accuracy < event.data.accuracy) {
+            return;
+        }
+        if (this.eventFromRelAtt && this.eventFromRelAtt.data.accuracy < event.data.accuracy) {
+            return;
         }
+        this.notify(event.clone());
     }
 
     /**
@@ -96,6 +129,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
     stop() {
         AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
         AbsoluteAttitudeFromRelAtt.removeEventListener(this.fromRelAttProviderId);
+        AbsoluteAttitudeFused.removeEventListener(this.fusedProviderId);
     }
 
     /**
@@ -115,8 +149,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
 
             this.notify(this.createEvent(
                 EventType.AbsoluteAttitude,
-                data.toAttitude(),
-                data.time
+                data.toAttitude()
             ));
 
         } else if (data instanceof Attitude) {
@@ -130,8 +163,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
 
             this.notify(this.createEvent(
                 EventType.AbsoluteAttitude,
-                data,
-                data.time
+                data
             ));
 
         } else {

package/src/providers/attitude/relative/RelativeAttitudeFromBrowserProvider.js

@@ -80,8 +80,6 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
 
     onDeviceOrientationEvent = e => {
 
-        const timestamp = e.timeStamp / 1e3;
-
         if (typeof e.alpha !== 'number' || typeof e.beta !== 'number' || typeof e.gamma !== 'number') {
             this.notifyError(new MissingSensorError().from('deviceorientation'));
             return;
@@ -89,11 +87,11 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
 
         const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
         const attitude = new Attitude(quaternion,
-            timestamp,
+            e.timeStamp / 1e3,
             RelativeAttitudeFromInertialProvider.DEFAULT_DRIFT,
             this.pname
         );
-        this.notify(this.createEvent(EventType.RelativeAttitude, attitude, timestamp));
+        this.notify(this.createEvent(EventType.RelativeAttitude, attitude));
     };
 }
 

package/src/providers/attitude/relative/RelativeAttitudeFromEkfProvider.js

@@ -82,8 +82,9 @@ class RelativeAttitudeFromEkfProvider extends Provider {
             return;
         }
 
-        const acceleration = accelerationEvent.data;
-        const { timestamp } = accelerationEvent;
+        const {
+            values: acceleration, timestamp
+        } = accelerationEvent.data;
 
         // Handle timestamps and dt
         if (this.lastTimestamp === 0) {
@@ -93,7 +94,7 @@ class RelativeAttitudeFromEkfProvider extends Provider {
         const diffTime = timestamp - this.lastTimestamp;
         this.lastTimestamp = timestamp;
 
-        const quaternion = this.ekfAttitude.update(diffTime, acceleration, this.gyroscopeEvent.data);
+        const quaternion = this.ekfAttitude.update(diffTime, acceleration, this.gyroscopeEvent.data.values);
 
         if (quaternion) {
             const attitude = new Attitude(quaternion,
@@ -104,7 +105,6 @@ class RelativeAttitudeFromEkfProvider extends Provider {
             this.notify(this.createEvent(
                 EventType.RelativeAttitude,
                 attitude,
-                timestamp,
                 [accelerationEvent, this.gyroscopeEvent]));
         }
     };

package/src/providers/imu/ImuProvider.js

@@ -105,7 +105,10 @@ class ImuProvider extends Provider {
         }
 
         if (acc) {
-            events.push(this.createEvent(EventType.Acceleration, acc, timestamp));
+            events.push(this.createEvent(EventType.Acceleration, {
+                timestamp,
+                values: acc
+            }));
         }
 
         let gyr;
@@ -120,7 +123,10 @@ class ImuProvider extends Provider {
         }
 
         if (gyr) {
-            events.push(this.createEvent(EventType.AngularRate, gyr, timestamp));
+            events.push(this.createEvent(EventType.AngularRate, {
+                timestamp,
+                values: gyr
+            }));
         }
 
         if (events.length !== 0) {

package/src/providers/inclination/InclinationFromAccProvider.js

@@ -53,7 +53,7 @@ class InclinationFromAccProvider extends Provider {
      * @private
      */
     onAccelerometerEvent = accelerometerEvent => {
-        const acc = accelerometerEvent.data;
+        const acc = accelerometerEvent.data.values;
 
         const screenOrientation = window.orientation || 0;
 
@@ -78,7 +78,6 @@ class InclinationFromAccProvider extends Provider {
         this.notify(this.createEvent(
             EventType.Inclination,
             inclination,
-            accelerometerEvent.timestamp,
             [accelerometerEvent]
         ));
     };

package/src/providers/inclination/InclinationFromRelativeAttitudeProvider.js

@@ -44,7 +44,6 @@ class InclinationFromRelativeAttitudeProvider extends Provider {
                 this.notify(this.createEvent(
                     EventType.Inclination,
                     inclination,
-                    attitudeEvent.timestamp,
                     [attitudeEvent]
                 ));
             },

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

@@ -68,7 +68,7 @@ class AbsolutePositionFromRelProvider extends Provider {
         /**
          * Use absolute position events only when they are not from this provider
          */
-        if (absolutePositionEvent.providersStack.includes(this.pname)) {
+        if (absolutePositionEvent.data === this.position) {
             return;
         }
 
@@ -91,13 +91,12 @@ class AbsolutePositionFromRelProvider extends Provider {
 
             this.position = this.position.destinationPoint(dist, bearing, alt);
             this.position.bearing = offsetPos.bearing;
-            this.position.time = event.timestamp;
+            this.position.time = offsetPos.time;
             this.position.accuracy += offsetPos.accuracy;
 
             this.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 this.position,
-                event.timestamp,
                 [event]
             ));
         }

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

@@ -1,10 +1,6 @@
 import noop from 'lodash.noop';
 
 import { UserPosition } from '@wemap/geo';
-import {
-    MapMatching, Network
-} from '@wemap/graph';
-import { deg2rad } from '@wemap/maths';
 import { PromiseUtils } from '@wemap/utils';
 
 import MetaProvider from '../../MetaProvider.js';
@@ -13,27 +9,20 @@ import ProviderEvent from '../../../events/ProviderEvent.js';
 import {
     AbsolutePositionFromRel, GnssWifi
 } from '../../../Providers.js';
-import ProvidersOptions from '../../../ProvidersOptions.js';
+import MapMatchingHandler from '../../../mapmatching/MapMatchingHandler.js';
 
 // Position accuracy uncertainty ratio
 const ACCURACY_NEW_POS_EPS_RATIO = 1.5;
 const ACCURACY_RELOC_RATIO = 2;
-const MM_MAX_ANGLE = deg2rad(20);
-const MM_MAX_DIST = 30;
-const MM_MIN_DIST = 0;
 const MM_MIN_TIME = 0.4;
 
 class AbsolutePositionProvider extends MetaProvider {
 
+    /** @type {number} */
     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;
     }
 
     /**
@@ -77,7 +66,11 @@ class AbsolutePositionProvider extends MetaProvider {
             });
 
         this.gnssWifiProviderId = GnssWifi.addEventListener(
-            events => this.onAbsolutePosition(events[0], false),
+            events => {
+                // bearing from GnssWifi is not reliable for our usecase
+                events[0].data.bearing = null;
+                this.onAbsolutePosition(events[0], false);
+            },
             noop
         );
 
@@ -94,46 +87,33 @@ class AbsolutePositionProvider extends MetaProvider {
         GnssWifi.removeEventListener(this.gnssWifiProviderId);
     }
 
+    /**
+     * @param {ProviderEvent} newPositionEvent
+     * @param {boolean} canContainLevel
+     */
     onAbsolutePosition(newPositionEvent, canContainLevel = true) {
-        let newPosition = newPositionEvent.data;
 
-        if (!this._useNewAbsolutePosition(newPosition)) {
+        if (!this._useNewAbsolutePosition(newPositionEvent.data)) {
             return;
         }
 
+        const newPosition = newPositionEvent.data.clone();
+
         if (this.lastEvent && !canContainLevel) {
             newPosition.level = this.lastEvent.data.level;
         }
 
-        if (this.lastEventBearing !== null) {
-            newPosition.bearing = this.lastEventBearing;
+        // If the new position does not have a bearing, retrieve the bearing from the last position
+        if (newPosition.bearing === null && this.lastEvent !== null) {
+            newPosition.bearing = this.lastEvent.data.bearing;
         }
 
-        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);
-            }
-
-            // 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();
-        }
+        const shouldTryMmOnNodes = !newPositionEvent.providersStack.includes(AbsolutePositionFromRel.pname);
+        const position = MapMatchingHandler.calcProjection(newPosition, shouldTryMmOnNodes) || newPosition;
 
         this.notify(this.createEvent(
             EventType.AbsolutePosition,
-            newPosition,
-            newPositionEvent.timestamp,
+            position,
             [newPositionEvent]
         ));
 
@@ -144,29 +124,20 @@ class AbsolutePositionProvider extends MetaProvider {
      */
     onAbsolutePositionFromRel(newPositionEvent) {
 
-        let newPosition = newPositionEvent.data;
-
-        this.lastEventBearing = newPosition.bearing;
-
-        if (this._shouldHandleMapMatching()
-            && newPositionEvent.data.time - this.lastMMAttempt > MM_MIN_TIME) {
-
-            // 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.
+        let position = newPositionEvent.data;
 
+        if (newPositionEvent.data.time - this.lastMMAttempt > MM_MIN_TIME) {
+            position = MapMatchingHandler.calcProjection(position) || position;
             this.lastMMAttempt = newPositionEvent.data.time;
-        } else {
-            newPosition = newPosition.clone();
+        }
+
+        if (position === newPositionEvent.data) {
+            position = position.clone();
         }
 
         this.notify(this.createEvent(
             EventType.AbsolutePosition,
-            newPosition,
-            newPositionEvent.timestamp,
+            position,
             [newPositionEvent]
         ));
     }
@@ -191,38 +162,11 @@ class AbsolutePositionProvider extends MetaProvider {
 
     }
 
-    _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 use projection.projection directly, because position has some specific properties like bearing and altitude
-        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
-     * @param {EventType} eventType
+     * @param {UserPosition} data
      */
-    feed(data, eventType) {
+    feed(data) {
         if (data instanceof UserPosition) {
             const position = data;
             if (position.time === null) {
@@ -231,65 +175,15 @@ class AbsolutePositionProvider extends MetaProvider {
             if (position.accuracy === null) {
                 throw Error('the accuracy of the position is not defined');
             }
+
             this.onAbsolutePosition(this.createEvent(
-                EventType.AbsolutePosition, position, position.time
+                EventType.AbsolutePosition, position
             ));
-        } 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;

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

@@ -97,7 +97,7 @@ class GnssWifiProvider extends Provider {
             this.pname);
 
         this.notify(this.createEvent(
-            EventType.AbsolutePosition, position, timestamp
+            EventType.AbsolutePosition, position
         ));
 
     };