@wemap/providers 4.0.3 → 4.0.5

package/debug/src/Utils.js

@@ -1,5 +1,6 @@
 import React from 'react'; // eslint-disable-line no-unused-vars
 
+import { ItineraryInfo } from '@wemap/geo';
 import { rad2deg } from '@wemap/maths';
 import { OsrmUtils } from '@wemap/osm';
 
@@ -121,6 +122,9 @@ class Utils {
 
     }
 
+    /**
+     * @param {ItineraryInfo} info
+     */
     static renderItineraryInfo(info) {
 
         if (!info) {

package/package.json

@@ -8,16 +8,16 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^4.0.3",
+    "@wemap/geo": "^4.0.4",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^4.0.0",
-    "@wemap/map": "^4.0.3",
+    "@wemap/map": "^4.0.4",
     "@wemap/maths": "^4.0.3",
     "@wemap/utils": "^4.0.0"
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
-    "@wemap/osm": "^4.0.3",
+    "@wemap/osm": "^4.0.4",
     "mapbox-gl": "^1.11.1"
   },
   "homepage": "https://github.com/wemap/wemap-modules-js#readme",
@@ -39,6 +39,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "4.0.3",
-  "gitHead": "91a82028ddda32038999582da381d1d0d8acd091"
+  "version": "4.0.5",
+  "gitHead": "83de234c6e6e93200995545e5d4d523f40850ecd"
 }

package/src/mapmatching/MapMatchingHandler.js

@@ -2,7 +2,7 @@
 import {
     AbsoluteHeading, Edge, Itinerary, MapMatching, Network, Projection, UserPosition
 } from '@wemap/geo';
