@wemap/positioning 2.0.0 → 2.1.0

package/src/providers/attitude/RelativeAttitudeProvider.js

@@ -0,0 +1,129 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import EkfAttitude from './EkfAttitude';
+import ImuProvider from '../others/ImuProvider';
+import { Attitude } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+import ProviderError from '../../events/ProviderError';
+
+
+/**
+ * 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 {
+
+    lastTimestamp = 0;
+
+    /**
+     * @override
+     */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.ekfAttitude = new EkfAttitude();
+        this.relativeOffsetQuaternion = [1, 0, 0, 0];
+
+        this.imuProvider = new ImuProvider(this.onImuEvent,
+            this.onImuError, { require: [EventType.Acceleration, EventType.AngularRate] });
+
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Relative Attitude from Ekf';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude];
+    }
+
+    /**
+     * @override
+     */
+    static get requiredProviders() {
+        return [ImuProvider];
+    }
+
+    /**
+     * @override
+     */
+    startInternal() {
+        this.imuProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stopInternal() {
+        this.imuProvider.stop();
+    }
+
+    /**
+     * @private
+     */
+    onImuEvent = imuEvent => {
+
+        let timestamp, acceleration, angularRate;
+        imuEvent.forEach(event => {
+            if (event.dataType === EventType.Acceleration) {
+                acceleration = event.data;
+                timestamp = event.timestamp;
+            } else if (event.dataType === EventType.AngularRate) {
+                angularRate = event.data;
+            }
+        });
+
+        // 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, angularRate);
+
+        if (quaternion) {
+            this.notify(this.createEvent(EventType.RelativeAttitude, new Attitude(quaternion), timestamp));
+        }
+    };
+
+    /**
+     *
+     * Set yaw offset, this value will be used as the filter does not use magnetometer
+     * @param {Number} heading heading offset in radians and clockwise
+     */
+    setOffset(_heading) {
+
+        // Minus before "heading" is here because ENU attitude is counter-clockwise whereas WGS84 heading is clockwise.
+        let heading = -_heading;
+
+        // Offset from window orientation
+        heading += deg2rad(window.orientation || 0);
+
+        this.ekfAttitude.setOrientationYaw(heading);
+    }
+
+    onImuError = imuErrors => {
+        this.notifyError(...ProviderError.modifyArrayDataType(imuErrors, EventType.RelativeAttitude));
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        return ProviderError.modifyArrayDataType(
+            super.checkAvailabilityErrors(),
+            EventType.RelativeAttitude
+        );
+    }
+}
+
+export default RelativeAttitudeProvider;

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/providers/others/MapMatchingProvider.js

@@ -0,0 +1,147 @@
+import Provider from '../Provider';
+import {
+    WGS84, Edge, Itinerary, Network, MapMatching
+} from '@wemap/geo';
+
+class MapMatchingProvider extends Provider {
+
+    /**
+     * Enable LocationSource mapmatching
+     * @param {*} network a network which will be used for map matching
+     * @param {*} maxDistance max distance between location and network to match. null disables maxDistance (default: null)
+     * @param {*} maxAngleBearing threshold to match a parallel segment for angle between location bearing and segment. null disables this threshold (default: null)
+     * @public
+     */
+    enableMapMatching(network, maxDistance, maxAngleBearing) {
+        this.mapMatching = new MapMatching();
+        this.mapMatching.maxDistance = maxDistance;
+        this.mapMatching.maxAngleBearing = maxAngleBearing;
+
+        if (network) {
+            this.setNetwork(network);
+        }
+    }
+
+    /**
+     * Update the LocationSource network for mapmatching
+     * @param {Network} network a network instance
+     * @public
+     */
+    setNetwork(network) {
+        if (!(network instanceof Network)) {
+            throw new TypeError(network + ' is not an instance of Network');
+        }
+        if (!this.mapMatching) {
+            throw new Error('MapMatching is not enabled');
+        }
+        this.mapMatching.setNetwork(network);
+    }
+
+    /**
+     * Is mapmatching activated?
+     * @returns is mapmatching activated
+     * @public
+     */
+    get hasMapMatching() {
+        return this.mapMatching !== null;
+    }
+
+    /**
+     * Returns projection of a location on network
+     * @param {WGS84} location if location is null, projection of this.pose.location is used
+     * @returns The projected location {WGS84} or null.
+     * @public
+     */
+    getProjectionOnNetwork(location = null) {
+
+        if (!this.mapMatching) {
+            return null;
+        }
+
+        let locationToProject = location;
+        if (!location) {
+            locationToProject = this.pose.location;
+        }
+        if (!locationToProject) {
+            return null;
+        }
+
+        return this.mapMatching.getProjection(locationToProject, false, false);
+    }
+
+
+    /**
+     * Itinerary
+     */
+
+    /**
+     * Update itinerary of Location Source.
+     * Itinerary is different from network, it is not used for mapmatching. It can be used for others tricks like HeadingUnlocker
+     * @param {Itinerary} itinerary a given itinerary
+     * @public
+     */
+    setItinerary(itinerary) {
+        if (!(itinerary instanceof Itinerary)) {
+            throw new TypeError(itinerary + ' is not an instance of Itinerary');
+        }
+        this.itinerary = itinerary;
+    }
+
+
+    /**
+     * Returns projection and itinerary info of a location on network
+     * @param {WGS84} location if location is null, projection of this.pose.location is used
+     * @returns An object of the projected location and itinerary info or null.
+     * @public
+     */
+    getItineraryInfo(location = null) {
+
+        if (!this.itinerary) {
+            throw new Error('No itinerary found');
+        }
+        const projection = this.getProjectionOnNetwork(location);
+        if (!projection) {
+            return null;
+        }
+
+        const totalDistance = this.itinerary.distance;
+        let traveledDistance = 0;
+        const edges = this.itinerary.edges;
+
+        if (projection.nearestElement instanceof WGS84) {
+
+            for (let i = 0; i < edges.length; i++) {
+                const edge = edges[i];
+                if (edge.node1.equalsTo(projection.nearestElement)) {
+                    break;
+                }
+                traveledDistance += edge.getLength();
+            }
+
+
+        } else if (projection.nearestElement instanceof Edge) {
+
+            for (let i = 0; i < edges.length; i++) {
+                const edge = edges[i];
+                if (edge.equalsTo(projection.nearestElement)) {
+                    traveledDistance += edge.node1.distanceTo(projection.projection);
+                    break;
+                }
+                traveledDistance += edge.getLength();
+            }
+
+        } else {
+            throw new Error('No projection found');
+        }
+
+        return {
+            projection: projection,
+            traveledDistance,
+            traveledPercentage: traveledDistance / totalDistance,
+            remainingDistance: totalDistance - traveledDistance,
+            remainingPercentage: 1 - traveledDistance / totalDistance
+        };
+    }
+}
+
+export default MapMatchingProvider;