@wemap/providers 3.0.0

package/src/providers/inclination/InclinationFromAccProvider.js

@@ -0,0 +1,87 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import { Accelerometer } from '../../Providers';
+
+/**
+ * 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 InclinationFromAccProvider extends Provider {
+
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Inclination from acceleration';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Inclination];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Accelerometer.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.providerId);
+    }
+
+    /**
+     * @private
+     */
+    onAccelerometerEvent = accelerometerEvent => {
+        const acc = accelerometerEvent.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,
+            accelerometerEvent.timestamp,
+            [accelerometerEvent]
+        ));
+    };
+}
+
+export default InclinationFromAccProvider;

package/src/providers/inclination/InclinationFromAttitudeProvider.js

@@ -0,0 +1,77 @@
+import Provider from '../Provider';
+import EventType from '../../events/EventType';
+import { Attitude } from '../../Providers';
+
+/**
+ * Inclination provider gives the inclination of the device using Relative Attitude
+ * 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 InclinationFromAttitudeProvider extends Provider {
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Inclination from attitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Inclination];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Attitude.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Attitude.addEventListener(
+            events => {
+                const attitudeEvent = events[0];
+                const inclination = this.constructor.enuQuatToInclination(
+                    attitudeEvent.data.quaternion
+                );
+                this.notify(this.createEvent(
+                    EventType.Inclination,
+                    inclination,
+                    attitudeEvent.timestamp,
+                    [attitudeEvent]
+                ));
+            },
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Attitude.removeEventListener(this.providerId);
+    }
+
+    static enuQuatToInclination(q) {
+        const screenOrientation = window.orientation || 0;
+
+        if (screenOrientation === 0) {
+            return Math.asin(2 * (q[2] * q[3] + q[1] * q[0]));
+        } else if (screenOrientation === 90) {
+            return Math.asin(2 * (q[1] * q[3] - q[2] * q[0]));
+        } else if (screenOrientation === -90) {
+            return Math.asin(2 * (q[2] * q[0] - q[1] * q[3]));
+        }
+        // else if (screenOrientation === 180)
+        return -Math.asin(2 * (q[2] * q[3] + q[1] * q[0]));
+    }
+}
+
+export default InclinationFromAttitudeProvider;

package/src/providers/inclination/InclinationProvider.js

@@ -0,0 +1,69 @@
+import MetaProvider from '../MetaProvider';
+import EventType from '../../events/EventType';
+import Availability from '../../events/Availability';
+import {
+    InclinationFromAttitude, InclinationFromAcc
+} from '../../Providers';
+
+/**
+ * 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 MetaProvider {
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.Inclination];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.union(
+            InclinationFromAcc.availability,
+            InclinationFromAttitude.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        const startInclinationFromAcc = () => {
+            this.provider = InclinationFromAcc;
+            this.providerId = this.provider.addEventListener(
+                events => this.notify(events[0].clone()),
+                this.notifyError,
+                this.name
+            );
+        };
+
+        if (InclinationFromAttitude.availability) {
+            this.provider = InclinationFromAttitude;
+            this.providerId = this.provider.addEventListener(
+                events => this.notify(events[0].clone()),
+                () => {
+                    InclinationFromAttitude.removeEventListener(this.providerId);
+                    startInclinationFromAcc();
+                },
+                this.name);
+        } else {
+            startInclinationFromAcc();
+        }
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.provider.removeEventListener(this.providerId);
+    }
+}
+
+export default InclinationProvider;

package/src/providers/legacy/AbsolutePdrProvider.js

@@ -0,0 +1,258 @@
+/* eslint-disable max-statements */
+import isNumber from 'lodash.isnumber';
+
+import { UserPosition } from '@wemap/geo';
+import {
+    Itinerary, MapMatching
+} from '@wemap/graph';
+import {
+    deg2rad, Vector3
+} from '@wemap/maths';
+
+import Provider from '../Provider';
+import StepDetectionProvider from '../steps/StepDetectionProvider';
+import HeadingUnlocker from './helpers/HeadingUnlocker';
+import Availability from '../../events/Availability';
+import EventType from '../../events/EventType';
+import AbsoluteAttitudeProvider from '../attitude/absolute/AbsoluteAttitudeProvider';
+import PdrProvider from '../position/relative/PdrProvider';
+import ProviderEvent from '../../events/ProviderEvent';
+
+class AbsolutePdrProvider extends Provider {
+
+    position = null;
+
+    static MM_PDR_ANGLE = deg2rad(20);
+    static MM_PDR_DIST = 15;
+    static MM_CONV_SPEED = 0.7;
+
+    static LO_SEGMENT_SIZE = 1.5;
+
+    /**
+    * @override
+    */
+    constructor() {
+        super();
+
+        this.relativePosition = [0, 0, 0];
+
+        this.mapMatching = new MapMatching();
+        this.mapMatching.maxAngleBearing = this.constructor.MM_PDR_ANGLE;
+        this.mapMatching.maxDistance = this.constructor.MM_PDR_DIST;
+
+        this.stepDetectionLocker = new HeadingUnlocker();
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'Absolute PDR';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    static get _availability() {
+        return Availability.merge(
+            StepDetectionProvider.availability,
+            AbsoluteAttitudeProvider.availability
+        );
+    }
+
+
+    /**
+     * @override
+     */
+    _start() {
+
+        this.pdrProviderId = this.scheduler.use(PdrProvider,
+            events => this.onPdrEvent(events),
+            error => this.notifyError(error),
+            this.name);
+
+        /**
+         * Position
+         */
+        const lastPosition = this.dataStore.getLast(EventType.AbsolutePosition);
+        if (lastPosition) {
+            this.onPositionChanged(lastPosition);
+        }
+        this.dataStore.addEventListener(EventType.AbsolutePosition, this.onPositionChanged);
+
+        /**
+         * Network
+         */
+        this.mapMatching.network = this.dataStore.getLast(EventType.Network);
+        this.dataStore.addEventListener(EventType.Network, this.onNetworkChanged);
+
+        /**
+         * Itinerary
+         */
+        const lastItinerary = this.dataStore.getLast(EventType.Itinerary);
+        if (lastItinerary) {
+            this.onItineraryChanged(lastItinerary);
+        }
+        this.dataStore.addEventListener(EventType.Itinerary, this.onItineraryChanged);
+    }
+
+    /**
+     * @override
+     */
+    _stop() {
+        this.dataStore.removeEventListener(EventType.AbsolutePosition, this.onPositionChanged);
+        this.dataStore.removeEventListener(EventType.Network, this.onNetworkChanged);
+        this.dataStore.removeEventListener(EventType.Itinerary, this.onItineraryChanged);
+        this.scheduler.release(this.pdrProviderId, this.name);
+    }
+
+    onPositionChanged = position => {
+        this.position = position.clone();
+        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
+    };
+
+    onNetworkChanged = network => {
+        this.mapMatching.network = network;
+    }
+
+    /**
+     * @override
+     */
+    onPdrEvent = events => {
+
+        events.forEach(event => {
+            if (event.dataType === EventType.AbsoluteAttitude) {
+                this.attitude = event.data;
+                this.notify(event);
+            } else {
+                this.parseRelativePositionEvent(event);
+            }
+        });
+    }
+
+    parseRelativePositionEvent(event) {
+
+        if (this.position && this.attitude
+            && (!this.options.stepdetectionlocker
+                || !this.stepDetectionLocker.locked
+                || !this.stepDetectionLocker.feedHeading(this.attitude.heading))) {
+
+            this.position = this.calculateNewPosition(this.position, event);
+
+            this.notify(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
+
+        } else {
+            // this.pdrPosition has not been initialized
+            // or
+            // Step detection is locked by stepDetectionLocker
+        }
+
+        this.relativePosition = event.data.slice(0);
+    }
+
+    /**
+     * Calculate AbsolutePosition from RelativePosition event
+     * @param {UserPosition} previousPosition
+     * @param {ProviderEvent} event
+     */
+    calculateNewPosition(previousPosition, event) {
+
+        const offsetPosition = Vector3.subtract(event.data, this.relativePosition);
+
+        const dist = Math.sqrt(offsetPosition[0] ** 2 + offsetPosition[2] ** 2);
+        const bearing = Math.atan2(offsetPosition[0], -offsetPosition[2]);
+
+        /**
+         * First, compute new position without map-matching
+         */
+        const newPositionWithoutMM = previousPosition.clone();
+        newPositionWithoutMM.move(dist, bearing, offsetPosition[1]);
+        newPositionWithoutMM.bearing = bearing;
+        newPositionWithoutMM.time = event.timestamp;
+        if (isNumber(newPositionWithoutMM.accuracy) && isNumber(this.attitude.accuracy)) {
+            // A bad accuracy from PDR is due to three things:
+            //  - Attitude accuracy
+            //  - Misalignement (device heading != walking direction)
+            //  - Step detection false positives / false negatives
+            // Following formula only use attitude accuracy with cone formula
+            newPositionWithoutMM.accuracy += (dist / 2) * Math.sin(this.attitude.accuracy / 2);
+        }
+
+        if (!this.options.useMapMatching || !this.mapMatching.network) {
+            /**
+             * If mapMatching is not used or not set, raw position is returned
+             */
+            return newPositionWithoutMM;
+        }
+
+        /**
+         * Secondly, find map-matching projection
+         */
+        const projection = this.mapMatching.getProjection(newPositionWithoutMM, true, true);
+        if (!projection || !projection.projection) {
+            /**
+             * If no projection has been found, returns the position without map-matching
+             */
+            return newPositionWithoutMM;
+        }
+
+        const projectedPosition = newPositionWithoutMM;
+        projectedPosition.level = projection.projection.level;
+
+        if (projection.distanceFromNearestElement < dist) {
+            /**
+             * If projection is not so far from network, projected position is returned
+             */
+            projectedPosition.lat = projection.projection.lat;
+            projectedPosition.lng = projection.projection.lng;
+            return projectedPosition;
+        }
+
+        /**
+         * If projected position is far from network, we do not project calculated position directly.
+         * This allows to adapt map-matching to not stick corridor directly.
+         * /!\ This smoothed position is different from the one of Smoother
+         */
+        const smoothedPosition = projectedPosition;
+        smoothedPosition.lat = previousPosition.lat;
+        smoothedPosition.lng = previousPosition.lng;
+
+        const smoothedDistance = projection.distanceFromNearestElement * this.constructor.MM_CONV_SPEED;
+        const smoothedBearing = previousPosition.bearingTo(projection.projection);
+        smoothedPosition.move(smoothedDistance, smoothedBearing);
+
+        return smoothedPosition;
+    }
+
+
+    /**
+     * Itinerary and PDR Locker
+     */
+
+    /**
+     * @param {Itinerary} itinerary
+     */
+    onItineraryChanged = itinerary => {
+
+        if (!itinerary || itinerary.edges.length === 0) {
+            this.stepDetectionLocker.unlock();
+        }
+
+        const edgeAt = itinerary.getEdgeAt(this.constructor.LO_SEGMENT_SIZE);
+        if (edgeAt) {
+            this.stepDetectionLocker.lock(edgeAt.bearing);
+        } else {
+            this.stepDetectionLocker.lock(itinerary.edges[0].bearing);
+        }
+        return;
+    }
+}
+
+export default AbsolutePdrProvider;