@wemap/providers 9.0.9 → 9.1.0

package/index.js

@@ -35,6 +35,7 @@ export { default as Inclination } from './src/providers/inclination/Inclination.
 
 export { default as StepDetector } from './src/providers/steps/StepDetector.js';
 export { default as StraightLineDetector } from './src/providers/steps/StraightLineDetector.js';
+export { default as StepDetectionMinMaxPeaks2 } from './src/providers/steps/StepDetectionMinMaxPeaks2.js';
 
 export { default as Pdr } from './src/providers/position/relative/Pdr.js';
 export { default as GeoRelativePositionFromArCore } from './src/providers/position/relative/GeoRelativePositionFromArCore.js';

package/package.json

@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.0.9",
-  "gitHead": "e51acbb8a7ae92d16f9c149562912cf7b0f6cf10"
+  "version": "9.1.0",
+  "gitHead": "af24605a74542ee339618c979f24da61e194f6f0"
 }

package/src/mapmatching/MapMatchingHandler.js

@@ -35,28 +35,49 @@ class MapMatchingHandler extends Provider {
     static DEFAULT_USE_ITINERARY_START_AS_POSITION = false;
 
     /** @type {boolean} */
-    static ORIENTATION_MATCHING = true;
+    static DEFAULT_USE_ORIENTATION_MATCHING = true;
 
     /** @type {number} in meters */
-    static MM_HUGE_JUMP_DISTANCE = 3;
+    static DEFAULT_MM_HUGE_JUMP_DISTANCE = 3;
 
     /** @type {number} */
-    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
+    static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
     /** @type {number} */
-    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
+    static DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
 
     /** @type {number} */
-    static LAST_PROJECTIONS_WINDOW_SIZE = 3;
+    static DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE = 3;
 
     /** @type {number} */
-    static LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
+    static DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
 
     /** @type {MapMatching} */
     _mapMatching;
 
     /** @type {number} */
-    _mapMatchingMinDistance;
+    _mapMatchingMinDistance = MapMatchingHandler.DEFAULT_MM_MIN_DIST;
+
+    /** @type {boolean} */
+    _useItineraryStartAsPosition = MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION;
+
+    /** @type {boolean} */
+    _useOrientationMatching = MapMatchingHandler.DEFAULT_USE_ORIENTATION_MATCHING;
+
+    /** @type {number} */
+    _hugeJumpDistance = MapMatchingHandler.DEFAULT_MM_HUGE_JUMP_DISTANCE;
+
+    /** @type {number} */
+    _minStepsBetweenOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING;
+
+    /** @type {number} */
+    _minStepsForOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING;
+
+    /** @type {number} */
+    _lastProjectionsWindowSize = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE;
+
+    /** @type {number} */
+    _lastProjectionsEdgeAngleThreshold = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD;
 
     /** @type {boolean} */
     _internalProvidersStarted = false;
@@ -86,8 +107,6 @@ class MapMatchingHandler extends Provider {
         this._mapMatching = new MapMatching();
         this._mapMatching.maxDistance = MapMatchingHandler.DEFAULT_MM_MAX_DIST;
         this._mapMatching.maxAngleBearing = MapMatchingHandler.DEFAULT_MM_MAX_ANGLE;
-        this._mapMatchingMinDistance = MapMatchingHandler.DEFAULT_MM_MIN_DIST;
-        this._useItineraryStartAsPosition = MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION;
     }
 
     /**
@@ -279,7 +298,7 @@ class MapMatchingHandler extends Provider {
 
         // newPosition must not be used after this line
 
-        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
+        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > this._hugeJumpDistance;
 
         // In case of a huge jump, be sure the user is in a straight line
         if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
@@ -321,11 +340,11 @@ class MapMatchingHandler extends Provider {
         if (projection) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
             this._lastProjections.push(projection);
-            if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
+            if (this._lastProjections.length > this._lastProjectionsWindowSize) {
                 this._lastProjections.shift();
             }
 
-            const thisWillBeAHugeJump = projection.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
+            const thisWillBeAHugeJump = projection.distanceFromNearestElement > this._hugeJumpDistance;
 
             // In case of a huge jump, be sure the user is in a straight line
             if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
@@ -376,7 +395,7 @@ class MapMatchingHandler extends Provider {
                 }
 
                 this._lastProjections.push(projectionWithAbs);
-                if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
+                if (this._lastProjections.length > this._lastProjectionsWindowSize) {
                     this._lastProjections.shift();
                 }
 
@@ -441,7 +460,7 @@ class MapMatchingHandler extends Provider {
         return !this._lastProjections.some(projection =>
             !(projection.nearestElement instanceof GraphEdge)
             || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
-                > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
+                > this._lastProjectionsEdgeAngleThreshold)
         );
     }
 
@@ -450,13 +469,13 @@ class MapMatchingHandler extends Provider {
      */
     tryOrientationMatching(projection) {
 
-        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
+        if (!this._useOrientationMatching) {
             return;
         }
 
         if (this.state !== ProviderState.STARTED
-            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
-            || StraightLineDetector.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
+            || this._countStepsFromLastMatching < this._minStepsBetweenOrientationMatching
+            || StraightLineDetector.numStepsDetectedFromLastTurn < this._minStepsForOrientationMatching) {
             return;
         }
 
@@ -524,6 +543,62 @@ class MapMatchingHandler extends Provider {
     set useItineraryStartAsPosition(useItineraryStartAsPosition) {
         this._useItineraryStartAsPosition = useItineraryStartAsPosition;
     }
+
+    get useOrientationMatching() {
+        return this._useOrientationMatching;
+    }
+
+    set useOrientationMatching(useOrientationMatching) {
+        this._useOrientationMatching = useOrientationMatching;
+    }
+
+    get hugeJumpDistance() {
+        return this._hugeJumpDistance;
+    }
+
+    set hugeJumpDistance(hugeJumpDistance) {
+        this._hugeJumpDistance = hugeJumpDistance;
+    }
+
+    get useOrientationMatching() {
+        return this._useOrientationMatching;
+    }
+
+    set useOrientationMatching(useOrientationMatching) {
+        this._useOrientationMatching = useOrientationMatching;
+    }
+
+    get minStepsBetweenOrientationMatching() {
+        return this._minStepsBetweenOrientationMatching;
+    }
+
+    set minStepsBetweenOrientationMatching(minStepsBetweenOrientationMatching) {
+        this._minStepsBetweenOrientationMatching = minStepsBetweenOrientationMatching;
+    }
+
+    get minStepsForOrientationMatching() {
+        return this._minStepsForOrientationMatching;
+    }
+
+    set minStepsForOrientationMatching(minStepsForOrientationMatching) {
+        this._minStepsForOrientationMatching = minStepsForOrientationMatching;
+    }
+
+    get lastProjectionsWindowSize() {
+        return this._lastProjectionsWindowSize;
+    }
+
+    set lastProjectionsWindowSize(lastProjectionsWindowSize) {
+        this._lastProjectionsWindowSize = lastProjectionsWindowSize;
+    }
+
+    get lastProjectionsEdgeAngleThreshold() {
+        return this._lastProjectionsEdgeAngleThreshold;
+    }
+
+    set lastProjectionsEdgeAngleThreshold(lastProjectionsEdgeAngleThreshold) {
+        this._lastProjectionsEdgeAngleThreshold = lastProjectionsEdgeAngleThreshold;
+    }
 }
 
 export default new MapMatchingHandler();

package/src/providers/position/absolute/AbsolutePosition.js

@@ -1,4 +1,4 @@
-import { UserPosition, GeoRelativePosition } from '@wemap/geo';
+import { UserPosition, GeoRelativePosition, Level } from '@wemap/geo';
 import { PromiseUtils, TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -158,33 +158,69 @@ class AbsolutePosition extends Provider {
     }
 
     /**
-     * @param {ProviderEvent<UserPosition>} positionEvent
+     * @param {ProviderEvent<UserPosition>} newPositionEvent
      * @param {boolean} canContainLevel
-     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
+     * @returns {boolean}
      */
-    _onAbsolutePosition(positionEvent, canContainLevel = true) {
+    _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent, canContainLevel = true) {
 
-        const newPosition = positionEvent.data.clone();
+        const newPosition = newPositionEvent.data;
         const lastPosition = this.lastEvent ? this.lastEvent.data : null;
 
-        if (lastPosition && !this.useAllAbsolutePositions) {
+        // 1. Verifiy if it is the first known absolute position
+        if (!lastPosition) {
+            return true;
+        }
 
-            // Is the new position accuracy is better enough than the last position accuracy
-            const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+        // 2. Is the new position accuracy is better enough than the last position accuracy
+        const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+        if (isBetterEnough) {
+            return true;
+        }
 
-            // Is the new position is far from the new one (regarding accuracy)
-            // This is important if the person put the current page in the background during a while
-            const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
+        // 3.a. Is the new position is far from the new one (regarding accuracy)
+        // This condition return true if the two positions accuracy circles does not intersect.
+        // This is important if the person put the current page in the background during a while. But,
+        //  could be dangerous if two providers do not provide close positions (ping-pong effect). This
+        //  is why the 3.b. condition has been added.
+        // TODO: add a routine to augment the current position accuracy when the page is in background
+        const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
 
-            // Added on 16/06/22
-            // The goal of this condition is to avoid continuous jumps between positions from two providers
-            // (i.e. GnssWifi and PoleStar)
-            const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy <= lastPosition.accuracy;
+        // 3.b. Added on 16/06/22
+        // The goal of this condition is to avoid continuous jumps between positions from two providers
+        // (i.e. GnssWifi and PoleStar)
+        const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy <= lastPosition.accuracy;
 
-            if (!isBetterEnough && !isFarEnoughAndAccuracyIsBetter) {
-                return false;
-            }
+        if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
+            return true;
+        }
+
+        // 4. Added on 23/06/22
+        // The goal of this condition is to take into account levels change when map-matching is not enabled / set
+        const isChangingLevel = canContainLevel && !Level.equals(newPosition.level, lastPosition.level);
+        if (isChangingLevel) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param {ProviderEvent<UserPosition>} positionEvent
+     * @param {boolean} canContainLevel
+     * @returns {boolean} if input position is used by the system (true = used, false = discarded)
+     */
+    _onAbsolutePosition(positionEvent, canContainLevel = true) {
+
+        if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel)
+            && !this.useAllAbsolutePositions) {
+            return false;
+        }
+
+        const newPosition = positionEvent.data.clone();
+        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
 
+        if (lastPosition) {
             if (!canContainLevel) {
                 newPosition.level = lastPosition.level;
             }

package/src/providers/position/absolute/PoleStar.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-bitwise */
 
 import { UserPosition } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -97,7 +98,7 @@ class PoleStar extends Provider {
                     json.alt / 5,
                     timestamp,
                     json.accuracy,
-                    json.bearing,
+                    deg2rad(json.bearing),
                     this.pname);
 
                 this.notify(this.createEvent(

package/src/providers/steps/StepDetector.js

@@ -11,6 +11,11 @@ import StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2.js';
 
 class StepDetector extends Provider {
 
+    /** @type {number} */
+    static DEFAULT_STEP_SIZE_MULTIPLIER = 1;
+
+    _stepSizeMultiplier = StepDetector.DEFAULT_STEP_SIZE_MULTIPLIER;
+
     constructor() {
         super();
         this.stepDetector = new StepDetectionMinMaxPeaks2();
@@ -84,7 +89,7 @@ class StepDetector extends Provider {
         const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
 
         if (stepDetected) {
-            const size = this.stepDetector.lastStepSize;
+            const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
             this.numOfSteps++;
             this.notify(this.createEvent(
                 EventType.Step, {
@@ -102,6 +107,14 @@ class StepDetector extends Provider {
         linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
         return linearAcc;
     }
+
+    set stepSizeMultiplier(stepSizeMultiplier) {
+        this._stepSizeMultiplier = stepSizeMultiplier;
+    }
+
+    get stepSizeMultiplier() {
+        return this._stepSizeMultiplier;
+    }
 }
 
 export default new StepDetector();

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 = 2;
+    static DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
 
     /** @type {number?} */
     _turnDetectorProviderId = null;
@@ -17,6 +17,9 @@ class StraightLineDetector extends Provider {
     /** @type {number} */
     _countSteps = 0;
 
+    /** @type {number} */
+    _stepsConsideredForStraightLine = StraightLineDetector.DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
+
     /**
     * @override
     */
@@ -41,7 +44,7 @@ class StraightLineDetector extends Provider {
     }
 
     _onTurn = (event) => {
-        if (this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
+        if (this._countSteps >= this._stepsConsideredForStraightLine) {
 
             const fromEvents = [event];
             if (StepDetector.lastEvent !== null) {
@@ -57,7 +60,7 @@ class StraightLineDetector extends Provider {
     _onStep = (event) => {
         this._countSteps++;
 
-        if (this._countSteps === StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
+        if (this._countSteps === this._stepsConsideredForStraightLine) {
 
             const fromEvents = [event];
             if (TurnDectector.lastEvent !== null) {
@@ -79,6 +82,14 @@ class StraightLineDetector extends Provider {
     get numStepsDetectedFromLastTurn() {
         return this._countSteps;
     }
+
+    get stepsConsideredForStraightLine() {
+        return this._stepsConsideredForStraightLine;
+    }
+
+    set stepsConsideredForStraightLine(stepsConsideredForStraightLine) {
+        this._stepsConsideredForStraightLine = stepsConsideredForStraightLine;
+    }
 }
 
 export default new StraightLineDetector();

package/src/providers/vision/Vps.js

@@ -6,6 +6,7 @@ import { Quaternion, deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import EventType from '../../events/EventType.js';
+import Inclination from '../inclination/Inclination.js';
 import Provider from '../Provider.js';
 import ProviderState from '../ProviderState.js';
 import ImageRelocalization from './ImageRelocalization.js';
@@ -14,6 +15,10 @@ class Vps extends Provider {
 
     static MIN_TIME_BETWEEN_TWO_REQUESTS = 1000;
 
+    static DEFAULT_MIN_INCLINATION_FOR_REQUEST = deg2rad(60);
+
+    static DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST = 200;
+
     static CAMERA_TO_SMARTPHONE_ROT = Quaternion.fromAxisAngle([1, 0, 0], Math.PI);
 
     /** @type {boolean} */
@@ -28,6 +33,14 @@ class Vps extends Provider {
     /** @type {?string} */
     _endpoint = null;
 
+    /** @type {?number} */
+    _inclinationProviderId = null;
+
+    /** @type {number} */
+    _minInclinationForRequest = Vps.DEFAULT_MIN_INCLINATION_FOR_REQUEST;
+
+    /** @type {number} */
+    _waitTimeMinInclinationForRequest = Vps.DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST;
 
     /**
     * @override
@@ -67,6 +80,9 @@ class Vps extends Provider {
             }
             this._useCamera(SharedCameras.list[0].camera);
         }
+
+        // 3. Inclination
+        this._inclinationProviderId = Inclination.addEventListener();
     }
 
     /**
@@ -77,13 +93,8 @@ class Vps extends Provider {
         SharedCameras.off('removed', this._onCameraRemoved);
 
         this._camera = null;
-    }
 
-    /**
-     * @param {string} endpoint
-     */
-    setEndpoint(endpoint) {
-        this._endpoint = endpoint;
+        Inclination.removeEventListener(this._inclinationProviderId);
     }
 
     _onCameraDetected = ({ camera }) => {
@@ -142,6 +153,14 @@ class Vps extends Provider {
                 break;
             }
 
+            // 2.a. Do not send an image if smartphone looks at the floor
+            const inclination = Inclination.lastEvent ? Inclination.lastEvent.data : null;
+            if (inclination !== null
+                && inclination < this._minInclinationForRequest) {
+                await new Promise(resolve => setTimeout(resolve, this._waitTimeMinInclinationForRequest));
+                continue;
+            }
+
             // 3. Get current image from camera and relocalize it.
             const image = await this._camera.currentImage;
             const res = await ImageRelocalization.relocalize(this._endpoint, image);
@@ -163,9 +182,13 @@ class Vps extends Provider {
             );
             const attitude = new Attitude(deviceQuaternion, res.attitude.time, res.attitude.accuracy);
 
-            // Added on 16/06/22: to provide a consistant accuracy for the VPS
+            // [16/06/22] Force VPS accuracy to 5m if the information does not exist
+            // this allows to correctly fuse positions from different providers (VPS,
+            // GnssWifi, Pole Star...)
             const devicePosition = res.userPosition.clone();
-            devicePosition.accuracy = 10;
+            if (devicePosition.accuracy === null) {
+                devicePosition.accuracy = 5;
+            }
 
             // 5. Finally, notify the listeners if the VPS is not stopped
             if (this.state === ProviderState.STOPPED) {
@@ -183,6 +206,33 @@ class Vps extends Provider {
     _internalStop = () => {
         // do nothing
     }
+
+    get endpoint() {
+        return this._endpoint;
+    }
+
+    /**
+     * @param {string} endpoint
+     */
+    set endpoint(endpoint) {
+        this._endpoint = endpoint;
+    }
+
+    get minInclinationForRequest() {
+        return this._minInclinationForRequest;
+    }
+
+    set minInclinationForRequest(minInclinationForRequest) {
+        this._minInclinationForRequest = minInclinationForRequest;
+    }
+
+    get waitTimeMinInclinationForRequest() {
+        return this._waitTimeMinInclinationForRequest;
+    }
+
+    set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest) {
+        this._waitTimeMinInclinationForRequest = waitTimeMinInclinationForRequest;
+    }
 }
 
 export default new Vps();