@wemap/positioning 2.0.0 → 2.2.0

package/src/providers/others/ImuProvider.js

@@ -0,0 +1,186 @@
+import { deg2rad } from '@wemap/maths';
+import {
+    Browser, BrowserUtils
+} from '@wemap/utils';
+
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import MissingAccelerometerError from '../../errors/MissingAccelerometerError';
+import MissingGyroscopeError from '../../errors/MissingGyroscopeError';
+import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError';
+
+/**
+ * Imu (Inertial Measurement Unit) provider retrieve acceleration data
+ *  and/or angular rate data from inertial sensors.
+ * opions.require has to be defined in order to work
+ *
+ * -----------------------------------
+ * 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 {
+
+    requiredSensors = [];
+
+    /**
+     * Constructor of ImuProvider
+     * options.require has to be filled by a list of EventType
+     * @example options = {require: [EventType.Acceleration, EventType.AngularRate]};
+     * @example options = {require: [EventType.Acceleration]};
+     *
+     * @param {Function} onEvent @see Provider#constructor
+     * @param {Function} onError @see Provider#constructor
+     * @param {Object} options @see Provider#constructor
+     */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        if (!options.hasOwnProperty('require')) {
+            throw new Error('options.require is missing in ImuProvider constructor');
+        }
+
+        if (options.require.length === 0) {
+            throw new Error('option.require is empty');
+        }
+
+        options.require.forEach(elem => {
+            if (!ImuProvider.eventsType.includes(elem)) {
+                throw new Error(elem + ' is not recognised in options.require');
+            }
+        });
+
+        this.requiredSensors = options.require;
+    }
+
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Inertial Measurement Unit';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AngularRate, EventType.Acceleration];
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+
+        if (BrowserUtils.isMobile) {
+            return [];
+        }
+
+        return [
+            ImuProvider.createError(
+                EventType.AngularRate,
+                new AskImuOnDesktopError()
+            ),
+            ImuProvider.createError(
+                EventType.Acceleration,
+                new AskImuOnDesktopError()
+            )
+        ];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        window.addEventListener('devicemotion', this.parseDeviceMotionEvent, true);
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        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;
+
+        if (this.requiredSensors.includes(EventType.Acceleration)) {
+
+            let acc;
+            if (e.accelerationIncludingGravity) {
+                const {
+                    x, y, z
+                } = e.accelerationIncludingGravity;
+
+                if (x && y && z) {
+                    acc = [x, y, z];
+
+                    if (BrowserUtils.name === Browser.SAFARI) {
+                        acc[0] *= -1;
+                        acc[1] *= -1;
+                        acc[2] *= -1;
+                    }
+                }
+            }
+
+            if (!acc) {
+                super.notifyError(this.createError(
+                    EventType.AngularRate,
+                    new MissingAccelerometerError().from('devicemotion'),
+                    timestamp
+                ));
+                return;
+            }
+
+            events.push(this.createEvent(EventType.Acceleration, acc, timestamp));
+        }
+
+
+        if (this.requiredSensors.includes(EventType.AngularRate)) {
+
+            let gyr;
+            if (e.rotationRate) {
+                const {
+                    alpha, beta, gamma
+                } = e.rotationRate;
+
+                if (alpha && beta && gamma) {
+                    gyr = [deg2rad(alpha), deg2rad(beta), deg2rad(gamma)];
+                }
+            }
+
+            if (!gyr) {
+                super.notifyError(this.createError(EventType.AngularRate,
+                    new MissingGyroscopeError().from('devicemotion'),
+                    timestamp));
+                return;
+            }
+
+            events.push(this.createEvent(EventType.AngularRate, gyr, timestamp));
+        }
+
+        if (events.length !== 0) {
+            super.notify(...events);
+        }
+    }
+
+}
+
+export default ImuProvider;

package/src/providers/others/InclinationProvider.js

