@wemap/providers 4.0.4 → 4.0.5

package/package.json

@@ -39,6 +39,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "4.0.4",
-  "gitHead": "8cb2140ad039f1e12b9834effb7cef467ade7549"
+  "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';
@@ -45,6 +45,12 @@ class MapMatchingHandler extends Provider {
     /** @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;
 
@@ -69,6 +75,10 @@ class MapMatchingHandler extends Provider {
     /** @type {number} */
     _countStepsFromLastMatching = 0;
 
+    /** @type {Projection[]} */
+    _lastProjections = [];
+
+
     constructor() {
         super();
 
@@ -288,6 +298,7 @@ class MapMatchingHandler extends Provider {
 
         if (TurnDectector.isTurning()) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
+            this._lastProjections = [];
             AbsolutePosition.notify(positionEvent);
             return;
         }
@@ -297,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;
 
@@ -312,6 +327,12 @@ class MapMatchingHandler extends Provider {
                 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,
@@ -335,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;
                     }
 
@@ -350,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);
@@ -380,6 +414,19 @@ class MapMatchingHandler extends Provider {
         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

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);