@wemap/providers 9.0.10 → 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.10",
-  "gitHead": "5801f314c614dacef96bf837dc713716d5f17a5a"
+  "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/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);
@@ -187,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();