@@ -0,0 +1,107 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import ImuProvider from './ImuProvider';
+import ProviderError from '../../events/ProviderError';
+
+/**
+ * Inclination provider gives the inclination of the device using Imu Sensor
+ * For example, when the top of the device is pointing the sky, inclination = Math.PI/2
+ *              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 Provider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.imuProvider = new ImuProvider(
+            this.onImuEvent,
+            this.onImuError,
+            { require: [EventType.Acceleration] }
+        );
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Inertial Measurement Unit';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Inclination];
+    }
+
+    /**
+     * @override
+     */
+    static get requiredProviders() {
+        return [ImuProvider];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        return this.imuProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        return this.imuProvider.stop();
+    }
+
+    /**
+     * @private
+     */
+    onImuEvent = imuEvent => {
+        const accelerationEvent = imuEvent[0];
+        const acc = accelerationEvent.data;
+
+        const screenOrientation = window.orientation || 0;
+
+        const sizeAcc = Math.sqrt(acc[0] * acc[0] + acc[1] * acc[1] + acc[2] * acc[2]);
+        const accNormalized = [acc[0] / sizeAcc, acc[1] / sizeAcc, acc[2] / sizeAcc];
+
+        const q = [accNormalized[2] + 1, accNormalized[1], -accNormalized[0], 0];
+        const qSize = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2]);
+        const qNormalized = [q[0] / qSize, q[1] / qSize, q[2] / qSize, 0];
+
+        let inclination;
+        if (screenOrientation === 0) {
+            inclination = Math.asin(2 * qNormalized[1] * qNormalized[0]);
+        } else if (screenOrientation === 90) {
+            inclination = -Math.asin(2 * qNormalized[2] * qNormalized[0]);
+        } else if (screenOrientation === -90) {
+            inclination = Math.asin(2 * qNormalized[2] * qNormalized[0]);
+        } else if (screenOrientation === 180) {
+            inclination = -Math.asin(2 * qNormalized[1] * qNormalized[0]);
+        }
+
+        this.notify(this.createEvent(EventType.Inclination, inclination));
+    };
+
+    onImuError = imuErrors => {
+        this.notifyError(...ProviderError.modifyArrayDataType(imuErrors, EventType.Inclination));
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        return ProviderError.modifyArrayDataType(
+            super.checkAvailabilityErrors(),
+            EventType.Inclination
+        );
+    }
+}
+
+export default InclinationProvider;

package/{src.old/providers/LocationSource.js → src/providers/others/MapMatchingProvider.js}

@@ -1,150 +1,9 @@
+import Provider from '../Provider';
 import {
-    MapMatching, Network, Itinerary, Edge, WGS84
+    WGS84, Edge, Itinerary, Network, MapMatching
 } from '@wemap/geo';
 
