@wemap/providers 3.0.0

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

@@ -0,0 +1,143 @@
+import {
+    AbsoluteHeading, Attitude
+} from '@wemap/geo';
+
+import MetaProvider from '../../MetaProvider';
+import EventType from '../../../events/EventType';
+import Availability from '../../../events/Availability';
+import {
+    AbsoluteAttitudeFromBrowser, AbsoluteAttitudeFromRelAtt
+} from '../../../Providers';
+
+
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+class AbsoluteAttitudeProvider extends MetaProvider {
+
+    constructor() {
+        super();
+
+        this.attitudeFromBrowserErrored = false;
+        this.attitudeFromRelAttErrored = false;
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Absolute Attitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            AbsoluteAttitudeFromBrowser.availability,
+            AbsoluteAttitudeFromRelAtt.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser.addEventListener(
+            events => this.onAttitudeFromBrowser(events[0]),
+            error => {
+                this.attitudeFromBrowserErrored = true;
+                this.onError(error);
+            },
+            this.name);
+
+        this.fromRelAttProviderId = AbsoluteAttitudeFromRelAtt.addEventListener(
+            events => this.onAttitudeFromRelAtt(events[0]),
+            error => {
+                this.attitudeFromRelAttErrored = true;
+                this.onError(error);
+            },
+            this.name);
+    }
+
+    onError(error) {
+        if (this.attitudeFromBrowserErrored && this.attitudeFromRelAttErrored) {
+            this.notifyError(error);
+        }
+    }
+
+    onAttitudeFromBrowser(event) {
+        this.eventFromBrowser = event;
+        if (!this.eventFromRelAtt
+            || event.data.accuracy <= this.eventFromRelAtt.data.accuracy) {
+            this.notify(event.clone());
+        }
+    }
+
+    onAttitudeFromRelAtt(event) {
+        this.eventFromRelAtt = event;
+        if (!this.eventFromBrowser
+            || event.data.accuracy <= this.eventFromBrowser.data.accuracy) {
+            this.notify(event.clone());
+        }
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitudeFromBrowser.removeEventListener(this.fromBrowserProviderId);
+        AbsoluteAttitudeFromRelAtt.removeEventListener(this.fromRelAttProviderId);
+    }
+
+    /**
+     * @override
+     * @param {AbsoluteHeading|Attitude} 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.notify(this.createEvent(
+                EventType.AbsoluteAttitude,
+                data.toAttitude(),
+                data.time
+            ));
+
+        } 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.notify(this.createEvent(
+                EventType.AbsoluteAttitude,
+                data,
+                data.time
+            ));
+
+        } else {
+            throw new Error('data is nor an AbsoluteHeading or an Attitude object');
+        }
+    }
+}
+
+export default AbsoluteAttitudeProvider;

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

@@ -0,0 +1,89 @@
+import isnumber from 'lodash.isnumber';
+
+import { Attitude } from '@wemap/geo';
+import { Rotations } from '@wemap/maths';
+import { BrowserUtils } from '@wemap/utils';
+
+import Provider from '../../Provider';
+import EventType from '../../../events/EventType';
+import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError';
+import MissingSensorError from '../../../errors/MissingSensorError';
+import Availability from '../../../events/Availability';
+import RelativeAttitudeProvider from './RelativeAttitudeProvider';
+
+
+/**
+ * Relative attitude provider gives the device attitude in a custom frame (x-right, y-front, z-up) using
+ *  browser deviceorientation
+ *
+ * -----------------------------------
+ * Overview of compatibilities:
+ * -----------------------------------
+ *
+ * Chrome Android (v72.0.3626): YES (via deviceorientation but deviceorientation.alpha is unreliable! Sometimes it starts at 0°, sometimes at 270°)
+ * Safari iOS (v12.0): YES (via deviceorientation)
+ * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
+ * Firefox Android (v65.0.1): YES (via deviceorientation)
+ *
+ * -----------------------------------
+ */
+class RelativeAttitudeFromBrowserProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Relative Attitude from Browser';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return BrowserUtils.isMobile
+            ? Availability.yes()
+            : Availability.no(new AskImuOnDesktopError());
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        window.addEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        window.removeEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
+    }
+
+
+    onDeviceOrientationEvent = e => {
+
+        const timestamp = e.timeStamp / 1e3;
+
+        if (!isnumber(e.alpha) || !isnumber(e.beta) || !isnumber(e.gamma)) {
+            this.notifyError(new MissingSensorError().from('deviceorientation'));
+            return;
+        }
+
+        const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
+        const attitude = new Attitude(quaternion,
+            timestamp,
+            RelativeAttitudeProvider.DEFAULT_DRIFT,
+            this.name
+        );
+        this.notify(this.createEvent(EventType.RelativeAttitude, attitude, timestamp));
+    };
+}
+
+export default RelativeAttitudeFromBrowserProvider;

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

