@wemap/providers 3.1.2 → 3.1.4

package/src/providers/legacy/AbsolutePdrProvider.js

@@ -1,258 +0,0 @@
-/* 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;

package/src/providers/legacy/ArCoreAbsoluteProvider.js

@@ -1,230 +0,0 @@
-/* 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

@@ -1,217 +0,0 @@
-/* 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;