-import Pose from '../Pose';
-import Constants from '../Constants';
-import SensorsLogger from '../sensors/SensorsLogger';
-import ProvidersLogger from './ProvidersLogger';
-
-/**
- * A LocationSource is an independant component which can be instantiate to provide a pose (localisation and orientation)
- * @see PdrLocationSource
- * @see GnssPdrLocationSource
- * @see GnssLocationSource
- * @see IPLocationSource
- */
-class LocationSource {
-
-    /**
-     * Constructor of a LocationSource
-     * This constructor must be called by any implementation of a LocationSource
-     * @param {Function} callback function called when a new location or new orientation is calculated
-     * @protected
-     */
-    constructor(callback) {
-        if (new.target === LocationSource) {
-            throw new TypeError('Cannot instantiate LocationSource directly');
-        }
-        ProvidersLogger.addEvent(this, 'constructor');
-        this.callback = callback;
-        this.pose = new Pose();
-    }
-
-    /**
-     * Start the LocationSource
-     * @public
-     */
-    start() {
-        ProvidersLogger.addEvent(this, 'start');
-    }
-
-    /**
-     * Stop the LocationSource
-     * @public
-     */
-    stop() {
-        ProvidersLogger.addEvent(this, 'stop');
-    }
-
-    /**
-     * Same than providerName but with options
-     * @public
-     */
-    get providerNameWithOptions() {
-        return this.providerName;
-    }
-
-    /**
-     * Set a logger to record raw data
-     * @param {SensorsLogger} logger the sensors logger
-     */
-    setLogger(logger) {
-
-        if (logger && !(logger instanceof SensorsLogger)) {
-            throw new Error('logger is not an instance of SensorsLogger');
-        }
-
-        this.logger = logger;
-    }
-
-    /**
-     * @see providerName
-     * @public
-     */
-    static get providerName() {
-        return null;
-    }
-
-    /**
-     * Explicit name of Location Source
-     * This name is used in "provider" of pose.location
-     * @returns provider name
-     * @public
-     */
-    get providerName() {
-        return this.constructor.providerName;
-    }
-
-    /**
-     * Get current pose
-     * @returns current pose
-     * @public
-     */
-    getPose() {
-        return this.pose;
-    }
-
-    /**
-     * This method must be called to notify callback when pose changed
-     * @protected
-     */
-    notify() {
-        ProvidersLogger.addPushEvent(this);
-
-        if (!this.callback) {
-            return;
-        }
-
-        if (!this.pose.location) {
-            return;
-        }
-
-        this.pose.location.provider = this.providerName;
-        this.callback(this.pose);
-    }
-
-    /**
-     * Get most accurate LocationSource from two LocationSource
-     * @param {LocationSource} ls1 LocationSource 1
-     * @param {LocationSource} ls2 LocationSource 2
-     * @returns The most accuracte LocationSource
-     * @public
-     */
-    static getMostAccurateLocationSource(ls1, ls2) {
-
-        if (!(ls1 instanceof LocationSource)) {
-            throw new TypeError(ls1 + ' is not an instance of LocationSource');
-        }
-
-        if (!(ls2 instanceof LocationSource)) {
-            throw new TypeError(ls2 + ' is not an instance of LocationSource');
-        }
-
-        const accuracyOrder = [];
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.IP] = 0;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.GNSS] = 1;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.GNSS_PDR] = 2;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.PDR] = 3;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.FIXED_LOCATION] = 4;
-
-        return accuracyOrder[ls1.providerName] > accuracyOrder[ls2.providerName] ? ls1 : ls2;
-    }
-
-
-    /**
-     * MapMatching
-     */
+class MapMatchingProvider extends Provider {
 
     /**
      * Enable LocationSource mapmatching
@@ -153,7 +12,7 @@ class LocationSource {
      * @param {*} maxAngleBearing threshold to match a parallel segment for angle between location bearing and segment. null disables this threshold (default: null)
      * @public
      */
-    enableMapMatching(network = null, maxDistance = null, maxAngleBearing = null) {
+    enableMapMatching(network, maxDistance, maxAngleBearing) {
         this.mapMatching = new MapMatching();
         this.mapMatching.maxDistance = maxDistance;
         this.mapMatching.maxAngleBearing = maxAngleBearing;
@@ -283,8 +142,6 @@ class LocationSource {
             remainingPercentage: 1 - traveledDistance / totalDistance
         };
     }
-
-
 }
 
-export default LocationSource;
+export default MapMatchingProvider;

package/src/providers/pose/ArCoreProvider.js

@@ -0,0 +1,127 @@
+import { Attitude } from '@wemap/geo';
+
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import MissingArCoreError from '../../errors/MissingArCoreError';
+
+/**
+ * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
+ * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
+ */
+class ArCoreProvider extends Provider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'ArCore provider';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude, EventType.RelativePosition];
+    }
+
+    /**
+     * Return the list of required providers
+     */
+    static get requiredProviders() {
+        return [];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(nativeProvider);
+            return;
+        }
+        nativeProvider.start();
+
+        this.pullDataLoop();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(nativeProvider);
+            return;
+        }
+        nativeProvider.stop();
+    }
+
+    pullDataLoop = () => {
+
+        if (this.state !== Provider.State.STARTED) {
+            return;
+        }
+
+        const nativeProvider = this.constructor.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            this.notifyError(...nativeProvider);
+            return;
+        }
+
+        const pose = JSON.parse(nativeProvider.getInfo());
+        if (pose.length !== 0) {
+            const attitude = new Attitude(pose.slice(0, 4));
+            const position = pose.slice(4, 7);
+            this.notify(
+                this.createEvent(EventType.RelativeAttitude, attitude),
+                this.createEvent(EventType.RelativePosition, position)
+            );
+        }
+
+        requestAnimationFrame(this.pullDataLoop);
+    }
+
+    static getNativeProvider() {
+        const nativeInterface = this.getNativeInterface();
+
+        if (!nativeInterface) {
+            return [
+                this.createMissingNativeInterfaceError(EventType.RelativeAttitude),
+                this.createMissingNativeInterfaceError(EventType.RelativePosition)
+            ];
+        }
+
+        return nativeInterface.getArCoreProvider();
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+
+        const nativeProvider = this.getNativeProvider();
+        if (Array.isArray(nativeProvider)) {
+            return nativeProvider;
+        }
+
+        if (nativeProvider.checkAvailability()) {
+            return [];
+        }
+
+        return [
+            this.createError(EventType.RelativeAttitude, new MissingArCoreError()),
+            this.createError(EventType.RelativePosition, new MissingArCoreError())
+        ];
+    }
+}
+
+export default ArCoreProvider;