@@ -0,0 +1,114 @@
+import { Attitude } from '@wemap/geo';
+
+import Provider from '../../Provider';
+import Availability from '../../../events/Availability';
+import EventType from '../../../events/EventType';
+import EkfAttitude from '../EkfAttitude';
+import RelativeAttitudeProvider from './RelativeAttitudeProvider';
+import {
+    Accelerometer, Gyroscope
+} from '../../../Providers';
+
+
+/**
+ * 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 RelativeAttitudeFromEkfProvider extends Provider {
+
+    lastTimestamp = 0;
+
+    /**
+     * @override
+     */
+    constructor(context) {
+        super(context);
+        this.ekfAttitude = new EkfAttitude();
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Relative Attitude from Ekf';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.merge(
+            Accelerometer.availability,
+            Gyroscope.availability,
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            this.notifyError,
+            this.name);
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.gyroscopeEvent = events[0]),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+    }
+
+    /**
+     * @private
+     */
+    onAccelerometerEvent = accelerationEvent => {
+
+        if (!this.gyroscopeEvent) {
+            return;
+        }
+
+        const acceleration = accelerationEvent.data;
+        const { timestamp } = accelerationEvent;
+
+        // Handle timestamps and dt
+        if (this.lastTimestamp === 0) {
+            this.lastTimestamp = timestamp;
+            return;
+        }
+        const diffTime = timestamp - this.lastTimestamp;
+        this.lastTimestamp = timestamp;
+
+        const quaternion = this.ekfAttitude.update(diffTime, acceleration, this.gyroscopeEvent.data);
+
+        if (quaternion) {
+            const attitude = new Attitude(quaternion,
+                timestamp,
+                RelativeAttitudeProvider.DEFAULT_DRIFT,
+                this.name
+            );
+            this.notify(this.createEvent(
+                EventType.RelativeAttitude,
+                attitude,
+                timestamp,
+                [accelerationEvent, this.gyroscopeEvent]));
+        }
+    };
+}
+
+export default RelativeAttitudeFromEkfProvider;

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

@@ -0,0 +1,103 @@
+import { deg2rad } from '@wemap/maths';
+
+import Provider from '../../Provider';
+import EventType from '../../../events/EventType';
+import Availability from '../../../events/Availability';
+import noop from 'lodash.noop';
+import ProviderState from '../../ProviderState';
+import {
+    RelativeAttitudeFromEkf, RelativeAttitudeFromBrowser, ArCore
+} from '../../../Providers';
+
+
+/**
+ * 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 {
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    static DEFAULT_DRIFT = deg2rad(15) / 60;
+
+
+    lastTimestamp = 0;
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Relative Attitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            RelativeAttitudeFromEkf.availability,
+            RelativeAttitudeFromBrowser.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.provider = RelativeAttitudeFromEkf.availability.isSupported
+            ? RelativeAttitudeFromEkf
+            : RelativeAttitudeFromBrowser;
+
+        this.listenerId = this.provider.addEventListener(
+            events => {
+                if (ArCore.state === ProviderState.STOPPPED) {
+                    this.notify(events[0].clone());
+                }
+            },
+            this.notifyError,
+            this.name);
+
+
+        this.arCoreMonitoringId = ArCore.addMonitoringListener(this.listenArCore, this.unlistenArCore);
+        if (ArCore.state === ProviderState.STARTED) {
+            this.listenArCore();
+        }
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.provider.removeEventListener(this.listenerId);
+        ArCore.removeMonitoringListener(this.arCoreMonitoringId);
+        this.unlistenArCore();
+    }
+
+    listenArCore = () => {
+        this.arCoreProviderId = ArCore.addEventListener(
+            events => {
+                const relativeAttitudeEvent = events.find(event => event.dataType === EventType.RelativeAttitude);
+                if (relativeAttitudeEvent) {
+                    this.notify(relativeAttitudeEvent.clone());
+                }
+            },
+            noop,
+            this.name,
+            false
+        );
+    };
+
+    unlistenArCore = () => {
+        ArCore.removeEventListener(this.arCoreProviderId);
+    }
+}
+
+export default RelativeAttitudeProvider;

package/src/providers/imu/AccelerometerProvider.js

@@ -0,0 +1,61 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import MissingAccelerometerError from '../../errors/MissingAccelerometerError';
+import { Imu } from '../../Providers';
+
+class AccelerometerProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Accelerometer';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Acceleration];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Imu.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Imu.addEventListener(
+            events => this.parseImuEvents(events),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Imu.removeEventListener(this.providerId);
+    }
+
+    /**
+     * @private
+     */
+    parseImuEvents = events => {
+
+        const accelerationEvent = events.find(event => event.dataType === EventType.Acceleration);
+        if (!accelerationEvent) {
+            this.notifyError(new MissingAccelerometerError().from('devicemotion'));
+            return;
+        }
+        this.notify(accelerationEvent.clone());
+    }
+
+}
+
+export default AccelerometerProvider;

