@wemap/providers 3.3.0 → 4.0.1

package/src/providers/attitude/absolute/{AbsoluteAttitudeProvider.js → AbsoluteAttitude.js}

@@ -5,21 +5,21 @@ import { PromiseUtils } from '@wemap/utils';
 
 import MetaProvider from '../../MetaProvider.js';
 import EventType from '../../../events/EventType.js';
-import {
-    AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFromRelAtt
-} from '../../../Providers.js';
-
+import AbsoluteAttitudeFromBrowser from './AbsoluteAttitudeFromBrowser.js';
+import AbsoluteAttitudeFromRelAtt from './AbsoluteAttitudeFromRelAtt.js';
+import AbsoluteAttitudeFused from './AbsoluteAttitudeFused.js';
 
 /**
  * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
  */
-class AbsoluteAttitudeProvider extends MetaProvider {
+class AbsoluteAttitude extends MetaProvider {
 
     constructor() {
         super();
 
         this.attitudeFromBrowserErrored = false;
         this.attitudeFromRelAttErrored = false;
+        this.attitudeFusedErrored = false;
     }
 
     /**
@@ -42,7 +42,8 @@ class AbsoluteAttitudeProvider extends MetaProvider {
     get _availability() {
         return PromiseUtils.any([
             AbsoluteAttitudeFromBrowser.availability,
-            AbsoluteAttitudeFromRelAtt.availability
+            AbsoluteAttitudeFromRelAtt.availability,
+            AbsoluteAttitudeFused.availability
         ]);
     }
 
@@ -66,28 +67,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 +128,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
     stop() {
         AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
         AbsoluteAttitudeFromRelAtt.removeEventListener(this.fromRelAttProviderId);
+        AbsoluteAttitudeFused.removeEventListener(this.fusedProviderId);
     }
 
     /**
@@ -115,8 +148,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
 
             this.notify(this.createEvent(
                 EventType.AbsoluteAttitude,
-                data.toAttitude(),
-                data.time
+                data.toAttitude()
             ));
 
         } else if (data instanceof Attitude) {
@@ -130,8 +162,7 @@ class AbsoluteAttitudeProvider extends MetaProvider {
 
             this.notify(this.createEvent(
                 EventType.AbsoluteAttitude,
-                data,
-                data.time
+                data
             ));
 
         } else {
@@ -140,4 +171,4 @@ class AbsoluteAttitudeProvider extends MetaProvider {
     }
 }
 
-export default AbsoluteAttitudeProvider;
+export default new AbsoluteAttitude();

package/src/providers/attitude/absolute/{AbsoluteAttitudeFromBrowserProvider.js → AbsoluteAttitudeFromBrowser.js}

@@ -15,7 +15,7 @@ import EventType from '../../../events/EventType.js';
 import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError.js';
 import MissingMagnetometerError from '../../../errors/MissingMagnetometerError.js';
 import MissingSensorError from '../../../errors/MissingSensorError.js';
-import { AbsolutePosition } from '../../../Providers.js';
+import AbsolutePosition from '../../position/absolute/AbsolutePosition.js';
 
 
 /**
@@ -35,7 +35,7 @@ import { AbsolutePosition } from '../../../Providers.js';
  *
  * -----------------------------------
  */
-class AbsoluteAttitudeFromBrowserProvider extends Provider {
+class AbsoluteAttitudeFromBrowser extends Provider {
 
     // from http://tyrex.inria.fr/mobile/benchmarks-attitude/
     static DEFAULT_ACCURACY = deg2rad(15);
@@ -207,7 +207,7 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
         if (isSkyMode) {
             alpha = 180 - e.webkitCompassHeading;
         } else {
-            alpha = AbsoluteAttitudeFromBrowserProvider.webkitCompassToHeading(
+            alpha = AbsoluteAttitudeFromBrowser.webkitCompassToHeading(
                 e.webkitCompassHeading, e.beta, e.gamma);
         }
 
@@ -229,7 +229,6 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
         this.notify(this.createEvent(
             EventType.AbsoluteAttitude,
             attitude,
-            this.magQuaternionTimestamp,
             [this.absolutePositionEvent]
         ));
     }
@@ -277,4 +276,4 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
     }
 }
 
-export default AbsoluteAttitudeFromBrowserProvider;
+export default new AbsoluteAttitudeFromBrowser();

package/src/providers/attitude/absolute/{AbsoluteAttitudeFromRelAttProvider.js → AbsoluteAttitudeFromRelAtt.js}

@@ -3,14 +3,15 @@ import { Attitude } from '@wemap/geo';
 
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
-import {
-    RelativeAttitude, AbsoluteAttitude, AbsoluteAttitudeFromBrowser
-} from '../../../Providers.js';
+import RelativeAttitude from '../relative/RelativeAttitude.js';
+import AbsoluteAttitude from './AbsoluteAttitude.js';
+import AbsoluteAttitudeFromBrowser from './AbsoluteAttitudeFromBrowser.js';
+import AbsoluteAttitudeFused from './AbsoluteAttitudeFused.js';
 
 /**
  * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
  */
-class AbsoluteAttitudeFromRelAttProvider extends Provider {
+class AbsoluteAttitudeFromRelAtt extends Provider {
 
     accuracy = 0;
 
@@ -91,7 +92,8 @@ class AbsoluteAttitudeFromRelAttProvider extends Provider {
          * Use absolute attitude events only when they are not from this provider
          */
         if (absoluteAttitudeEvent.providersStack.includes(this.pname)
-            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFromBrowser.pname)) {
+            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFromBrowser.pname)
+            || absoluteAttitudeEvent.providersStack.includes(AbsoluteAttitudeFused.pname)) {
             return;
         }
         this.absoluteAttitudeEvent = absoluteAttitudeEvent;
@@ -121,7 +123,6 @@ class AbsoluteAttitudeFromRelAttProvider extends Provider {
         this.notify(this.createEvent(
             EventType.AbsoluteAttitude,
             attitude,
-            time,
             [this.relativeAttitudeEvent, this.absoluteAttitudeEvent]
         ));
 
@@ -129,4 +130,4 @@ class AbsoluteAttitudeFromRelAttProvider extends Provider {
 
 }
 
-export default AbsoluteAttitudeFromRelAttProvider;
+export default new AbsoluteAttitudeFromRelAtt();

package/src/providers/attitude/absolute/AbsoluteAttitudeFused.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 ProviderState from '../../ProviderState.js';
+import RelativeAttitude from '../relative/RelativeAttitude.js';
+
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+class AbsoluteAttitudeFused 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 new AbsoluteAttitudeFused();

package/src/providers/attitude/relative/{RelativeAttitudeProvider.js → RelativeAttitude.js}

@@ -3,17 +3,16 @@ import noop from 'lodash.noop';
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import ProviderState from '../../ProviderState.js';
-import {
-    RelativeAttitudeFromInertial, ArCore
-} from '../../../Providers.js';
 
+import RelativeAttitudeFromInertial from './RelativeAttitudeFromInertial.js';
+import ArCore from '../../position/relative/ArCore.js';
 
 /**
  * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
  *  browser deviceorientation
  * The provider does not work until an offset is given.
  */
-class RelativeAttitudeProvider extends Provider {
+class RelativeAttitude extends Provider {
 
     /**
     * @override
@@ -95,4 +94,4 @@ class RelativeAttitudeProvider extends Provider {
     }
 }
 
-export default RelativeAttitudeProvider;
+export default new RelativeAttitude();

package/src/providers/attitude/relative/{RelativeAttitudeFromBrowserProvider.js → RelativeAttitudeFromBrowser.js}

@@ -6,7 +6,7 @@ import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError.js';
 import MissingSensorError from '../../../errors/MissingSensorError.js';
-import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertialProvider.js';
+import RelativeAttitudeFromInertial from './RelativeAttitudeFromInertial.js';
 
 
 /**
@@ -24,7 +24,7 @@ import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertial
  *
  * -----------------------------------
  */
-class RelativeAttitudeFromBrowserProvider extends Provider {
+class RelativeAttitudeFromBrowser extends Provider {
 
     /**
     * @override
@@ -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,12 +87,12 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
 
         const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
         const attitude = new Attitude(quaternion,
-            timestamp,
-            RelativeAttitudeFromInertialProvider.DEFAULT_DRIFT,
+            e.timeStamp / 1e3,
+            RelativeAttitudeFromInertial.DEFAULT_DRIFT,
             this.pname
         );
-        this.notify(this.createEvent(EventType.RelativeAttitude, attitude, timestamp));
+        this.notify(this.createEvent(EventType.RelativeAttitude, attitude));
     };
 }
 
-export default RelativeAttitudeFromBrowserProvider;
+export default new RelativeAttitudeFromBrowser();

package/src/providers/attitude/relative/{RelativeAttitudeFromEkfProvider.js → RelativeAttitudeFromEkf.js}

@@ -3,10 +3,10 @@ import { Attitude } from '@wemap/geo';
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import EkfAttitude from '../EkfAttitude.js';
-import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertialProvider.js';
-import {
-    Accelerometer, Gyroscope
-} from '../../../Providers.js';
+import RelativeAttitudeFromInertial from './RelativeAttitudeFromInertial.js';
+
+import Accelerometer from '../../imu/Accelerometer.js';
+import Gyroscope from '../../imu/Gyroscope.js';
 
 
 /**
@@ -14,7 +14,7 @@ import {
  *  browser deviceorientation
  * The provider does not work until an offset is given.
  */
-class RelativeAttitudeFromEkfProvider extends Provider {
+class RelativeAttitudeFromEkf extends Provider {
 
     lastTimestamp = 0;
 
@@ -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,21 +94,20 @@ 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,
                 timestamp,
-                RelativeAttitudeFromInertialProvider.DEFAULT_DRIFT,
+                RelativeAttitudeFromInertial.DEFAULT_DRIFT,
                 this.pname
             );
             this.notify(this.createEvent(
                 EventType.RelativeAttitude,
                 attitude,
-                timestamp,
                 [accelerationEvent, this.gyroscopeEvent]));
         }
     };
 }
 
-export default RelativeAttitudeFromEkfProvider;
+export default new RelativeAttitudeFromEkf();

package/src/providers/attitude/relative/{RelativeAttitudeFromInertialProvider.js → RelativeAttitudeFromInertial.js}

@@ -3,11 +3,11 @@ import { PromiseUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
-import {
-    RelativeAttitudeFromEkf, RelativeAttitudeFromBrowser
-} from '../../../Providers.js';
+import RelativeAttitudeFromEkf from './RelativeAttitudeFromEkf.js';
+import RelativeAttitudeFromBrowser from './RelativeAttitudeFromBrowser.js';
 
-class RelativeAttitudeFromInertialProvider extends Provider {
+
+class RelativeAttitudeFromInertial extends Provider {
 
     /**
      * default relative attitude drift in rad.second-1
@@ -67,4 +67,4 @@ class RelativeAttitudeFromInertialProvider extends Provider {
     }
 }
 
-export default RelativeAttitudeFromInertialProvider;
+export default new RelativeAttitudeFromInertial();

package/src/providers/imu/{AccelerometerProvider.js → Accelerometer.js}

@@ -1,9 +1,9 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import MissingAccelerometerError from '../../errors/MissingAccelerometerError.js';
-import { Imu } from '../../Providers.js';
+import Imu from './Imu.js';
 
-class AccelerometerProvider extends Provider {
+class Accelerometer extends Provider {
 
     /**
      * @override
@@ -58,4 +58,4 @@ class AccelerometerProvider extends Provider {
 
 }
 
-export default AccelerometerProvider;
+export default new Accelerometer();

package/src/providers/imu/{GyroscopeProvider.js → Gyroscope.js}

@@ -1,9 +1,9 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import MissingGyroscopeError from '../../errors/MissingGyroscopeError.js';
-import { Imu } from '../../Providers.js';
+import Imu from './Imu.js';
 
-class GyroscopeProvider extends Provider {
+class Gyroscope extends Provider {
 
     /**
      * @override
@@ -58,4 +58,4 @@ class GyroscopeProvider extends Provider {
 
 }
 
-export default GyroscopeProvider;
+export default new Gyroscope();

package/src/providers/imu/{ImuProvider.js → Imu.js}

@@ -22,7 +22,7 @@ import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError.js';
  *
  * -----------------------------------
  */
-class ImuProvider extends Provider {
+class Imu extends Provider {
 
     /**
     * @override
@@ -41,7 +41,7 @@ class ImuProvider extends Provider {
     /**
      * @override
      */
-    get _availability() {
+    static get _availability() {
         return BrowserUtils.isMobile
             ? Promise.resolve()
             : Promise.reject(new AskImuOnDesktopError());
@@ -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) {
@@ -130,4 +136,4 @@ class ImuProvider extends Provider {
 
 }
 
-export default ImuProvider;
+export default new Imu();

package/src/providers/inclination/{InclinationProvider.js → Inclination.js}

@@ -2,9 +2,8 @@ import { PromiseUtils } from '@wemap/utils';
 
 import MetaProvider from '../MetaProvider.js';
 import EventType from '../../events/EventType.js';
-import {
-    InclinationFromRelativeAttitude, InclinationFromAcc
-} from '../../Providers.js';
+import InclinationFromAcc from './InclinationFromAcc.js';
+import InclinationFromRelativeAttitude from './InclinationFromRelativeAttitude.js';
 
 /**
  * Inclination provider gives the inclination of the device using Imu Sensor
@@ -12,7 +11,7 @@ import {
  *              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 InclinationProvider extends MetaProvider {
+class Inclination extends MetaProvider {
 
     /**
      * @override
@@ -75,4 +74,4 @@ class InclinationProvider extends MetaProvider {
     }
 }
 
-export default InclinationProvider;
+export default new Inclination();