@wemap/providers 4.0.1 → 4.0.4

package/src/providers/attitude/TurnDectector.js

@@ -0,0 +1,71 @@
+import { std } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import RelativeAttitude from './relative/RelativeAttitude.js';
+import Provider from '../Provider.js';
+
+class TurnDetector extends Provider {
+
+    // in seconds
+    static SLIDING_WINDOW_TIME = 0.3;
+
+    static STD_THRESHOLD = 0.075;
+
+    /** @type {number} in seconds */
+    static CONSIDER_TURN_UNTIL = 1;
+
+    /** @type {number[]} */
+    slidingWindow = [];
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'TurnDetector';
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = RelativeAttitude.addEventListener(
+            events => this._parseRelativeAttitude(events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        RelativeAttitude.removeEventListener(this.providerId);
+    }
+
+    isTurning() {
+        if (!this.lastEvent || !RelativeAttitude.lastEvent) {
+            return false;
+        }
+
+        const diffTime = RelativeAttitude.lastEvent.data.time - this.lastEvent.data.timestamp;
+        return diffTime < TurnDetector.CONSIDER_TURN_UNTIL;
+    }
+
+    /**
+     * @private
+     */
+    _parseRelativeAttitude = relativeAttitudeEvent => {
+
+        const { heading, time: timestamp } = relativeAttitudeEvent.data;
+
+        this.slidingWindow = this.slidingWindow.filter(item => item[0] >= timestamp - TurnDetector.SLIDING_WINDOW_TIME);
+        this.slidingWindow.push([timestamp, heading]);
+
+        const stdVal = std(this.slidingWindow.map(item => item[1]));
+        if (stdVal > TurnDetector.STD_THRESHOLD) {
+            this.notify(this.createEvent(EventType.Turn, { timestamp }, [relativeAttitudeEvent]));
+        }
+
+    }
+}
+
+export default new TurnDetector();

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

@@ -1,25 +1,46 @@
-import {
-    AbsoluteHeading, Attitude
-} from '@wemap/geo';
+import { AbsoluteHeading, Attitude } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
 import { PromiseUtils } from '@wemap/utils';
 
-import MetaProvider from '../../MetaProvider.js';
+import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import AbsoluteAttitudeFromBrowser from './AbsoluteAttitudeFromBrowser.js';
-import AbsoluteAttitudeFromRelAtt from './AbsoluteAttitudeFromRelAtt.js';
-import AbsoluteAttitudeFused from './AbsoluteAttitudeFused.js';
+import RelativeAttitude from '../relative/RelativeAttitude.js';
+import ProviderEvent from '../../../events/ProviderEvent.js';
 
 /**
  * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
  */
-class AbsoluteAttitude extends MetaProvider {
+class AbsoluteAttitude extends Provider {
+
+    /** @type {boolean} */
+    _attitudeFromBrowserErrored = false;
+
+    /** @type {boolean} */
+    _attitudeFromRelativeErrored = false;
+
+    /*
+     * RELATIVE
+     */
+
+    /** @type {Attitude} */
+    _relativeAttitude = null;
+
+    /** @type {number} in radians/s */
+    _relativeAccuracy = 0;
+
+    /** @type {ProviderEvent<Attitude|AbsoluteHeading>} */
+    _lastForcedHeadingEvent;
+
+    /** @type {number[]} quaternion offset from relative to absolute */
+    _relAbsQuat;
+
 
     constructor() {
         super();
 
-        this.attitudeFromBrowserErrored = false;
-        this.attitudeFromRelAttErrored = false;
-        this.attitudeFusedErrored = false;
+        this._attitudeFromBrowserErrored = false;
+        this._attitudeFromRelativeErrored = false;
     }
 
     /**
@@ -42,8 +63,7 @@ class AbsoluteAttitude extends MetaProvider {
     get _availability() {
         return PromiseUtils.any([
             AbsoluteAttitudeFromBrowser.availability,
-            AbsoluteAttitudeFromRelAtt.availability,
-            AbsoluteAttitudeFused.availability
+            RelativeAttitude.availability
         ]);
     }
 
@@ -53,87 +73,122 @@ class AbsoluteAttitude extends MetaProvider {
     start() {
 
         this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser.addEventListener(
-            events => this.onAttitudeFromBrowser(events[0]),
+            events => this._onAttitudeFromBrowser(events[0]),
             error => {
-                this.attitudeFromBrowserErrored = true;
+                this._attitudeFromBrowserErrored = true;
                 this.onError(error);
             }
         );
 
-        this.fromRelAttProviderId = AbsoluteAttitudeFromRelAtt.addEventListener(
-            events => this.onAttitudeFromRelAtt(events[0]),
+        this.relativeAttitudeProviderId = RelativeAttitude.addEventListener(
+            events => this._onRelativeAttitudeEvent(events[0]),
             error => {
-                this.attitudeFromRelAttErrored = true;
-                this.onError(error);
+                this._attitudeFromRelativeErrored = true;
+                this.notifyError(error);
             }
         );
 
-        this.fusedProviderId = AbsoluteAttitudeFused.addEventListener(
-            events => this.onAttitudeFused(events[0]),
-            error => {
-                this.attitudeFusedErrored = true;
-                this.onError(error);
-            }
-        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
+        RelativeAttitude.removeEventListener(this.relativeAttitudeProviderId);
     }
 
     onError(error) {
-        if (this.attitudeFromBrowserErrored
-            && this.attitudeFromRelAttErrored
-            && this.attitudeFusedErrored) {
+        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
             this.notifyError(error);
         }
     }
 
-    onAttitudeFromBrowser(event) {
-        this.eventFromBrowser = event;
 
+    /**
+     * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
+     */
+    _forceHeadingForRelative = (absoluteHeadingEvent, force = false) => {
 
-        if (this.eventFromRelAtt && this.eventFromRelAtt.data.accuracy < event.data.accuracy) {
-            return;
-        }
-        if (this.eventFromFused && this.eventFromFused.data.accuracy < event.data.accuracy) {
+        if (!force && this.lastEvent
+            && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
             return;
         }
-        this.notify(event.clone());
-    }
 
-    onAttitudeFromRelAtt(event) {
-        this.eventFromRelAtt = event;
+        const currentRelativeHeading = this._relativeAttitude ? this._relativeAttitude.heading : 0;
 
-        if (this.eventFromBrowser && this.eventFromBrowser.data.accuracy < event.data.accuracy) {
-            return;
-        }
-        if (this.eventFromFused && this.eventFromFused.data.accuracy < event.data.accuracy) {
+        this._relAbsQuat = Quaternion.fromAxisAngle(
+            [0, 0, 1],
+            currentRelativeHeading - absoluteHeadingEvent.data.heading
+        );
+
+        this._relativeAccuracy = 0;
+        this._lastForcedHeadingEvent = absoluteHeadingEvent;
+    };
+
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _onRelativeAttitudeEvent(event) {
+
+        if (!this._lastForcedHeadingEvent) {
             return;
         }
-        this.notify(event.clone());
-    }
 
-    onAttitudeFused(event) {
-        this.eventFromFused = event;
+        const { quaternion, accuracy, time } = event.data;
 
-        if (this.eventFromBrowser && this.eventFromBrowser.data.accuracy < event.data.accuracy) {
-            return;
+        // Calculate relative accuracy
+        if (this._relativeAttitude) {
+            this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
         }
-        if (this.eventFromRelAtt && this.eventFromRelAtt.data.accuracy < event.data.accuracy) {
-            return;
+        // Keep the relative attitude event for the calculation of relAbsQuat
+        this._relativeAttitude = event.data;
+
+        const accuracyWithRelative = Math.min(
+            this._lastForcedHeadingEvent.data.accuracy + this._relativeAccuracy,
+            Math.PI
+        );
+        const accuracyWithAbsolute = this._eventFromBrowser.data.accuracy;
+
+        let newAccuracy;
+        let relAbsQuat;
+        if (accuracyWithAbsolute < accuracyWithRelative) {
+            const currentHeading = this._relativeAttitude ? this._relativeAttitude.heading : 0;
+            newAccuracy = accuracyWithAbsolute;
+            relAbsQuat = Quaternion.fromAxisAngle([0, 0, 1], currentHeading - this._eventFromBrowser.data.heading);
+        } else {
+            newAccuracy = accuracyWithRelative;
+            relAbsQuat = this._relAbsQuat;
         }
-        this.notify(event.clone());
+
+        const absoluteQuat = Quaternion.multiply(relAbsQuat, quaternion);
+        const attitude = new Attitude(absoluteQuat, time, newAccuracy);
+
+        this.notify(this.createEvent(
+            EventType.AbsoluteAttitude,
+            attitude,
+            [event, this._lastForcedHeadingEvent]
+        ));
     }
 
+
     /**
-     * @override
+     * @param {ProviderEvent<Attitude>} event
      */
-    stop() {
-        AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
-        AbsoluteAttitudeFromRelAtt.removeEventListener(this.fromRelAttProviderId);
-        AbsoluteAttitudeFused.removeEventListener(this.fusedProviderId);
+    _onAttitudeFromBrowser(event) {
+        this._eventFromBrowser = event;
+
+        if (!this._lastForcedHeadingEvent) {
+            this._forceHeadingForRelative(event);
+            return;
+        }
+
+        // Absolute attitude from browser is not used anymore due to magnetometer inaccuracy on pitch and roll
     }
 
     /**
      * @override
-     * @param {AbsoluteHeading|Attitude} data
+     * @param {AbsoluteHeading|Attitude|ProviderEvent} data
      */
     feed(data) {
 
@@ -146,10 +201,7 @@ class AbsoluteAttitude extends MetaProvider {
                 throw Error('the accuracy of the absolute heading is not defined');
             }
 
-            this.notify(this.createEvent(
-                EventType.AbsoluteAttitude,
-                data.toAttitude()
-            ));
+            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
 
         } else if (data instanceof Attitude) {
 
@@ -160,10 +212,16 @@ class AbsoluteAttitude extends MetaProvider {
                 throw Error('the accuracy of the attitude is not defined');
             }
 
-            this.notify(this.createEvent(
-                EventType.AbsoluteAttitude,
-                data
-            ));
+            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
+
+        } else if (data instanceof ProviderEvent) {
+
+            if (data.dataType !== EventType.AbsoluteHeading
+                || !(data.data instanceof AbsoluteHeading)) {
+                throw Error('the provider event is not an AbsoluteHeading');
+            }
+
+            this._forceHeadingForRelative(data);
 
         } else {
             throw new Error('data is nor an AbsoluteHeading or an Attitude object');

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

@@ -1,5 +1,3 @@
-import noop from 'lodash.noop';
-
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import ProviderState from '../../ProviderState.js';
@@ -84,7 +82,7 @@ class RelativeAttitude extends Provider {
                     this.notify(relativeAttitudeEvent.clone());
                 }
             },
-            noop,
+            () => {},
             false
         );
     };

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

@@ -88,8 +88,7 @@ class RelativeAttitudeFromBrowser extends Provider {
         const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
         const attitude = new Attitude(quaternion,
             e.timeStamp / 1e3,
-            RelativeAttitudeFromInertial.DEFAULT_DRIFT,
-            this.pname
+            RelativeAttitudeFromInertial.DEFAULT_DRIFT
         );
         this.notify(this.createEvent(EventType.RelativeAttitude, attitude));
     };

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

@@ -99,8 +99,7 @@ class RelativeAttitudeFromEkf extends Provider {
         if (quaternion) {
             const attitude = new Attitude(quaternion,
                 timestamp,
-                RelativeAttitudeFromInertial.DEFAULT_DRIFT,
-                this.pname
+                RelativeAttitudeFromInertial.DEFAULT_DRIFT
             );
             this.notify(this.createEvent(
                 EventType.RelativeAttitude,

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

@@ -1,10 +1,13 @@
+import { Attitude } from '@wemap/geo';
 import { deg2rad } from '@wemap/maths';
 import { PromiseUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
+import ProviderEvent from '../../../events/ProviderEvent.js';
 import EventType from '../../../events/EventType.js';
 import RelativeAttitudeFromEkf from './RelativeAttitudeFromEkf.js';
 import RelativeAttitudeFromBrowser from './RelativeAttitudeFromBrowser.js';
+import HighRotationsDetector from '../../imu/HighRotationsDetector.js';
 
 
 class RelativeAttitudeFromInertial extends Provider {
@@ -12,7 +15,7 @@ class RelativeAttitudeFromInertial extends Provider {
     /**
      * default relative attitude drift in rad.second-1
      */
-    static DEFAULT_DRIFT = deg2rad(5) / 60;
+    DEFAULT_DRIFT = deg2rad(5) / 60;
 
 
     /**
@@ -49,11 +52,24 @@ class RelativeAttitudeFromInertial extends Provider {
             .catch(() => (this.provider = RelativeAttitudeFromBrowser))
             .finally(() => {
                 this.listenerId = this.provider.addEventListener(
-                    events => this.notify(events[0].clone()),
+                    events => this._parseEvent(events[0]),
                     error => this.notifyError(error)
                 );
+                this._highRotationsDetector = HighRotationsDetector.addEventListener();
             });
+    }
 
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _parseEvent(event) {
+        const relativeAttitudeEvent = event.clone();
+        if (HighRotationsDetector.isInProgress()) {
+            let accuracy = relativeAttitudeEvent.data.accuracy + (this.DEFAULT_DRIFT * 100);
+            accuracy = Math.min(accuracy, Math.PI);
+            relativeAttitudeEvent.data.accuracy = accuracy;
+        }
+        this.notify(relativeAttitudeEvent);
     }
 
     /**
@@ -64,6 +80,7 @@ class RelativeAttitudeFromInertial extends Provider {
             this.provider.removeEventListener(this.listenerId);
             this.provider = null;
         }
+        HighRotationsDetector.removeEventListener(this._highRotationsDetector);
     }
 }
 

package/src/providers/imu/HighRotationsDetector.js

@@ -0,0 +1,62 @@
+import { Vector3 } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import Provider from '../Provider.js';
+import Gyroscope from './Gyroscope.js';
+
+class HighRotationsDetector extends Provider {
+
+    // in radians by second
+    static THRESHOLD = 10;
+
+    /** @type {number} in seconds */
+    static DELAY_CONSIDERATION = 3;
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'HighRotationsDetector';
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Gyroscope.addEventListener(
+            events => this._parseGyroscopeEvent(events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Gyroscope.removeEventListener(this.providerId);
+    }
+
+    isInProgress() {
+        if (!this.lastEvent || !Gyroscope.lastEvent) {
+            return false;
+        }
+
+        const diffTime = Gyroscope.lastEvent.data.timestamp - this.lastEvent.data.timestamp;
+        return diffTime < HighRotationsDetector.DELAY_CONSIDERATION;
+    }
+
+    /**
+     * @private
+     */
+    _parseGyroscopeEvent = gyroscopeEvent => {
+
+        const { values, timestamp } = gyroscopeEvent.data;
+        const speed = Vector3.norm(values);
+        if (speed > HighRotationsDetector.THRESHOLD) {
+            this.notify(this.createEvent(EventType.HighRotation, { timestamp }, [gyroscopeEvent]));
+        }
+
+    }
+}
+
+export default new HighRotationsDetector();

package/src/providers/inclination/Inclination.js

@@ -1,6 +1,6 @@
 import { PromiseUtils } from '@wemap/utils';
 
-import MetaProvider from '../MetaProvider.js';
+import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import InclinationFromAcc from './InclinationFromAcc.js';
 import InclinationFromRelativeAttitude from './InclinationFromRelativeAttitude.js';
@@ -11,7 +11,7 @@ import InclinationFromRelativeAttitude from './InclinationFromRelativeAttitude.j
  *              when the device is layed on a table, inclination = 0
  * This provider use window.orientation to return a result in function of screen orientation
  */
-class Inclination extends MetaProvider {
+class Inclination extends Provider {
 
     /**
      * @override

package/src/providers/others/CameraNative.js

@@ -1,9 +1,9 @@
-import MetaProvider from '../MetaProvider.js';
+import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import { ArCore } from '../../Providers.js';
 import ProviderState from '../ProviderState.js';
 
-class CameraNative extends MetaProvider {
+class CameraNative extends Provider {
 
     /**
      * @override

package/src/providers/others/CameraProjectionMatrix.js

@@ -1,8 +1,8 @@
-import MetaProvider from '../MetaProvider.js';
+import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import ArCore from '../position/relative/ArCore.js';
 
-class CameraProjectionMatrix extends MetaProvider {
+class CameraProjectionMatrix extends Provider {
 
     /**
      * @override