@wemap/positioning 1.2.2 → 2.1.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/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;

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -0,0 +1,233 @@
+/* eslint max-statements: ["error", 40]*/
+
+import { WGS84UserPosition } from '@wemap/geo';
+
+import MapMatchingProvider from '../others/MapMatchingProvider';
+import PdrProvider from './pdr/PdrProvider';
+import GnssWifiProvider from '../position/GnssWifiProvider';
+import EventType from '../../events/EventType';
+import AbsoluteAttitudeProvider from '../attitude/AbsoluteAttitudeProvider';
+import Constants from '../Constants';
+import ProviderError from '../../events/ProviderError';
+
+const GPF_ACCURACY = 25;
+const GPF_DISTANCE = 25;
+
+const MM_GNSS_DIST = 20;
+const MM_GNSS_ANGLE = 20;
+
+class GnssWifiPdrProvider extends MapMatchingProvider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.pdrProvider = new PdrProvider(e => this.onPdrEvent(e), e => this.onProviderError(e), options);
+        this.gnssWifiProvider = new GnssWifiProvider(e => this.onGnssWifiEvent(e), e => this.onProviderError(e), options);
+        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(
+            e => this.onAbsoluteAttitudeEvent(e),
+            e => this.onProviderError(e),
+            options
+        );
+
+        this.gpsLastUpdate = 0;
+        this.isFirstGnssUpdate = true;
+        this.isFirstAttitudeUpdate = true;
+    }
+
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'GnssWifiPdr';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    static get requiredProviders() {
+        return [PdrProvider, GnssWifiProvider, AbsoluteAttitudeProvider];
+    }
+
+
+    /**
+     * @override
+     */
+    startInternal() {
+        this.pdrProvider.start();
+        this.gnssWifiProvider.start();
+        this.absoluteAttitudeProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.imuProvider.stop();
+        this.gnssWifiProvider.stop();
+        this.absoluteAttitudeProvider.stop();
+    }
+
+    /**
+     * @private
+     */
+    onPdrEvent(pdrEvent) {
+        pdrEvent.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                this.location = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                this.attitude = event.data;
+            }
+        });
+        this.notify(...pdrEvent);
+    }
+
+    /**
+     * @private
+     */
+    onGnssWifiEvent(events) {
+
+        const gnssWifiEvent = events[0];
+        const location = gnssWifiEvent.data;
+
+        // This should be called to update True North / Magnetic North declination
+        this.absoluteAttitudeProvider.setLocation(location);
+
+        if (location.accuracy > GPF_ACCURACY) {
+            return;
+        }
+
+        this.gnssLocation = location.clone();
+        this.gnssLocation.alt = Constants.DEFAULT_ALTITUDE;
+
+        if (!this.location || this.location
+            && this.location.distanceTo(this.gnssLocation) > GPF_DISTANCE) {
+
+            if (!this.mapMatching || !this.attitude) {
+                this.pdrProvider.setLocation(this.gnssLocation);
+            } else {
+
+                this.gnssLocation.bearing = this.attitude.headingDegrees;
+                const projection = this.mapMatching.getProjection(this.gnssLocation);
+
+                if (projection && projection.projection) {
+
+                    // Create a new location from projection and new GNSS location.
+                    const projectedLocation = WGS84UserPosition.fromWGS84(projection.projection, this.gnssLocation);
+                    this.pdrProvider.setLocation(projectedLocation);
+
+                    // // If nearest element is an edge, use its orientation to set heading
+                    // if (projection.nearestElement instanceof Edge) {
+                    //     const edgeBearing = projection.nearestElement.bearing;
+                    //     const diff1 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing);
+                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing + Math.PI);
+                    //     this.pdrProvider.setHeading(diff1 < diff2 ? edgeBearing : edgeBearing + Math.PI);
+                    // }
+
+                    if (this.lastAttitude) {
+                        this.pdrProvider.setHeading(this.lastAttitude.heading);
+                    }
+
+                } else {
+                    this.pdrProvider.setLocation(this.gnssLocation);
+                }
+            }
+        }
+
+    }
+
+    onAbsoluteAttitudeEvent(events) {
+
+        const attitude = events[0].data;
+
+        if (this.isFirstAttitudeUpdate) {
+            this.pdrProvider.setHeading(attitude.heading);
+            this.isFirstAttitudeUpdate = false;
+        }
+
+        this.lastAttitude = attitude;
+    }
+
+    onProviderError(errors) {
+        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsoluteAttitude));
+        this.notifyError(...ProviderError.modifyArrayDataType(errors, EventType.AbsolutePosition));
+    }
+
+    /**
+     * @override
+     */
+    static checkAvailabilityErrors() {
+        const errors = super.checkAvailabilityErrors();
+        return ProviderError.modifyArrayDataType(
+            errors,
+            EventType.AbsolutePosition
+        ).concat(
+            ProviderError.modifyArrayDataType(
+                errors,
+                EventType.AbsoluteAttitude
+            )
+        );
+    }
+
+    /**
+     * MapMatching
+     */
+
+    enableMapMatching(network = null, maxDistance = MM_GNSS_DIST, maxAngleBearing = MM_GNSS_ANGLE) {
+        this.pdrProvider.enableMapMatching(network, maxDistance, maxAngleBearing);
+        super.enableMapMatching(network, maxDistance, maxAngleBearing);
+    }
+
+
+    setNetwork(network) {
+        this.pdrProvider.setNetwork(network);
+        super.setNetwork(network);
+    }
+
+    /**
+     * Itinerary
+     */
+
+    setItinerary(itinerary) {
+
+        const isFirstItinerary = !this.itinerary;
+
+        super.setItinerary(itinerary);
+
+        if (isFirstItinerary && itinerary.length > 0) {
+
+            // When the first itinerary is received, first or second node (depending on MM_GNSS_DIST) is used as a starting point. No map-matching is needed here as router already provide the projection in the itinerary (node2 is node1 projection on OSRM network).
+
+            if (!this.gnssLocation
+                || itinerary.length < 2
+                || !itinerary.points[0].equalsTo(this.gnssLocation)) {
+                console.warn('Itinerary has not been calculated from GnssWifiPdrProvider and these is not recommanded');
+            }
+
+            let startEdge;
+            if (itinerary.firstEdge.getLength() <= MM_GNSS_DIST) {
+                startEdge = itinerary.firstEdge;
+            } else {
+                startEdge = itinerary.secondEdge;
+            }
+            const startPoint = WGS84UserPosition.fromWGS84(startEdge.node1);
+            startPoint.alt = Constants.DEFAULT_ALTITUDE;
+            this.pdrProvider.setLocation(startPoint);
+            this.pdrProvider.setStepDetectionLockerOrientation(startEdge.getBearing());
+        }
+
+    }
+
+}
+
+export default GnssWifiPdrProvider;