@wemap/providers 4.0.1 → 4.0.4

package/src/mapmatching/MapMatchingHandler.js

@@ -1,30 +1,76 @@
+/* eslint-disable max-statements */
 import {
-    MapMatching, Network, UserPosition
+    AbsoluteHeading, Edge, Itinerary, MapMatching, Network, Projection, UserPosition
 } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
+import { deg2rad, diffAngle } from '@wemap/maths';
+import { TimeUtils } from '@wemap/utils';
 
-import AbsoluteAttitudeFused from '../providers/attitude/absolute/AbsoluteAttitudeFused.js';
+import EventType from '../events/EventType.js';
+import ProviderEvent from '../events/ProviderEvent.js';
+
+import AbsoluteAttitude from '../providers/attitude/absolute/AbsoluteAttitude.js';
+import AbsoluteAttitudeFromBrowser from '../providers/attitude/absolute/AbsoluteAttitudeFromBrowser.js';
+import TurnDectector from '../providers/attitude/TurnDectector.js';
+import Constants from '../providers/Constants.js';
 import AbsolutePosition from '../providers/position/absolute/AbsolutePosition.js';
+import Provider from '../providers/Provider.js';
+import ProviderState from '../providers/ProviderState.js';
+import StepDetector from '../providers/steps/StepDetector.js';
+import StraightLineDetector from '../providers/steps/StraightLineDetector.js';
 import ProvidersOptions from '../ProvidersOptions.js';
 