-import { deg2rad, diffAngle } from '@wemap/maths';
+import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import EventType from '../events/EventType.js';
@@ -42,6 +42,15 @@ class MapMatchingHandler extends Provider {
     /** @type {number} */
     static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
+    /** @type {number} */
+    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
+
+    /** @type {number} */
+    static LAST_PROJECTIONS_WINDOW_SIZE = 3;
+
+    /** @type {number} */
+    static LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
+
     /** @type {MapMatching} */
     _mapMatching;
 
@@ -66,6 +75,10 @@ class MapMatchingHandler extends Provider {
     /** @type {number} */
     _countStepsFromLastMatching = 0;
 
+    /** @type {Projection[]} */
+    _lastProjections = [];
+
+
     constructor() {
         super();
 
@@ -262,6 +275,11 @@ class MapMatchingHandler extends Provider {
             return;
         }
 
+        // Detector to avoid big jumps in the wrong direction
+        if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
+            return;
+        }
+
         AbsolutePosition.notify(this.createEvent(
             EventType.AbsolutePosition,
             projectionWithBearing.projection,
@@ -280,6 +298,7 @@ class MapMatchingHandler extends Provider {
 
         if (TurnDectector.isTurning()) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+            this._lastProjections = [];
             AbsolutePosition.notify(positionEvent);
             return;
         }
@@ -289,6 +308,10 @@ class MapMatchingHandler extends Provider {
 
         if (projection) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+            this._lastProjections.push(projection);
+            if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
+                this._lastProjections.shift();
+            }
 
             const thisWillBeAHugeJump = projection.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
 
@@ -298,6 +321,18 @@ class MapMatchingHandler extends Provider {
                 return;
             }
 
+            // Detector to avoid big jumps in the wrong direction
+            if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
+                AbsolutePosition.notify(positionEvent);
+                return;
+            }
+
+            // Do not use projection if the neareast element is not the same direction than previous
+            if (!this._areLastProjectionsInTheSameDirection()) {
+                AbsolutePosition.notify(positionEvent);
+                return;
+            }
+
             AbsolutePosition.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 projection.projection,
@@ -321,6 +356,18 @@ class MapMatchingHandler extends Provider {
 
                     this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
                     if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
+                        AbsolutePosition.notify(positionEvent);
+                        return;
+                    }
+
+                    this._lastProjections.push(projectionWithAbs);
+                    if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
+                        this._lastProjections.shift();
+                    }
+
+
+                    if (!this._areLastProjectionsInTheSameDirection()) {
+                        AbsolutePosition.notify(positionEvent);
                         return;
                     }
 
@@ -336,6 +383,7 @@ class MapMatchingHandler extends Provider {
             }
 
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+            this._lastProjections = [];
 
             // If no projection found with both projection methods, simply use the newPosition.
             AbsolutePosition.notify(positionEvent);
@@ -343,6 +391,43 @@ class MapMatchingHandler extends Provider {
 
     }
 
+    /**
+     * @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;
+            }
+        }
+
+        return false;
+    }
+
+    _areLastProjectionsInTheSameDirection() {
+
+        if (this._lastProjections.length === 0) {
+            return false;
+        }
+
+        const firstProjection = this._lastProjections[0];
+        return !this._lastProjections.some(projection =>
+            !(projection.nearestElement instanceof Edge)
+            || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
+                > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
+        );
+    }
+
     /**
      * @param {Projection} projection
      */
@@ -353,7 +438,8 @@ class MapMatchingHandler extends Provider {
         }
 
         if (this.state !== ProviderState.STARTED
-            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING) {
+            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
+            || StraightLineDetector.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
             return;
         }
 

package/src/providers/attitude/TurnDectector.js

@@ -9,7 +9,7 @@ class TurnDetector extends Provider {
     // in seconds
     static SLIDING_WINDOW_TIME = 0.3;
 
-    static STD_THRESHOLD = 0.05;
+    static STD_THRESHOLD = 0.075;
 
     /** @type {number} in seconds */
     static CONSIDER_TURN_UNTIL = 1;

package/src/providers/attitude/absolute/AbsoluteAttitude.js

@@ -108,22 +108,43 @@ class AbsoluteAttitude extends Provider {
     /**
      * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
      */
-    _forceHeadingForRelative = (absoluteHeadingEvent, force = false) => {
+    _forceHeadingForRelative = (absoluteHeadingEvent) => {
 
-        if (!force && this.lastEvent
-            && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
+        if (this.lastEvent && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
             return;
         }
 
-        const currentRelativeHeading = this._relativeAttitude ? this._relativeAttitude.heading : 0;
 
-        this._relAbsQuat = Quaternion.fromAxisAngle(
-            [0, 0, 1],
-            currentRelativeHeading - absoluteHeadingEvent.data.heading
+        /**
+         * @param {Attitude} relativeAttitude
+         */
+        const calcForceHeading = (relativeAttitude) => {
+            const currentRelativeHeading = relativeAttitude.heading;
+
+            this._relAbsQuat = Quaternion.fromAxisAngle(
+                [0, 0, 1],
+                currentRelativeHeading - absoluteHeadingEvent.data.heading
+            );
+
+            this._relativeAccuracy = 0;
+            this._lastForcedHeadingEvent = absoluteHeadingEvent;
+        };
+
+        // If relativeAttitude does not exist yet, wait the next
+        if (this._relativeAttitude) {
+            calcForceHeading(this._relativeAttitude);
+            return;
+        }
+
+        // If this._relativeAttitude does not exist, wait the first value
+        // /!\ This works only if the relative attitude event is provided rapidly.
+        const providerId = RelativeAttitude.addEventListener(
+            events => {
+                calcForceHeading(events[0].data);
+                RelativeAttitude.removeEventListener(providerId);
+            }
         );
 
-        this._relativeAccuracy = 0;
-        this._lastForcedHeadingEvent = absoluteHeadingEvent;
     };
 
     /**
@@ -131,34 +152,41 @@ class AbsoluteAttitude extends Provider {
      */
     _onRelativeAttitudeEvent(event) {
 
-        if (!this._lastForcedHeadingEvent) {
-            return;
-        }
-
         const { quaternion, accuracy, time } = event.data;
 
         // Calculate relative accuracy
         if (this._relativeAttitude) {
             this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
         }
+
         // Keep the relative attitude event for the calculation of relAbsQuat
+        // /!\ Keep this even if forced heading is not set /!\
         this._relativeAttitude = event.data;
 
+
+        if (!this._lastForcedHeadingEvent) {
+            return;
+        }
+
         const accuracyWithRelative = Math.min(
             this._lastForcedHeadingEvent.data.accuracy + this._relativeAccuracy,
             Math.PI
         );
-        const accuracyWithAbsolute = this._eventFromBrowser.data.accuracy;
-
-        let newAccuracy;
-        let relAbsQuat;
-        if (accuracyWithAbsolute < accuracyWithRelative) {
-            const currentHeading = this._relativeAttitude ? this._relativeAttitude.heading : 0;
-            newAccuracy = accuracyWithAbsolute;
-            relAbsQuat = Quaternion.fromAxisAngle([0, 0, 1], currentHeading - this._eventFromBrowser.data.heading);
-        } else {
-            newAccuracy = accuracyWithRelative;
-            relAbsQuat = this._relAbsQuat;
+
+        let newAccuracy = accuracyWithRelative;
+        let relAbsQuat = this._relAbsQuat;
+
+        if (this._eventFromBrowser) {
+
+            const {
+                accuracy: accuracyWithAbsolute,
+                heading: headingFromAbsolute
+            } = this._eventFromBrowser.data;
+
+            if (accuracyWithAbsolute < accuracyWithRelative) {
+                newAccuracy = accuracyWithAbsolute;
+                relAbsQuat = Quaternion.fromAxisAngle([0, 0, 1], event.data.heading - headingFromAbsolute);
+            }
         }
 
         const absoluteQuat = Quaternion.multiply(relAbsQuat, quaternion);

package/src/providers/steps/StraightLineDetector.js

@@ -6,7 +6,7 @@ import EventType from '../../events/EventType.js';
 class StraightLineDetector extends Provider {
 
     /** @type {number} */
-    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 3;
+    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
 
     /** @type {number?} */
     _turnDetectorProviderId = null;
@@ -75,6 +75,10 @@ class StraightLineDetector extends Provider {
     isStraight() {
         return this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
     }
+
+    get numStepsDetectedFromLastTurn() {
+        return this._countSteps;
+    }
 }
 
 export default new StraightLineDetector();

package/src/smoothers/AttitudeSmoother.js

@@ -5,7 +5,7 @@ import { deg2rad, diffAngle, Quaternion } from '@wemap/maths';
 class AttitudeSmoother {
 
     /** @type {number} in radians/s */
-    static ROTATION_SPEED_JUMP_THRESHOLD = deg2rad(90);
+    static ROTATION_SPEED_JUMP_THRESHOLD = deg2rad(180);
 
     /** @type {number} in radians/s */
     static ROTATION_SPEED_CONVERGENCE = deg2rad(10);