@wemap/providers 3.0.0

package/src/providers/legacy/ArCoreAbsoluteProvider.js

@@ -0,0 +1,230 @@
+/* eslint-disable max-statements */
+import {
+    Attitude, UserPosition
+} from '@wemap/geo';
+
+import {
+    Quaternion, Vector3
+} from '@wemap/maths';
+
+
+import Availability from '../../events/Availability';
+import EventType from '../../events/EventType';
+import ArCoreProvider from '../position/relative/ArCoreProvider';
+import ImuProvider from '../others/ImuProvider';
+import MapMatchingProvider from './MapMatchingProvider';
+import PdrProvider from './pdr/PdrProvider';
+
+const MM_ARCORE_DIST = 5;
+
+
+class ArCoreAbsoluteProvider extends MapMatchingProvider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.arCoreProvider = new ArCoreProvider(
+            e => this.onArCoreEvent(e),
+            onError,
+            options);
+
+        this.imuProvider = new ImuProvider(
+            this.onImuEvent,
+            onError,
+            Object.assign({}, options || {}, { require: [EventType.AngularRate] })
+        );
+
+        if (this.options.useMapMatching) {
+            this.enableMapMatching();
+        }
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'ArCore absolute provider';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * Return the list of required providers
+     */
+    static get _availability() {
+        return Availability.union(
+            ArCoreProvider.availability,
+            ImuProvider.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    _start() {
+        this.arCoreProvider.start();
+        this.imuProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    _stop() {
+        this.arCoreProvider.stop();
+        this.imuProvider.stop();
+    }
+
+    onArCoreEvent = events => {
+
+        const eventsForNotification = [];
+
+        events.forEach(event => {
+            if (event.dataType === EventType.RelativeAttitude) {
+
+                // const previousAttitude = this.relativeAttitude;
+                this.relativeAttitude = event.data;
+
+                /**
+                 * The two following blocks cannot be called in the same call because this.waitingForceHeading
+                 * if exists, is called before the first this.relativeAttitude assigment. So, this.waitingForceHeading
+                 * and previousAttitude should not be defined in the same time.
+                 */
+
+                if (typeof this.waitingForceHeading !== 'undefined') {
+                    /**
+                     * waitingForceHeading is set by setHeading() if this.relativeAttitude does not exist
+                     * At this moment, this.relativeAttitude is defined, so we can call setHeading again
+                     */
+                    this.setHeading(this.waitingForceHeading);
+                    delete this.waitingForceHeading;
+
+                }
+
+                // if (previousAttitude && this.absoluteAttitude) {
+                //     /**
+                //      * Sometimes ArCore has "orientation jumps" around z-axis.
+                //      * Here we try to detect and remove them.
+                //      */
+                //     const dist = Quaternion.distance(event.data.quaternion, previousAttitude.quaternion);
+                //     if (typeof this.angularRate !== 'undefined') {
+                //         const velocity = Vector3.norm(this.angularRate);
+                //         if (dist > deg2rad(10) && velocity < deg2rad(4)) {
+                //             this.setHeading(this.absoluteAttitude.heading);
+                //         }
+                //     }
+                // }
+
+                if (this.offsetQuat) {
+                    const absoluteQuaternion = Quaternion.multiply(this.offsetQuat, this.relativeAttitude.quaternion);
+                    this.absoluteAttitude = new Attitude(absoluteQuaternion);
+                    eventsForNotification.push(this.createEvent(EventType.AbsoluteAttitude, this.absoluteAttitude, event.timestamp));
+                }
+            }
+
+            if (event.dataType === EventType.RelativePosition) {
+
+                if (this.oldRelativePos && this.offsetAngle
+                    && !ArCoreAbsoluteProvider.positionEquals(this.oldRelativePos, event.data)) {
+
+                    const diffPos = Vector3.subtract(event.data, this.oldRelativePos);
+                    const dist = Math.sqrt(diffPos[0] ** 2 + diffPos[2] ** 2);
+                    const bearing = Math.atan2(diffPos[0], -diffPos[2]) - this.offsetAngle;
+                    this.position = this.position.destinationPoint(dist, bearing, diffPos[1]);
+
+                    if (this.absoluteAttitude) {
+                        this.position.bearing = this.absoluteAttitude.heading;
+                        this.updatePositionWithMapMatching();
+                    }
+
+                    eventsForNotification.push(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
+                }
+
+                this.oldRelativePos = event.data;
+            }
+
+            if (event.dataType === EventType.Barcode) {
+                eventsForNotification.push(event);
+            }
+
+            if (eventsForNotification.length !== 0) {
+                this.notify(...eventsForNotification);
+            }
+        });
+    }
+
+    static positionEquals(pos1, pos2) {
+        return pos1[0] === pos2[0] && pos1[1] === pos2[1] && pos1[2] === pos2[2];
+    }
+
+    onImuEvent = events => {
+        this.angularRate = events[0].data;
+    }
+
+    setHeading(heading) {
+
+        if (!this.relativeAttitude) {
+            this.waitingForceHeading = heading;
+            return;
+        }
+
+        this.offsetAngle = this.relativeAttitude.heading - heading;
+        this.offsetQuat = Quaternion.fromAxisAngle([0, 0, 1], this.offsetAngle);
+    }
+
+    setPosition(position) {
+        this.position = UserPosition.fromCoordinates(position);
+        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
+    }
+
+    /**
+     * @override
+     */
+    static get useCameraNatively() {
+        return true;
+    }
+
+
+    /**
+     * MapMatching
+     */
+
+    enableMapMatching(network, maxDistance, maxAngleBearing) {
+        super.enableMapMatching(
+            network,
+            maxDistance || MM_ARCORE_DIST,
+            maxAngleBearing || PdrProvider.MM_PDR_ANGLE
+        );
+    }
+
+    updatePositionWithMapMatching() {
+        if (!this.mapMatching) {
+            return;
+        }
+        const projection = this.mapMatching.getProjection(this.position, true, true);
+        if (projection) {
+            if (projection.distanceFromNearestElement > 1) {
+                this.position.lat = projection.projection.lat;
+                this.position.lng = projection.projection.lng;
+            }
+            this.position.level = projection.projection.level;
+        }
+    }
+
+    enableBarcodeScanner() {
+        this.arCoreProvider.enableBarcodeScanner();
+    }
+
+    disableBarcodeScanner() {
+        this.arCoreProvider.disableBarcodeScanner();
+    }
+}
+
+export default ArCoreAbsoluteProvider;

package/src/providers/legacy/GnssWifiPdrProvider.js

@@ -0,0 +1,217 @@
+/* eslint max-statements: ["error", 40]*/
+
+import { UserPosition } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+
+import MapMatchingProvider from './MapMatchingProvider';
+import PdrProvider from './pdr/PdrProvider';
+import GnssWifiProvider from '../position/GnssWifiProvider';
+import Availability from '../../events/Availability';
+import EventType from '../../events/EventType';
+import AbsoluteAttitudeProvider from '../attitude/absolute/AbsoluteAttitudeProvider';
+import Constants from '../Constants';
+
+const GPF_ACCURACY = 25;
+const GPF_DISTANCE = 25;
+
+const MM_GNSS_DIST = 20;
+const MM_GNSS_ANGLE = deg2rad(20);
+
+class GnssWifiPdrProvider extends MapMatchingProvider {
+
+    /**
+    * @override
+    */
+    constructor(onEvent, onError, options) {
+        super(onEvent, onError, options);
+
+        this.pdrProvider = new PdrProvider(e => this.onPdrEvent(e), onError, options);
+        this.gnssWifiProvider = new GnssWifiProvider(e => this.onGnssWifiEvent(e), onError, options);
+        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(
+            e => this.onAbsoluteAttitudeEvent(e),
+            onError,
+            options
+        );
+
+        this.gpsLastUpdate = 0;
+        this.isFirstGnssUpdate = true;
+        this.isFirstAttitudeUpdate = true;
+
+        if (this.options.useMapMatching) {
+            this.enableMapMatching();
+        }
+    }
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'GnssWifiPdr';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    static get _availability() {
+        return Availability.merge(
+            PdrProvider.availability,
+            GnssWifiProvider.availability,
+            AbsoluteAttitudeProvider.availability
+        );
+    }
+
+
+    /**
+     * @override
+     */
+    _start() {
+        this.pdrProvider.start();
+        this.gnssWifiProvider.start();
+        this.absoluteAttitudeProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.pdrProvider.stop();
+        this.gnssWifiProvider.stop();
+        this.absoluteAttitudeProvider.stop();
+    }
+
+    /**
+     * @private
+     */
+    onPdrEvent(pdrEvent) {
+        pdrEvent.forEach(event => {
+            if (event.dataType === EventType.AbsolutePosition) {
+                this.position = event.data;
+            } else if (event.dataType === EventType.AbsoluteAttitude) {
+                this.attitude = event.data;
+            }
+        });
+        this.notify(...pdrEvent);
+    }
+
+    /**
+     * @private
+     */
+    onGnssWifiEvent(events) {
+
+        const gnssWifiEvent = events[0];
+        const position = gnssWifiEvent.data;
+
+        // This should be called to update True North / Magnetic North declination
+        this.absoluteAttitudeProvider.setPosition(position);
+
+        if (position.accuracy > GPF_ACCURACY) {
+            return;
+        }
+
+        this.gnssPosition = position.clone();
+        this.gnssPosition.alt = Constants.DEFAULT_ALTITUDE;
+
+        if (!this.position || this.position
+            && this.position.distanceTo(this.gnssPosition) > GPF_DISTANCE) {
+
+            if (!this.mapMatching || !this.attitude) {
+                this.pdrProvider.setPosition(this.gnssPosition);
+            } else {
+
+                this.gnssPosition.bearing = this.attitude.heading;
+                const projection = this.mapMatching.getProjection(this.gnssPosition, true, true);
+
+                if (projection && projection.projection) {
+
+                    // Create a new position from projection and new GNSS position.
+                    this.gnssPosition.lat = projection.projection.lat;
+                    this.gnssPosition.lng = projection.projection.lng;
+
+                    // // 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.gnssPosition.bearing), edgeBearing);
+                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssPosition.bearing), edgeBearing + Math.PI);
+                    //     this.pdrProvider.setHeading(diff1 < diff2 ? edgeBearing : edgeBearing + Math.PI);
+                    // }
+
+                    if (this.lastAttitude) {
+                        this.pdrProvider.setHeading(this.lastAttitude.heading);
+                    }
+
+                }
+                this.pdrProvider.setPosition(this.gnssPosition);
+            }
+        }
+
+    }
+
+    onAbsoluteAttitudeEvent(events) {
+
+        const attitude = events[0].data;
+
+        if (this.isFirstAttitudeUpdate) {
+            this.pdrProvider.setHeading(attitude.heading);
+            this.isFirstAttitudeUpdate = false;
+        }
+
+        this.lastAttitude = attitude;
+    }
+
+    /**
+     * 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.gnssPosition
+                || itinerary.length < 2
+                || !itinerary.points[0].equalsTo(this.gnssPosition)) {
+                console.warn('Itinerary has not been calculated from GnssWifiPdrProvider and these is not recommanded');
+            }
+
+            const startEdge = itinerary.getEdgeAt(MM_GNSS_DIST);
+            if (!startEdge) {
+                return;
+            }
+            const startPoint = UserPosition.fromCoordinates(startEdge.node1.coords);
+            startPoint.alt = Constants.DEFAULT_ALTITUDE;
+            this.pdrProvider.setPosition(startPoint);
+            this.pdrProvider.setStepDetectionLockerOrientation(startEdge.bearing);
+        }
+
+    }
+
+}
+
+export default GnssWifiPdrProvider;

package/src/providers/legacy/MapMatchingProvider.js

@@ -0,0 +1,65 @@
+import Provider from '../Provider';
+import {
+    Itinerary, MapMatching, Network
+} from '@wemap/graph';
+
+class MapMatchingProvider extends Provider {
+
+    /**
+     * Enable mapmatching
+     * @param {*} network a network which will be used for map matching
+     * @param {*} maxDistance max distance between position and network to match. null disables maxDistance (default: null)
+     * @param {*} maxAngleBearing threshold to match a parallel segment for angle between position 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 network for mapmatching
+     * @param {Network} network a network instance
+     * @public
+     */
+    setNetwork(network) {
+        if (!this.mapMatching) {
+            throw new Error('MapMatching is not enabled');
+        }
+        this.mapMatching.network = network;
+    }
+
+    /**
+     * Is mapmatching activated?
+     * @returns is mapmatching activated
+     * @public
+     */
+    get hasMapMatching() {
+        return this.mapMatching !== null;
+    }
+
+
+    /**
+     * Itinerary
+     */
+
+    /**
+     * Update itinerary.
+     * 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;
+    }
+}
+
+export default MapMatchingProvider;