@wemap/providers 4.0.0 → 4.0.3

package/src/events/ProvidersLoggerOld.js

@@ -1,83 +1,84 @@
 import Logger from '@wemap/logger';
 
-let currentId = 0;
-const objectsIdMap = new WeakMap();
+class ProvidersLoggerOld {
 
-let pushEvents = {};
-let pushEventsRef = {};
+    _enabled = false;
 
-let interval;
-let initDate;
+    currentId = 0;
+    objectsIdMap = new WeakMap();
 
-class ProvidersLoggerOld {
+    pushEvents = {};
+    pushEventsRef = {};
+
+    interval;
+    initDate;
 
-    static _enabled = false;
 
-    static get enabled() {
+    get enabled() {
         return this._enabled;
     }
 
-    static set enabled(_newVal) {
+    set enabled(_newVal) {
         this._enabled = _newVal;
     }
 
-    static initializeInterval() {
+    initializeInterval() {
 
-        if (interval) {
+        if (this.interval) {
             return;
         }
 
-        interval = setInterval(() => {
+        this.interval = setInterval(() => {
 
-            for (const [key, value] of Object.entries(pushEvents)) {
-                Logger.debug('Received ' + value + ' notifications from ' + pushEventsRef[key].pname + ' last second');
+            for (const [key, value] of Object.entries(this.pushEvents)) {
+                Logger.debug('Received ' + value + ' notifications from ' + this.pushEventsRef[key].pname + ' last second');
             }
 
-            pushEvents = {};
-            pushEventsRef = {};
+            this.pushEvents = {};
+            this.pushEventsRef = {};
         }, 1000);
     }
 
-    static getObjectId(object) {
-        if (!objectsIdMap.has(object)) {
-            objectsIdMap.set(object, ++currentId);
+    getObjectId(object) {
+        if (!this.objectsIdMap.has(object)) {
+            this.objectsIdMap.set(object, ++this.currentId);
         }
-        return objectsIdMap.get(object);
+        return this.objectsIdMap.get(object);
     }
 
-    static addEvent(object, method) {
+    addEvent(object, method) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        if (!initDate) {
-            initDate = Date.now();
+        if (!this.initDate) {
+            this.initDate = Date.now();
         }
 
-        ProvidersLoggerOld.initializeInterval();
+        this.initializeInterval();
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
         const objectClassName = object.pname;
 
         Logger.debug(objectClassName + '[' + objectId + '].' + method);
     }
 
-    static incrementNotifications(object) {
+    incrementNotifications(object) {
 
-        if (!ProvidersLoggerOld.enabled) {
+        if (!this.enabled) {
             return;
         }
 
-        const objectId = ProvidersLoggerOld.getObjectId(object);
+        const objectId = this.getObjectId(object);
 
-        let counter = pushEvents[objectId];
+        let counter = this.pushEvents[objectId];
         if (!counter) {
             counter = 0;
-            pushEventsRef[objectId] = object;
+            this.pushEventsRef[objectId] = object;
         }
-        pushEvents[objectId] = counter + 1;
+        this.pushEvents[objectId] = counter + 1;
     }
 
 }
-export default ProvidersLoggerOld;
+export default new ProvidersLoggerOld();

package/src/mapmatching/MapMatchingHandler.js

@@ -1,19 +1,46 @@
-import { UserPosition } from '@wemap/geo';
+/* eslint-disable max-statements */
 import {
-    MapMatching, Network
+    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 {
-    AbsolutePosition, AbsoluteAttitudeFused
-} from '../Providers.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';
 
-const MM_MAX_ANGLE = deg2rad(20);
-const MM_MAX_DIST = 30;
-const MM_MIN_DIST = 0;
+class MapMatchingHandler extends Provider {
+
+    /** @type {number} in radians */
+    static MM_MAX_ANGLE = deg2rad(30);
+
+    /** @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;
 
-class MapMatchingHandler {
+    /** @type {number} */
+    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
     /** @type {MapMatching} */
     _mapMatching;
@@ -21,105 +48,344 @@ class MapMatchingHandler {
     /** @type {number} */
     _mapMatchingMinDistance;
 
+    /** @type {boolean} */
+    _internalProvidersStarted = false;
+
+    /** @type {number?} */
+    _straightLineDetectorProviderId;
+
+    /** @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;
+        this._mapMatching.maxAngleBearing = MapMatchingHandler.MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
+    }
+
     /**
-     * Singleton pattern using reflection.
-     * @returns {MapMatchingHandler}
+     * @override
      */
-    static get instance() {
-        if (!this._instance) {
-            this._instance = Reflect.construct(this, []);
+    start() {
+        if (this.network) {
+            this._startInternalProviders();
         }
-        return this._instance;
     }
 
-    constructor() {
+    /**
+     * @override
+     */
+    stop() {
+        this._stopInternalProviders();
+    }
 
-        if (this.constructor._instance) {
-            throw new Error(`Cannot instantiate ${this.name} twice`);
+    _manageStartStop = () => {
+        if (this.network && !this._internalProvidersStarted) {
+            this._startInternalProviders();
+        } else if (!this.network && this._internalProvidersStarted) {
+            this._stopInternalProviders();
         }
+    }
 
-        this._mapMatching = new MapMatching();
-        this._mapMatching.maxDistance = MM_MAX_DIST;
-        this._mapMatching.maxAngleBearing = MM_MAX_ANGLE;
-        this._mapMatchingMinDistance = MM_MIN_DIST;
+    _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;
     }
 
-    /**
-     * @param {Network} network
-     */
+    /** @type {Network} */
+    get network() {
+        return this._mapMatching.network;
+    }
+
+    /** @type {Network} */
     set network(network) {
+
         this._mapMatching.network = network;
+        this.notify(this.createEvent(EventType.Network, network));
 
-        if (!this.enabled) {
-            return;
+        this._manageStartStop();
+
+        if (this.canUseMapMatching()) {
+            this._notifyPositionFromNetworkInput(network);
         }
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    canUseMapMatching() {
+        return this.enabled && this.network;
+    }
+
+    /**
+     * @param {Network} network
+     */
+    _notifyPositionFromNetworkInput(network) {
 
         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);
+        const lastPosition = lastEvent ? lastEvent.data : null;
+
+        const notify = (pos) => {
+            const newEvent = lastEvent
+                ? lastEvent.clone()
+                : new ProviderEvent(EventType.AbsolutePosition);
+            newEvent.data = pos;
+            AbsolutePosition.notify(newEvent);
+        };
+
+        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;
         }
+
+        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 {UserPosition} position
-     * @param {boolean} shouldTryMmOnNodes
-     * @returns {UserPosition}
+     * @param {ProviderEvent<UserPosition>} positionEvent
      */
-    calcProjection(position, shouldTryMmOnNodes = false) {
+    notifyPositionFromAbsolute(positionEvent) {
 
-        let projection = null;
-        let bearingUsedForProjection = false;
+        const newPosition = positionEvent.data;
 
-        if (!this.enabled || !this._mapMatching.network) {
-            return null;
+        let projectionWithBearing = null;
+        if (newPosition.bearing !== null) {
+            projectionWithBearing = this.getProjection(newPosition, true, true);
         }
 
-        // 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;
+        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;
         }
 
-        // 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;
+        // 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;
         }
 
-        // No projection found
-        if (!projection) {
-            return null;
+        AbsolutePosition.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            projectionWithBearing.projection,
+            [positionEvent]
+        ));
+
+        this.tryOrientationMatching(projectionWithBearing);
+
+    }
+
+
+    /**
+     * @param {ProviderEvent<UserPosition>} positionEvent
+     */
+    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 = [];
+
+            const thisWillBeAHugeJump = projection.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()) {
+                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);
         }
 
-        // 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;
+    }
+
+    /**
+     * @param {Projection} projection
+     */
+    tryOrientationMatching(projection) {
+
+        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
+            return;
         }
 
-        if (bearingUsedForProjection) {
-            AbsoluteAttitudeFused.mapMatching(projection);
+        if (this.state !== ProviderState.STARTED
+            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING) {
+            return;
         }
 
-        // 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 { nearestElement, origin } = projection;
+        if (!(nearestElement instanceof Edge)) {
+            return;
+        }
+
+        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);
+        }
+
+        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() {
@@ -147,4 +413,4 @@ class MapMatchingHandler {
     }
 }
 
-export default MapMatchingHandler.instance;
+export default new MapMatchingHandler();

package/src/providers/FakeProvider.spec.js

@@ -3,13 +3,15 @@ import { UserPosition } from '@wemap/geo';
 import Provider from './Provider.js';
 import EventType from '../events/EventType.js';
 
-class FakeProvider1 extends Provider {
+class FakeProvider1Clazz extends Provider {
     static get pname() {
         return 'FakeProvider1';
     }
 }
+const FakeProvider1 = new FakeProvider1Clazz();
+export { FakeProvider1 };
 
-class FakeProvider2 extends Provider {
+class FakeProvider2Clazz extends Provider {
     static get pname() {
         return 'FakeProvider2';
     }
@@ -19,8 +21,10 @@ class FakeProvider2 extends Provider {
     start() { }
     stop() { }
 }
+const FakeProvider2 = new FakeProvider2Clazz();
+export { FakeProvider2 };
 
-class FakeProvider3 extends Provider {
+class FakeProvider3Clazz extends Provider {
     static get pname() {
         return 'FakeProvider3';
     }
@@ -34,31 +38,27 @@ class FakeProvider3 extends Provider {
         clearInterval(this.intervalId);
     }
 }
+const FakeProvider3 = new FakeProvider3Clazz();
+export { FakeProvider3 };
 
-class FakeProvider4 extends Provider {
+class FakeProvider4Clazz extends Provider {
 
     static get pname() {
         return 'FakeProvider4';
     }
 
-    constructor() {
-        super();
-        this.fp3 = FakeProvider3.instance;
-    }
     get _availability() {
-        return this.fp3.availability;
+        return FakeProvider3.availability;
     }
     start() {
-        this.fp3id = this.fp3.addEventListener(
+        this.fp3id = FakeProvider3.addEventListener(
             events => this.notify(events[0].clone()),
             this.notifyError.bind(this)
         );
     }
     stop() {
-        this.fp3.removeEventListener(this.fp3id);
+        FakeProvider3.removeEventListener(this.fp3id);
     }
 }
-
-export {
-    FakeProvider1, FakeProvider2, FakeProvider3, FakeProvider4
-};
+const FakeProvider4 = new FakeProvider4Clazz();
+export { FakeProvider4 };