@wemap/providers 4.0.0 → 4.0.3

package/src/providers/Provider.js

@@ -1,5 +1,3 @@
-import noop from 'lodash.noop';
-
 import EventType from '../events/EventType.js';
 import ProviderEvent from '../events/ProviderEvent.js';
 import ProvidersLoggerOld from '../events/ProvidersLoggerOld.js';
@@ -7,7 +5,6 @@ import ContainsIgnoredProviderError from '../errors/ContainsIgnoredProviderError
 import ProvidersOptions from '../ProvidersOptions.js';
 import ProviderState from './ProviderState.js';
 
-let uniqueId = 1;
 
 /**
  * A provider is a meta class to define an entity which can be
@@ -15,25 +12,24 @@ let uniqueId = 1;
  */
 class Provider {
 
+    /** @type {number} */
     static _callbackUniqueId = 0;
 
-    state = ProviderState.STOPPPED;
+    /** @type {number} */
+    static _uniqueId = 1;
 
-    _eventsCallbacks = [];
-    _monitoringCallbacks = [];
 
+    /** @type {number} */
+    id;
 
-    /**
-     * Singleton pattern using reflection.
-     * @returns {Provider}
-     */
-    static get instance() {
-        if (!this._instance) {
-            this._instance = Reflect.construct(this, []);
-        }
-        return this._instance;
-    }
+    /** @type {number} */
+    state = ProviderState.STOPPPED;
 
+    /** @type {ProviderEvent[]} */
+    _lastEvents = null;
+
+    _eventsCallbacks = [];
+    _monitoringCallbacks = [];
 
     /**
      * Provider constructor
@@ -44,23 +40,20 @@ class Provider {
             throw new Error('Can\'t instantiate Provider directly');
         }
 
-        if (this._instance) {
-            throw new Error(`Cannot instantiate ${this.pname} twice`);
-        }
-
-        this.id = uniqueId++;
+        this.id = Provider._uniqueId++;
 
         ProvidersLoggerOld.addEvent(this, 'constructor');
     }
 
     /**
      * Get the provider name
-     * @returns {String} the provider name
+     * @type {String} the provider name
      */
     static get pname() {
         return 'Unknown';
     }
 
+    /** @type {String} */
     get pname() {
         return this.constructor.pname;
     }
@@ -76,7 +69,7 @@ class Provider {
     }
 
     /**
-     * @returns {Promise} returns an availability promise
+     * @type {Promise} returns an availability promise
      */
     get availability() {
         if (ProvidersOptions.ignoreProviders.includes(this.pname)) {
@@ -86,13 +79,14 @@ class Provider {
         return this._availability;
     }
 
+    /** @type {Promise} */
     get _availability() {
         return Promise.resolve();
     }
 
     /**
      * Create an event from current provider
-     * @param {ProviderEvent#DataType} dataType type of ProviderEvent
+     * @param {String} dataType type of ProviderEvent (from EventType)
      * @param {Object} data data exported to ProviderEvent
      * @returns {ProviderEvent}
      * @protected
@@ -136,7 +130,7 @@ class Provider {
      * @param {Boolean} startIfNecessary
      * @returns {Number}
      */
-    addEventListener(onEvents = noop, onError = noop, startIfNecessary = true) {
+    addEventListener(onEvents = () => {}, onError = () => {}, startIfNecessary = true) {
         const id = ++Provider._callbackUniqueId;
 
         /**
@@ -185,7 +179,7 @@ class Provider {
                 this.notifyError(e);
             })
             // notifyError can throw an error if onStop is not defined
-            .catch(() => noop);
+            .catch(() => {});
 
         return id;
     }
@@ -238,7 +232,7 @@ class Provider {
      * @param {Function} onStopped
      * @returns {Number}
      */
-    addMonitoringListener(onStarted = noop, onStopped = noop) {
+    addMonitoringListener(onStarted = () => {}, onStopped = () => {}) {
         const id = ++this.constructor._callbackUniqueId;
         this._monitoringCallbacks.push({
             id,
@@ -286,6 +280,9 @@ class Provider {
 
         // Notify callbacks
         this._eventsCallbacks.forEach(({ onEvents }) => onEvents(events));
+
+        // Keep a trace of the last events.
+        this._lastEvents = events;
     }
 
     /**
@@ -302,6 +299,26 @@ class Provider {
             onError(error);
         });
     }
+
+    /** @type {ProviderEvent} */
+    get lastEvent() {
+        return this._lastEvents ? this._lastEvents[0] : null;
+    }
+
+    /** @type {ProviderEvent[]} */
+    get lastEvents() {
+        return this._lastEvents;
+    }
+
+    /**
+     * Input data from external interface
+     * @param {ProviderEvent} event
+     * @param {EventType} eventType
+     */
+    // eslint-disable-next-line no-unused-vars
+    feed(event, eventType) {
+        throw new Error('Not implemented');
+    }
 }
 
 export default Provider;

package/src/providers/Provider.spec.js

@@ -1,7 +1,6 @@
 /* eslint-disable max-nested-callbacks */
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import noop from 'lodash.noop';
 
 import Logger from '@wemap/logger';
 
@@ -24,18 +23,11 @@ describe('Provider', () => {
 
     it('creation/singleton', () => {
         expect(() => new Provider()).throw(Error);
-        expect(() => Provider.instance).throw(Error);
-        expect(() => FakeProvider1.instance).not.throw(Error);
-        expect(() => FakeProvider2.instance).not.throw(Error);
-        expect(() => FakeProvider3.instance).not.throw(Error);
-        expect(() => FakeProvider4.instance).not.throw(Error);
-        expect(FakeProvider1.instance).equals(FakeProvider1.instance);
-        expect(FakeProvider4.instance).equals(FakeProvider4.instance);
     });
 
 
     it('default getter', () => {
-        const provider = FakeProvider1.instance;
+        const provider = FakeProvider1;
         expect(provider.pname).equals(FakeProvider1.pname);
         expect(provider.eventsType).is.empty;
         expect(provider.hasNativeInterface).is.false;
@@ -45,33 +37,30 @@ describe('Provider', () => {
 
     it('availability', async () => {
 
-        const fakeProvider1 = FakeProvider1.instance;
-        await expect(fakeProvider1.availability).to.be.fulfilled;
+        await expect(FakeProvider1.availability).to.be.fulfilled;
         ProvidersOptions.ignoreProviders.push(FakeProvider1.pname);
-        await expect(fakeProvider1.availability).to.be.rejectedWith(ContainsIgnoredProviderError);
+        await expect(FakeProvider1.availability).to.be.rejectedWith(ContainsIgnoredProviderError);
         ProvidersOptions.ignoreProviders = [];
 
-        await expect(FakeProvider2.instance.availability).to.be.rejectedWith(Error);
+        await expect(FakeProvider2.availability).to.be.rejectedWith(Error);
 
-        await expect(FakeProvider3.instance.availability).to.be.fulfilled;
-        await expect(FakeProvider4.instance.availability).to.be.fulfilled;
+        await expect(FakeProvider3.availability).to.be.fulfilled;
+        await expect(FakeProvider4.availability).to.be.fulfilled;
     });
 
     it('checkAvailability on start', async () => {
 
-        const fp2 = FakeProvider2.instance;
-
         /**
          * checkAvailabilityOnStart = true
          */
         let errored = false;
-        fp2.addEventListener(noop, () => (errored = true));
+        FakeProvider2.addEventListener(() => {}, () => (errored = true));
 
         await sleep(2);
 
         expect(errored).is.true;
-        expect(fp2.state).equals(ProviderState.STOPPPED);
-        expect(fp2._eventsCallbacks.length).equals(0);
+        expect(FakeProvider2.state).equals(ProviderState.STOPPPED);
+        expect(FakeProvider2._eventsCallbacks.length).equals(0);
 
         /**
          * checkAvailabilityOnStart = false
@@ -79,16 +68,16 @@ describe('Provider', () => {
         ProvidersOptions.checkAvailabilityOnStart = false;
 
         errored = false;
-        const id = fp2.addEventListener(noop, () => (errored = true));
+        const id = FakeProvider2.addEventListener(() => {}, () => (errored = true));
 
         await sleep(2);
 
         expect(errored).is.false;
-        expect(fp2.state).equals(ProviderState.STARTED);
+        expect(FakeProvider2.state).equals(ProviderState.STARTED);
 
-        fp2.removeEventListener(id);
-        expect(fp2.state).equals(ProviderState.STOPPPED);
-        expect(fp2._eventsCallbacks.length).equals(0);
+        FakeProvider2.removeEventListener(id);
+        expect(FakeProvider2.state).equals(ProviderState.STOPPPED);
+        expect(FakeProvider2._eventsCallbacks.length).equals(0);
 
         ProvidersOptions.checkAvailabilityOnStart = true;
     });
@@ -122,13 +111,13 @@ describe('Provider', () => {
 
     it('start/stop', async () => {
         let errored = false;
-        FakeProvider1.instance.addEventListener(noop, (errored = true));
+        FakeProvider1.addEventListener(() => {}, (errored = true));
         await sleep(2);
         expect(errored).is.true;
 
-        await expect(startStop(FakeProvider2.instance)).to.be.fulfilled;
-        await expect(startStop(FakeProvider3.instance)).to.be.fulfilled;
-        await expect(startStop(FakeProvider4.instance)).to.be.fulfilled;
+        await expect(startStop(FakeProvider2)).to.be.fulfilled;
+        await expect(startStop(FakeProvider3)).to.be.fulfilled;
+        await expect(startStop(FakeProvider4)).to.be.fulfilled;
 
     });
 });

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.05;
+
+    /** @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

@@ -0,0 +1,232 @@
+import { AbsoluteHeading, Attitude } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+import { PromiseUtils } from '@wemap/utils';
+
+import Provider from '../../Provider.js';
+import EventType from '../../../events/EventType.js';
+import AbsoluteAttitudeFromBrowser from './AbsoluteAttitudeFromBrowser.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 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._attitudeFromRelativeErrored = false;
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'AbsoluteAttitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return PromiseUtils.any([
+            AbsoluteAttitudeFromBrowser.availability,
+            RelativeAttitude.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser.addEventListener(
+            events => this._onAttitudeFromBrowser(events[0]),
+            error => {
+                this._attitudeFromBrowserErrored = true;
+                this.onError(error);
+            }
+        );
+
+        this.relativeAttitudeProviderId = RelativeAttitude.addEventListener(
+            events => this._onRelativeAttitudeEvent(events[0]),
+            error => {
+                this._attitudeFromRelativeErrored = true;
+                this.notifyError(error);
+            }
+        );
+
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
+        RelativeAttitude.removeEventListener(this.relativeAttitudeProviderId);
+    }
+
+    onError(error) {
+        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
+            this.notifyError(error);
+        }
+    }
+
+
+    /**
+     * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
+     */
+    _forceHeadingForRelative = (absoluteHeadingEvent, force = false) => {
+
+        if (!force && this.lastEvent
+            && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
+            return;
+        }
+
+        const currentRelativeHeading = this._relativeAttitude ? this._relativeAttitude.heading : 0;
+
+        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;
+        }
+
+        const { quaternion, accuracy, time } = event.data;
+
+        // Calculate relative accuracy
+        if (this._relativeAttitude) {
+            this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
+        }
+        // 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;
+        }
+
+        const absoluteQuat = Quaternion.multiply(relAbsQuat, quaternion);
+        const attitude = new Attitude(absoluteQuat, time, newAccuracy);
+
+        this.notify(this.createEvent(
+            EventType.AbsoluteAttitude,
+            attitude,
+            [event, this._lastForcedHeadingEvent]
+        ));
+    }
+
+
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _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|ProviderEvent} data
+     */
+    feed(data) {
+
+        if (data instanceof AbsoluteHeading) {
+
+            if (data.time === null) {
+                throw Error('the time of the absolute heading is not defined');
+            }
+            if (data.accuracy === null) {
+                throw Error('the accuracy of the absolute heading is not defined');
+            }
+
+            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
+
+        } else if (data instanceof Attitude) {
+
+            if (data.time === null) {
+                throw Error('the time of the attitude is not defined');
+            }
+            if (data.accuracy === null) {
+                throw Error('the accuracy of the attitude is not defined');
+            }
+
+            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');
+        }
+    }
+}
+
+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);
         }
 
@@ -276,4 +276,4 @@ class AbsoluteAttitudeFromBrowserProvider extends Provider {
     }
 }
 
-export default AbsoluteAttitudeFromBrowserProvider;
+export default new AbsoluteAttitudeFromBrowser();

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

@@ -1,19 +1,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
@@ -85,7 +82,7 @@ class RelativeAttitudeProvider extends Provider {
                     this.notify(relativeAttitudeEvent.clone());
                 }
             },
-            noop,
+            () => {},
             false
         );
     };
@@ -95,4 +92,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
@@ -88,11 +88,10 @@ class RelativeAttitudeFromBrowserProvider extends Provider {
         const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
         const attitude = new Attitude(quaternion,
             e.timeStamp / 1e3,
-            RelativeAttitudeFromInertialProvider.DEFAULT_DRIFT,
-            this.pname
+            RelativeAttitudeFromInertial.DEFAULT_DRIFT
         );
         this.notify(this.createEvent(EventType.RelativeAttitude, attitude));
     };
 }
 
-export default RelativeAttitudeFromBrowserProvider;
+export default new RelativeAttitudeFromBrowser();