package/src/providers/imu/GyroscopeProvider.js

@@ -0,0 +1,61 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import MissingGyroscopeError from '../../errors/MissingGyroscopeError';
+import { Imu } from '../../Providers';
+
+class GyroscopeProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Gyroscope';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AngularRate];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Imu.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Imu.addEventListener(
+            events => this.parseImuEvents(events),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Imu.removeEventListener(this.providerId);
+    }
+
+    /**
+     * @private
+     */
+    parseImuEvents = events => {
+
+        const gyroscopeEvent = events.find(event => event.dataType === EventType.AngularRate);
+        if (!gyroscopeEvent) {
+            this.notifyError(new MissingGyroscopeError().from('devicemotion'));
+            return;
+        }
+        this.notify(gyroscopeEvent.clone());
+    }
+
+}
+
+export default GyroscopeProvider;

package/src/providers/imu/ImuProvider.js

@@ -0,0 +1,122 @@
+import isnumber from 'lodash.isnumber';
+
+import { deg2rad } from '@wemap/maths';
+import {
+    Browser, BrowserUtils
+} from '@wemap/utils';
+
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError';
+import Availability from '../../events/Availability';
+
+/**
+ * Imu (Inertial Measurement Unit) provider retrieve acceleration data
+ *  and/or angular rate data from inertial sensors.
+ *
+ * -----------------------------------
+ * Overview of compatibilities:
+ * -----------------------------------
+ *
+ * Chrome Android (v72.0.3626): YES (via devicemotion)
+ * Safari iOS (v12.0): YES (via devicemotion)
+ * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent}
+ * Firefox Android (v65.0.1): YES (via devicemotion)
+ *
+ * -----------------------------------
+ */
+class ImuProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Inertial Measurement Unit';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AngularRate, EventType.Acceleration];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return BrowserUtils.isMobile
+            ? Availability.yes()
+            : Availability.no(new AskImuOnDesktopError());
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        window.addEventListener('devicemotion', this.parseDeviceMotionEvent, true);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        window.removeEventListener('devicemotion', this.parseDeviceMotionEvent, true);
+    }
+
+    /**
+     * devicemotion callback
+     * @param {DeviceMotionEvent} e device motion event
+     * @returns {ProviderEvent[]} an array of provider events
+     * @private
+     */
+    parseDeviceMotionEvent = e => {
+
+        const events = [];
+
+        const timestamp = e.timeStamp / 1e3;
+
+        let acc;
+        if (e.accelerationIncludingGravity) {
+            const {
+                x, y, z
+            } = e.accelerationIncludingGravity;
+
+            if (isnumber(x) && isnumber(y) && isnumber(z)) {
+                acc = [x, y, z];
+
+                if (BrowserUtils.name === Browser.SAFARI) {
+                    acc[0] *= -1;
+                    acc[1] *= -1;
+                    acc[2] *= -1;
+                }
+            }
+        }
+
+        if (acc) {
+            events.push(this.createEvent(EventType.Acceleration, acc, timestamp));
+        }
+
+        let gyr;
+        if (e.rotationRate) {
+            const {
+                alpha, beta, gamma
+            } = e.rotationRate;
+
+            if (isnumber(alpha) && isnumber(beta) && isnumber(gamma)) {
+                gyr = [deg2rad(alpha), deg2rad(beta), deg2rad(gamma)];
+            }
+        }
+
+        if (gyr) {
+            events.push(this.createEvent(EventType.AngularRate, gyr, timestamp));
+        }
+
+        if (events.length !== 0) {
+            this.notify(...events);
+        }
+    }
+
+}
+
+export default ImuProvider;