-class MapMatchingHandler {
+class MapMatchingHandler extends Provider {
+
+    /** @type {number} in radians */
+    static MM_MAX_ANGLE = deg2rad(30);
 
-    static MM_MAX_ANGLE = deg2rad(20);
+    /** @type {number} in meters */
     static MM_MAX_DIST = 30;
+
+    /** @type {number} in meters */
     static MM_MIN_DIST = 0;
 
+    /** @type {boolean} */
+    static ORIENTATION_MATCHING = true;
+
+    /** @type {boolean} */
+    static USE_ITINERARY_START_AS_POSITION = true;
+
+    /** @type {number} in meters */
+    static MM_HUGE_JUMP_DISTANCE = 3;
+
+    /** @type {number} */
+    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
+
+    /** @type {number} */
+    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
+
     /** @type {MapMatching} */
     _mapMatching;
 
     /** @type {number} */
     _mapMatchingMinDistance;
 
+    /** @type {boolean} */
+    _internalProvidersStarted = false;
 
-    constructor() {
+    /** @type {number?} */
+    _straightLineDetectorProviderId;
 
-        if (this.constructor._instance) {
-            throw new Error(`Cannot instantiate ${this.name} twice`);
-        }
+    /** @type {number?} */
+    _turnDetectorProviderId;
+
+    /** @type {number?} */
+    _stepDetectorProviderId;
+
+    /** @type {Projection[]} */
+    _projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+
+    /** @type {number} */
+    _countStepsFromLastMatching = 0;
+
+    constructor() {
+        super();
 
         this._mapMatching = new MapMatching();
         this._mapMatching.maxDistance = MapMatchingHandler.MM_MAX_DIST;
@@ -32,82 +78,353 @@ class MapMatchingHandler {
         this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
     }
 
+    /**
+     * @override
+     */
+    start() {
+        if (this.network) {
+            this._startInternalProviders();
+        }
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this._stopInternalProviders();
+    }
+
+    _manageStartStop = () => {
+        if (this.network && !this._internalProvidersStarted) {
+            this._startInternalProviders();
+        } else if (!this.network && this._internalProvidersStarted) {
+            this._stopInternalProviders();
+        }
+    }
+
+    _startInternalProviders() {
+
+        if (this.enabled && this._internalProvidersStarted) {
+            return;
+        }
+
+        this._straightLineDetectorProviderId = StraightLineDetector.addEventListener();
+        this._turnDetectorProviderId = TurnDectector.addEventListener();
+        this._stepDetectorProviderId = StepDetector.addEventListener(() => (this._countStepsFromLastMatching++));
+
+        this._internalProvidersStarted = true;
+    }
+
+    _stopInternalProviders() {
+
+        if (this.enabled && !this._internalProvidersStarted) {
+            return;
+        }
+
+        StraightLineDetector.removeEventListener(this._straightLineDetectorProviderId);
+        TurnDectector.removeEventListener(this._turnDetectorProviderId);
+        StepDetector.removeEventListener(this._stepDetectorProviderId);
+
+        this._internalProvidersStarted = false;
+    }
+
     get enabled() {
         return ProvidersOptions.useMapMatching;
     }
 
+    /** @type {Network} */
+    get network() {
+        return this._mapMatching.network;
+    }
+
+    /** @type {Network} */
+    set network(network) {
+
+        this._mapMatching.network = network;
+        this.notify(this.createEvent(EventType.Network, network));
+
+        this._manageStartStop();
+
+        if (this.canUseMapMatching()) {
+            this._notifyPositionFromNetworkInput(network);
+        }
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    canUseMapMatching() {
+        return this.enabled && this.network;
+    }
+
     /**
      * @param {Network} network
      */
-    set network(network) {
-        this._mapMatching.network = network;
+    _notifyPositionFromNetworkInput(network) {
+
+        const lastEvent = AbsolutePosition.lastEvent;
+        const lastPosition = lastEvent ? lastEvent.data : null;
+
+        const notify = (pos) => {
+            const newEvent = lastEvent
+                ? lastEvent.clone()
+                : new ProviderEvent(EventType.AbsolutePosition);
+            newEvent.data = pos;
+            AbsolutePosition.notify(newEvent);
+        };
 
-        if (!this.enabled) {
+        let newPosition;
+        if (MapMatchingHandler.USE_ITINERARY_START_AS_POSITION
+            && network instanceof Itinerary && network.start) {
+
+            // In case of an itinerary, use itinerary start as new position,
+            // but add the distance between lastPosition and itinerary start for the accuracy
+            newPosition = UserPosition.fromCoordinates(network.start);
+
+            if (lastPosition) {
+                newPosition.alt = lastPosition.alt;
+                newPosition.time = lastPosition.time;
+                newPosition.accuracy = lastPosition.accuracy + newPosition.distanceTo(lastPosition);
+                newPosition.bearing = lastPosition.bearing;
+            } else {
+                newPosition.alt = Constants.DEFAULT_ALTITUDE;
+                newPosition.time = TimeUtils.preciseTime();
+                newPosition.accuracy = 0;
+                newPosition.bearing = network.edges[0].bearing;
+            }
+
+            // if the distance between itinerary.start and itinerary.nodes[0] is less than MM_MAX_DIST,
+            //  projection.projection is itinerary.nodes[0]
+            const projection = this.getProjection(newPosition, true);
+            if (projection) {
+                notify(projection.projection);
+                // Do not notify for attitude projection because bearing has not been used.
+            } else {
+                // This means the first position is far from the network and the user has
+                //  to reach itinerary.nodes[0] before to continue
+                notify(newPosition);
+            }
             return;
         }
 
-        const lastEvent = AbsolutePosition.lastEvent;
-        if (network !== null && lastEvent) {
-            const projectedPosition = this.calcProjection(lastEvent.data, true);
-            if (projectedPosition) {
-                const newEvent = lastEvent.clone();
-                newEvent.data = projectedPosition;
-                AbsolutePosition.notify(newEvent);
+        if (!lastPosition) {
+            return;
+        }
+
+        newPosition = lastPosition.clone();
+        // TODO in function of the lastEvent, if it is from relative or absolute
+    }
+
+    /**
+     * @param {ProviderEvent<UserPosition>} newPositionEvent
+     */
+    notifyPositionFromFeed(newPositionEvent) {
+
+        const projection = this.getProjection(newPositionEvent.data, true, false);
+        if (!projection) {
+            AbsolutePosition.notify(newPositionEvent);
+            return;
+        }
+
+        AbsolutePosition.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            projection.projection,
+            [newPositionEvent]
+        ));
+    }
+
+
+    /**
+     * @param {ProviderEvent<UserPosition>} positionEvent
+     */
+    notifyPositionFromAbsolute(positionEvent) {
+
+        const newPosition = positionEvent.data;
+
+        let projectionWithBearing = null;
+        if (newPosition.bearing !== null) {
+            projectionWithBearing = this.getProjection(newPosition, true, true);
+        }
+
+        if (!projectionWithBearing) {
+            // Verify if the newPosition is far enough from the network to be used by the system.
+            const projectionWithoutBearing = this.getProjection(newPosition, true, false);
+            if (!projectionWithoutBearing) {
+                // In this case, the newPosition is far enough and can be used safely.
+                AbsolutePosition.notify(positionEvent);
             }
+            return;
+        }
+
+        // newPosition must not be used after this line
+
+        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
+
+        // In case of a huge jump, be sure the user is in a straight line
+        if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
+            return;
+        }
+
+        // Detector to avoid big jumps in the wrong direction
+        if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
+            return;
         }
+
+        AbsolutePosition.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            projectionWithBearing.projection,
+            [positionEvent]
+        ));
+
+        this.tryOrientationMatching(projectionWithBearing);
+
     }
 
+
     /**
-     * @param {UserPosition} position
-     * @param {boolean} shouldTryMmOnNodes
-     * @returns {UserPosition}
+     * @param {ProviderEvent<UserPosition>} positionEvent
      */
-    calcProjection(position, shouldTryMmOnNodes = false) {
+    notifyPositionFromRelative(positionEvent) {
+
+        if (TurnDectector.isTurning()) {
+            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+            AbsolutePosition.notify(positionEvent);
+            return;
+        }
+
+        const newPosition = positionEvent.data;
+        const projection = this.getProjection(newPosition, true, true);
+
+        if (projection) {
+            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
 
-        let projection = null;
-        let bearingUsedForProjection = false;
+            const thisWillBeAHugeJump = projection.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
 
-        if (!this.enabled || !this._mapMatching.network) {
-            return null;
+            // In case of a huge jump, be sure the user is in a straight line
+            if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
+                AbsolutePosition.notify(positionEvent);
+                return;
+            }
+
+            // Detector to avoid big jumps in the wrong direction
+            if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
+                AbsolutePosition.notify(positionEvent);
+                return;
+            }
+
+            AbsolutePosition.notify(this.createEvent(
+                EventType.AbsolutePosition,
+                projection.projection,
+                [positionEvent]
+            ));
+            this.tryOrientationMatching(projection);
+
+        } else {
+
+            // Sometimes, the newPosition.bearing diverges due to the Absolute Attitude offset
+            // and the Orientation Matching. So, we created this detector to check if projection
+            // with bearing from "AbsoluteAttitudeFromBrowser" is better than the current bearing.
+            // /!\ This works only if the user is waking in the same direction than the smartphone orientation /!\
+            if (StraightLineDetector.isStraight()) {
+
+                const testedPosition = newPosition.clone();
+                testedPosition.bearing = AbsoluteAttitudeFromBrowser.lastEvent.data.heading;
+                const projectionWithAbs = this.getProjection(testedPosition, true, true);
+
+                if (projectionWithAbs) {
+
+                    this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
+                    if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
+                        return;
+                    }
+
+                    AbsolutePosition.notify(this.createEvent(
+                        EventType.AbsolutePosition,
+                        projectionWithAbs.projection,
+                        [positionEvent]
+                    ));
+
+                    this.tryOrientationMatching(projectionWithAbs);
+                    return;
+                }
+            }
+
+            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+
+            // If no projection found with both projection methods, simply use the newPosition.
+            AbsolutePosition.notify(positionEvent);
         }
 
-        // Firstly, if new position bearing is known, try to use map-matching with bearing
-        // That is not always the case, for e.g. the first position returned by the GnssWifi provider.
-        if (position.bearing !== null) {
-            projection = this._mapMatching.getProjection(position, true, true);
-            bearingUsedForProjection = true;
+    }
+
+    /**
+     * @param {Projection} projection
+     */
+    _detectWrongBigJump(projection) {
+
+        if (this.network instanceof Itinerary && AbsolutePosition.lastEvent) {
+            const itinerary = this.network;
+            const infoPrevious = itinerary.getInfo(AbsolutePosition.lastEvent.data);
+            const infoProjection = itinerary.getInfo(projection.projection);
+            if (infoPrevious
+                && infoProjection
+                && infoPrevious.traveledDistance > infoProjection.traveledDistance
+                && (infoPrevious.traveledDistance - infoProjection.traveledDistance) > projection.origin.accuracy
+                && projection.distanceFromNearestElement > projection.origin.accuracy
+                && projection.origin.distanceTo(AbsolutePosition.lastEvent.data) < projection.origin.accuracy + AbsolutePosition.lastEvent.data.accuracy) {
+
+                return true;
+            }
         }
 
-        // Secondly, if map-matching with bearing did not work, try MM on nodes (without bearing).
-        // Note: this is not allowed for positions from AbsolutePositionFromRel to allow
-        //       user to leave the network.
-        if (!projection && shouldTryMmOnNodes) {
-            projection = this._mapMatching.getProjection(position, true, false);
-            bearingUsedForProjection = false;
+        return false;
+    }
+
+
+    /**
+     * @param {Projection} projection
+     */
+    tryOrientationMatching(projection) {
+
+        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
+            return;
         }
 
-        // No projection found
-        if (!projection) {
-            return null;
+        if (this.state !== ProviderState.STARTED
+            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
+            || StraightLineDetector.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
+            return;
         }
 
-        if (bearingUsedForProjection) {
-            AbsoluteAttitudeFused.mapMatching(projection);
+        const { nearestElement, origin } = projection;
+        if (!(nearestElement instanceof Edge)) {
+            return;
         }
 
-        // Do not use projection if it too close from itinerary,
-        //  this allows left/right movements (ie with ArCore)
-        if (projection.distanceFromNearestElement < this._mapMatchingMinDistance) {
-            return null;
+        let matchingDirection;
+        const matchingDirectionAngle1 = diffAngle(nearestElement.bearing, origin.bearing);
+        const matchingDirectionAngle2 = diffAngle(nearestElement.bearing + Math.PI, origin.bearing);
+
+        if (Math.abs(matchingDirectionAngle1) < Math.abs(matchingDirectionAngle2)) {
+            matchingDirection = nearestElement.bearing;
+        } else {
+            matchingDirection = (nearestElement.bearing + Math.PI) % (2 * Math.PI);
         }
 
-        // Do not use projection.projection directly, because position has some specific properties like time, bearing and altitude
-        const projectedPosition = position.clone();
-        projectedPosition.lat = projection.projection.lat;
-        projectedPosition.lng = projection.projection.lng;
-        projectedPosition.level = projection.projection.level;
+        const matchedHeading = new AbsoluteHeading(
+            matchingDirection,
+            origin.time,
+            0
+            // Math.min(Math.abs(matchingDirectionAngle1), Math.abs(matchingDirectionAngle2))
+        );
+
+        AbsoluteAttitude.feed(new ProviderEvent(EventType.AbsoluteHeading, matchedHeading));
+
+        this._countStepsFromLastMatching = 0;
+    }
 
-        return projectedPosition;
+    getProjection(position, useDistance, useBearing) {
+        return this._mapMatching.getProjection(position, useDistance, useBearing);
     }
 
     get maxDistance() {

package/src/providers/Provider.js

@@ -1,5 +1,3 @@
-import noop from 'lodash.noop';
-
 import EventType from '../events/EventType.js';
 import ProviderEvent from '../events/ProviderEvent.js';
 import ProvidersLoggerOld from '../events/ProvidersLoggerOld.js';
@@ -14,11 +12,22 @@ import ProviderState from './ProviderState.js';
  */
 class Provider {
 
+    /** @type {number} */
     static _callbackUniqueId = 0;
+
+    /** @type {number} */
     static _uniqueId = 1;
 
+
+    /** @type {number} */
+    id;
+
+    /** @type {number} */
     state = ProviderState.STOPPPED;
 
+    /** @type {ProviderEvent[]} */
+    _lastEvents = null;
+
     _eventsCallbacks = [];
     _monitoringCallbacks = [];
 
@@ -38,12 +47,13 @@ class Provider {
 
     /**
      * Get the provider name
-     * @returns {String} the provider name
+     * @type {String} the provider name
      */
     static get pname() {
         return 'Unknown';
     }
 
+    /** @type {String} */
     get pname() {
         return this.constructor.pname;
     }
@@ -59,7 +69,7 @@ class Provider {
     }
 
     /**
-     * @returns {Promise} returns an availability promise
+     * @type {Promise} returns an availability promise
      */
     get availability() {
         if (ProvidersOptions.ignoreProviders.includes(this.pname)) {
@@ -69,13 +79,14 @@ class Provider {
         return this._availability;
     }
 
+    /** @type {Promise} */
     get _availability() {
         return Promise.resolve();
     }
 
     /**
      * Create an event from current provider
-     * @param {ProviderEvent#DataType} dataType type of ProviderEvent
+     * @param {String} dataType type of ProviderEvent (from EventType)
      * @param {Object} data data exported to ProviderEvent
      * @returns {ProviderEvent}
      * @protected
@@ -119,7 +130,7 @@ class Provider {
      * @param {Boolean} startIfNecessary
      * @returns {Number}
      */
-    addEventListener(onEvents = noop, onError = noop, startIfNecessary = true) {
+    addEventListener(onEvents = () => {}, onError = () => {}, startIfNecessary = true) {
         const id = ++Provider._callbackUniqueId;
 
         /**
@@ -168,7 +179,7 @@ class Provider {
                 this.notifyError(e);
             })
             // notifyError can throw an error if onStop is not defined
-            .catch(() => noop);
+            .catch(() => {});
 
         return id;
     }
@@ -221,7 +232,7 @@ class Provider {
      * @param {Function} onStopped
      * @returns {Number}
      */
-    addMonitoringListener(onStarted = noop, onStopped = noop) {
+    addMonitoringListener(onStarted = () => {}, onStopped = () => {}) {
         const id = ++this.constructor._callbackUniqueId;
         this._monitoringCallbacks.push({
             id,
@@ -269,6 +280,9 @@ class Provider {
 
         // Notify callbacks
         this._eventsCallbacks.forEach(({ onEvents }) => onEvents(events));
+
+        // Keep a trace of the last events.
+        this._lastEvents = events;
     }
 
     /**
@@ -285,6 +299,26 @@ class Provider {
             onError(error);
         });
     }
+
+    /** @type {ProviderEvent} */
+    get lastEvent() {
+        return this._lastEvents ? this._lastEvents[0] : null;
+    }
+
+    /** @type {ProviderEvent[]} */
+    get lastEvents() {
+        return this._lastEvents;
+    }
+
+    /**
+     * Input data from external interface
+     * @param {ProviderEvent} event
+     * @param {EventType} eventType
+     */
+    // eslint-disable-next-line no-unused-vars
+    feed(event, eventType) {
+        throw new Error('Not implemented');
+    }
 }
 
 export default Provider;

package/src/providers/Provider.spec.js

@@ -1,7 +1,6 @@
 /* eslint-disable max-nested-callbacks */
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import noop from 'lodash.noop';
 
 import Logger from '@wemap/logger';
 
@@ -55,7 +54,7 @@ describe('Provider', () => {
          * checkAvailabilityOnStart = true
          */
         let errored = false;
-        FakeProvider2.addEventListener(noop, () => (errored = true));
+        FakeProvider2.addEventListener(() => {}, () => (errored = true));
 
         await sleep(2);
 
@@ -69,7 +68,7 @@ describe('Provider', () => {
         ProvidersOptions.checkAvailabilityOnStart = false;
 
         errored = false;
-        const id = FakeProvider2.addEventListener(noop, () => (errored = true));
+        const id = FakeProvider2.addEventListener(() => {}, () => (errored = true));
 
         await sleep(2);
 
@@ -112,7 +111,7 @@ describe('Provider', () => {
 
     it('start/stop', async () => {
         let errored = false;
-        FakeProvider1.addEventListener(noop, (errored = true));
+        FakeProvider1.addEventListener(() => {}, (errored = true));
         await sleep(2);
         expect(errored).is.true;