@wemap/providers 9.1.1 → 10.0.0-alpha.0

package/index.d.ts

@@ -1,23 +1,82 @@
 import { Calibration } from "@wemap/camera";
-import { Coordinates } from "@wemap/geo";
+import {
+    Attitude, AttitudeJson,
+    UserPosition, UserPositionJson
+} from "@wemap/geo";
 import { Quaternion_t } from "@wemap/maths";
+import { UserAgentWithDetails } from "@wemap/utils";
 
 declare module '@wemap/providers' {
 
+    export type CoarsePoseJson = {
+        attitude?: AttitudeJson,
+        position?: UserPositionJson,
+    };
+
+    export type CoarsePose = {
+        attitude?: Attitude,
+        position?: UserPosition,
+    };
+
+    export type VpsMetadataJson = {
+        size: [number, number], // [width, height]
+        calibration?: Calibration,
+        time?: number,
+        coarse?: CoarsePoseJson,
+        userAgent?: UserAgentWithDetails
+    }
+
     export class VpsMetadata {
 
         size: { width: number, height: number };
         calibration?: Calibration;
         time?: number;
-        coarse: {
-            attitude?: Quaternion_t,
-            position: Coordinates,
-            positionAccuracy: number
-        }
-
-        toJson(): object;
-        static fromJson(json: object): VpsMetadata;
+        coarse?: CoarsePose;
+        userAgent?: UserAgentWithDetails;
+
+        toJson(): VpsMetadataJson;
+        static fromJson(json: VpsMetadataJson): VpsMetadata;
+    }
+
+    export type VpsRequestJson = VpsMetadataJson & {
+        image: string
+    }
+
+    export class VpsRequest {
+        image: string;
+        metadata: VpsMetadata;
+
+        toJson(): VpsRequestJson;
+        static fromJson(json: VpsRequestJson): VpsRequest
     }
 
+    export type VpsResponseJson = {
+        attitude: AttitudeJson,
+        coordinates: UserPositionJson
+    }
+
+    export class VpsResponse {
+        attitude: Attitude;
+        coordinates: UserPosition;
+
+        toJson(): VpsResponseJson;
+        static fromJson(json: VpsResponseJson): VpsResponse;
+    }
+
+    export class ImageRelocalization {
+
+        static _prepareRequest(
+            imageCanvas: HTMLCanvasElement,
+            calibration?: Calibration,
+            coarsePose?: CoarsePose
+        ): VpsRequest
+
+        static relocalize(
+            endpointUrl: string, imageCanvas: HTMLCanvasElement,
+            calibration?: Calibration, coarsePose?: CoarsePose
+        ): Promise<VpsResponse>;
+
+        static getHeadingFromQuaternion(quaternion: Quaternion_t): number;
+    }
 }
 

package/index.js

@@ -9,7 +9,9 @@ export { default as MapMatchingHandler } from './src/mapmatching/MapMatchingHand
 export { default as PositionSmoother } from './src/smoothers/PositionSmoother.js';
 export { default as AttitudeSmoother } from './src/smoothers/AttitudeSmoother.js';
 
-export { default as VpsMetadata } from './src/providers/vision/VpsMetadata.js';
+export { default as VpsMetadata } from './src/providers/vision/vps/VpsMetadata.js';
+export { default as VpsRequest } from './src/providers/vision/vps/VpsRequest.js';
+export { default as VpsResponse } from './src/providers/vision/vps/VpsResponse.js';
 
 export { default as ProvidersLoggerOld } from './src/events/ProvidersLoggerOld.js';
 
@@ -35,7 +37,6 @@ 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';
@@ -47,8 +48,8 @@ export { default as Ip } from './src/providers/position/absolute/Ip.js';
 export { default as AbsolutePosition } from './src/providers/position/absolute/AbsolutePosition.js';
 
 export { default as ArCore } from './src/providers/vision/ArCore.js';
-export { default as ImageRelocalization } from './src/providers/vision/ImageRelocalization.js';
-export { default as Vps } from './src/providers/vision/Vps.js';
+export { default as ImageRelocalization } from './src/providers/vision/vps/ImageRelocalization.js';
+export { default as Vps } from './src/providers/vision/vps/Vps.js';
 export { default as Barcode } from './src/providers/vision/Barcode.js';
 
 export { default as CameraNative } from './src/providers/others/CameraNative.js';

package/package.json

@@ -8,15 +8,15 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/camera": "^9.0.8",
-    "@wemap/geo": "^9.1.1",
+    "@wemap/camera": "^10.0.0-alpha.0",
+    "@wemap/geo": "^10.0.0-alpha.0",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^9.0.0",
-    "@wemap/map": "^9.1.1",
+    "@wemap/map": "^10.0.0-alpha.0",
     "@wemap/maths": "^9.0.0",
-    "@wemap/osm": "^9.1.1",
-    "@wemap/routers": "^9.1.1",
-    "@wemap/utils": "^9.0.0"
+    "@wemap/osm": "^10.0.0-alpha.0",
+    "@wemap/routers": "^10.0.0-alpha.0",
+    "@wemap/utils": "^10.0.0-alpha.0"
   },
   "description": "A package using different geoloc systems",
   "devDependencies": {
@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.1.1",
-  "gitHead": "bf6a54cf4f886ebac773549339ada8f98c0b7f7f"
+  "version": "10.0.0-alpha.0",
+  "gitHead": "d98a62dea33f5bcd93bc0eda133242da9fe441e3"
 }

package/src/mapmatching/MapMatchingHandler.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-statements */
 import {
-    AbsoluteHeading, GraphEdge, Level, MapMatching, Network, GraphProjection, UserPosition
+    AbsoluteHeading, GraphEdge, MapMatching, Network, GraphProjection, UserPosition
 } from '@wemap/geo';
 import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
 import { Itinerary } from '@wemap/routers';
@@ -35,55 +35,28 @@ class MapMatchingHandler extends Provider {
     static DEFAULT_USE_ITINERARY_START_AS_POSITION = false;
 
     /** @type {boolean} */
-    static DEFAULT_USE_ORIENTATION_MATCHING = true;
+    static ORIENTATION_MATCHING = true;
 
     /** @type {number} in meters */
-    static DEFAULT_MM_HUGE_JUMP_DISTANCE = 3;
-
-    /** @type {number} in meters */
-    static DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE = 2;
+    static MM_HUGE_JUMP_DISTANCE = 3;
 
     /** @type {number} */
-    static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
+    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
     /** @type {number} */
-    static DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
+    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
 
     /** @type {number} */
-    static DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE = 3;
+    static LAST_PROJECTIONS_WINDOW_SIZE = 3;
 
     /** @type {number} */
-    static DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
+    static LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
 
     /** @type {MapMatching} */
     _mapMatching;
 
     /** @type {number} */
-    _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} */
-    _disableMMCloseToATurnDistance = MapMatchingHandler.DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_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;
+    _mapMatchingMinDistance;
 
     /** @type {boolean} */
     _internalProvidersStarted = false;
@@ -113,6 +86,8 @@ 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;
     }
 
     /**
@@ -304,7 +279,7 @@ class MapMatchingHandler extends Provider {
 
         // newPosition must not be used after this line
 
-        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > this._hugeJumpDistance;
+        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()) {
@@ -346,11 +321,11 @@ class MapMatchingHandler extends Provider {
         if (projection) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
             this._lastProjections.push(projection);
-            if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+            if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
                 this._lastProjections.shift();
             }
 
-            const thisWillBeAHugeJump = projection.distanceFromNearestElement > this._hugeJumpDistance;
+            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()) {
@@ -370,13 +345,6 @@ class MapMatchingHandler extends Provider {
                 return true;
             }
 
-            // Detector to avoid map-matching close to network turns
-            if (this._disableMMCloseToATurnDistance > 0
-                && this._hasTurnInCircle(projection.projection, this._disableMMCloseToATurnDistance)) {
-                AbsolutePosition.notify(positionEvent);
-                return true;
-            }
-
             AbsolutePosition.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 projection.projection,
@@ -408,7 +376,7 @@ class MapMatchingHandler extends Provider {
                 }
 
                 this._lastProjections.push(projectionWithAbs);
-                if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+                if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
                     this._lastProjections.shift();
                 }
 
@@ -473,57 +441,22 @@ class MapMatchingHandler extends Provider {
         return !this._lastProjections.some(projection =>
             !(projection.nearestElement instanceof GraphEdge)
             || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
-                > this._lastProjectionsEdgeAngleThreshold)
+                > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
         );
     }
 
-    /**
-     * @param {GraphNode} node
-     * @returns {boolean}
-     */
-    _nodeHasTurn(node) {
-        const { edges } = node;
-        for (let i = 0; i < edges.length; i++) {
-            for (let j = i + 1; j < edges.length; j++) {
-                const angle = diffAngleLines(edges[i].bearing, edges[j].bearing);
-                if (angle > MapMatchingHandler.DEFAULT_MM_MAX_ANGLE) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @param {Coordinates} center
-     * @param {number} radius
-     * @returns {boolean}
-     */
-    _hasTurnInCircle(center, radius) {
-        /** @type {Network} */
-        const network = this._mapMatching.network;
-        if (!network) {
-            return false;
-        }
-
-        return network.nodes.filter(node =>
-            node.coords.distanceTo(center) <= radius
-            && Level.intersect(node.coords.level, center.level)
-        ).some(this._nodeHasTurn);
-    }
-
     /**
      * @param {Projection} projection
      */
     tryOrientationMatching(projection) {
 
-        if (!this._useOrientationMatching) {
+        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
             return;
         }
 
         if (this.state !== ProviderState.STARTED
-            || this._countStepsFromLastMatching < this._minStepsBetweenOrientationMatching
-            || StraightLineDetector.numStepsDetectedFromLastTurn < this._minStepsForOrientationMatching) {
+            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
+            || StraightLineDetector.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
             return;
         }
 
@@ -591,70 +524,6 @@ 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 disableMMCloseToATurnDistance() {
-        return this._disableMMCloseToATurnDistance;
-    }
-
-    set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance) {
-        this._disableMMCloseToATurnDistance = disableMMCloseToATurnDistance;
-    }
-
-    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, Level } from '@wemap/geo';
+import { UserPosition, GeoRelativePosition } from '@wemap/geo';
 import { PromiseUtils, TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -9,7 +9,7 @@ import GnssWifi from './GnssWifi.js';
 import { default as GeoRelativePositionProvider } from '../relative/GeoRelativePosition.js';
 import ProvidersOptions from '../../../ProvidersOptions.js';
 import ProviderState from '../../ProviderState.js';
-import Vps from '../../vision/Vps.js';
+import Vps from '../../vision/vps/Vps.js';
 import PoleStar from './PoleStar.js';
 
 class AbsolutePosition extends Provider {
@@ -20,9 +20,6 @@ class AbsolutePosition extends Provider {
     /** @type {boolean} */
     static USE_MM_FOR_FEED = true;
 
-    /** @type {boolean} */
-    useAllAbsolutePositions = false;
-
     /** @type {number?} */
     _gnssWifiProviderId;
 
@@ -53,18 +50,10 @@ class AbsolutePosition extends Provider {
      * @override
      */
     get _availability() {
-
-        const providersToCheck = [
+        return PromiseUtils.any([
             GeoRelativePositionProvider.availability,
             GnssWifi.availability
-        ];
-        if (ProvidersOptions.hasPoleStar) {
-            providersToCheck.push(PoleStar.availability);
-        }
-        if (ProvidersOptions.hasVps) {
-            providersToCheck.push(Vps.availability);
-        }
-        return PromiseUtils.any(providersToCheck);
+        ]);
     }
 
 
@@ -157,54 +146,6 @@ class AbsolutePosition extends Provider {
         MapMatchingHandler.removeEventListener(this._mapMatchingHandlerId);
     }
 
-    /**
-     * @param {ProviderEvent<UserPosition>} newPositionEvent
-     * @param {boolean} canContainLevel
-     * @returns {boolean}
-     */
-    _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent, canContainLevel = true) {
-
-        const newPosition = newPositionEvent.data;
-        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
-
-        // 1. Verifiy if it is the first known absolute position
-        if (!lastPosition) {
-            return true;
-        }
-
-        // 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;
-        }
-
-        // 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;
-
-        // 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 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
@@ -212,15 +153,22 @@ class AbsolutePosition extends Provider {
      */
     _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) {
+
+            // Is the new position accuracy is better enough than the last position accuracy
+            const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+
+            // 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;
+
+            if (!isBetterEnough && !isFarEnough) {
+                return false;
+            }
+
             if (!canContainLevel) {
                 newPosition.level = lastPosition.level;
             }

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

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

package/src/providers/steps/StepDetector.js

@@ -11,11 +11,6 @@ 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();
@@ -89,7 +84,7 @@ class StepDetector extends Provider {
         const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
 
         if (stepDetected) {
-            const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
+            const size = this.stepDetector.lastStepSize;
             this.numOfSteps++;
             this.notify(this.createEvent(
                 EventType.Step, {
@@ -107,14 +102,6 @@ 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 DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
+    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
 
     /** @type {number?} */
     _turnDetectorProviderId = null;
@@ -17,9 +17,6 @@ class StraightLineDetector extends Provider {
     /** @type {number} */
     _countSteps = 0;
 
-    /** @type {number} */
-    _stepsConsideredForStraightLine = StraightLineDetector.DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
-
     /**
     * @override
     */
@@ -44,7 +41,7 @@ class StraightLineDetector extends Provider {
     }
 
     _onTurn = (event) => {
-        if (this._countSteps >= this._stepsConsideredForStraightLine) {
+        if (this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
 
             const fromEvents = [event];
             if (StepDetector.lastEvent !== null) {
@@ -60,7 +57,7 @@ class StraightLineDetector extends Provider {
     _onStep = (event) => {
         this._countSteps++;
 
-        if (this._countSteps === this._stepsConsideredForStraightLine) {
+        if (this._countSteps === StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
 
             const fromEvents = [event];
             if (TurnDectector.lastEvent !== null) {
@@ -82,14 +79,6 @@ 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/{ImageRelocalization.js → vps/ImageRelocalization.js}

@@ -1,9 +1,12 @@
+import UAParser from 'ua-parser-js';
+
 import { CameraUtils } from '@wemap/camera';
 import { Attitude, Coordinates, UserPosition } from '@wemap/geo';
 import Logger from '@wemap/logger';
 import { TimeUtils } from '@wemap/utils';
 
-import VpsMetadata from './VpsMetadata.js';
+import VpsRequest from './VpsRequest.js';
+import VpsResponse from './VpsResponse.js';
 
 class ImageRelocalization {
 
@@ -11,49 +14,24 @@ class ImageRelocalization {
      * @param {HTMLCanvasElement} imageCanvas
      * @param {{intrinsic:number[], distortions:number[]}} calibration
      * @param {{position: Coordinates, positionAccuracy: number}} coarsePose
-     * @returns {object}
+     * @returns {VpsRequest}
      */
     static _prepareRequest(imageCanvas, calibration, coarsePose) {
-        const requestTime = TimeUtils.preciseTime() / 1e3;
+        const request = new VpsRequest();
+        const { metadata } = request;
+
+        metadata.time = TimeUtils.preciseTime() / 1e3;
 
         CameraUtils.convertToGrayscale(imageCanvas);
         const reducedImage = CameraUtils.reduceImageSize(imageCanvas, 1280);
-        const base64Image = CameraUtils.canvasToBase64(reducedImage);
+        request.image = reducedImage;
 
-        const metadata = new VpsMetadata();
-        metadata.time = requestTime;
         metadata.size = { width: reducedImage.width, height: reducedImage.height };
         metadata.calibration = calibration;
         metadata.coarse = coarsePose;
+        metadata.userAgent = (new UAParser()).getResult();
 
-        return {
-            image: base64Image,
-            ...metadata.toJson()
-        };
-    }
-
-    /**
-     * @param {object} json
-     * @returns {{userPosition: UserPosition, attitude: Attitude}}
-     */
-    static _parseJsonResponse(json, requestTime = null) {
-
-        const attitude = new Attitude([
-            json.attitude.w, json.attitude.x,
-            json.attitude.y, json.attitude.z
-        ], requestTime, 0);
-
-        const userPosition = new UserPosition(
-            json.coordinates.lat,
-            json.coordinates.lng,
-            json.coordinates.alt,
-            typeof json.coordinates.level === 'undefined' ? null : json.coordinates.level,
-            requestTime,
-            0,
-            attitude.heading
-        );
-
-        return { userPosition, attitude };
+        return request;
     }
 
     /**
@@ -66,14 +44,14 @@ class ImageRelocalization {
     static async relocalize(endpointUrl, imageCanvas, calibration = null, coarsePose = null) {
 
         // 1. Prepare the request
-        const jsonPayload = this._prepareRequest(imageCanvas, calibration, coarsePose);
+        const vpsRequest = this._prepareRequest(imageCanvas, calibration, coarsePose);
 
         // 2. Send the request
         let serverResponse;
         try {
             serverResponse = await fetch(endpointUrl, {
                 method: 'POST',
-                body: JSON.stringify(jsonPayload),
+                body: JSON.stringify(vpsRequest.toJson()),
                 headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }
             });
         } catch (e) {
@@ -91,9 +69,7 @@ class ImageRelocalization {
         }
 
         // 3. Parse the response
-        const { userPosition, attitude } = this._parseJsonResponse(json, jsonPayload.time);
-
-        return { userPosition, attitude };
+        return VpsResponse.fromJson(json);
     }
 
     static getHeadingFromQuaternion(quaternion) {

package/src/providers/vision/{Vps.js → vps/Vps.js}

@@ -5,20 +5,15 @@ import Logger from '@wemap/logger';
 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 EventType from '../../../events/EventType.js';
+import Provider from '../../Provider.js';
+import ProviderState from '../../ProviderState.js';
 import ImageRelocalization from './ImageRelocalization.js';
 
 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} */
@@ -33,14 +28,6 @@ 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
@@ -80,9 +67,6 @@ class Vps extends Provider {
             }
             this._useCamera(SharedCameras.list[0].camera);
         }
-
-        // 3. Inclination
-        this._inclinationProviderId = Inclination.addEventListener();
     }
 
     /**
@@ -93,8 +77,13 @@ class Vps extends Provider {
         SharedCameras.off('removed', this._onCameraRemoved);
 
         this._camera = null;
+    }
 
-        Inclination.removeEventListener(this._inclinationProviderId);
+    /**
+     * @param {string} endpoint
+     */
+    setEndpoint(endpoint) {
+        this._endpoint = endpoint;
     }
 
     _onCameraDetected = ({ camera }) => {
@@ -153,14 +142,6 @@ 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);
@@ -182,14 +163,6 @@ class Vps extends Provider {
             );
             const attitude = new Attitude(deviceQuaternion, res.attitude.time, res.attitude.accuracy);
 
-            // [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();
-            if (devicePosition.accuracy === null) {
-                devicePosition.accuracy = 5;
-            }
-
             // 5. Finally, notify the listeners if the VPS is not stopped
             if (this.state === ProviderState.STOPPED) {
                 break;
@@ -197,7 +170,7 @@ class Vps extends Provider {
 
             this.notify(
                 this.createEvent(EventType.AbsoluteAttitude, attitude),
-                this.createEvent(EventType.AbsolutePosition, devicePosition)
+                this.createEvent(EventType.AbsolutePosition, res.userPosition)
             );
 
         }
@@ -206,33 +179,6 @@ 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();

package/src/providers/vision/{VpsMetadata.js → vps/VpsMetadata.js}

@@ -1,4 +1,4 @@
-import { Coordinates } from '@wemap/geo';
+import { Attitude, UserPosition } from '@wemap/geo';
 
 class VpsMetadata {
 
@@ -11,11 +11,14 @@ class VpsMetadata {
     /** @type {?number} */
     time;
 
-    /** @type {?{position: Coordinates, positionAccuracy: number, ?attitude: [number, number, number, number]}} */
+    /** @type {?{position?: UserPosition, attitude?: Attitude}} */
     coarse;
 
+    /** @type {object} */
+    userAgent;
+
     /**
-     * @returns {object}
+     * @returns {VpsMetadata}
      */
     toJson() {
         const output = { size: [this.size.width, this.size.height] };
@@ -27,18 +30,16 @@ class VpsMetadata {
         }
         if (this.coarse) {
             output.coarse = {};
-
             if (this.coarse.attitude) {
-                output.coarse.attitude = this.coarse.attitude;
+                output.coarse.attitude = this.coarse.attitude.toJson();
             }
 
             if (this.coarse.position) {
                 output.coarse.position = this.coarse.position.toJson();
             }
-
-            if (this.coarse.positionAccuracy) {
-                output.coarse.positionAccuracy = this.coarse.positionAccuracy;
-            }
+        }
+        if (typeof this.userAgent === 'object') {
+            output.userAgent = this.userAgent;
         }
 
         return output;
@@ -46,7 +47,7 @@ class VpsMetadata {
 
     /**
      * @param {object} json
-     * @returns {Coordinates}
+     * @returns {VpsMetadata}
      */
     static fromJson(json) {
         const output = new VpsMetadata();
@@ -62,18 +63,16 @@ class VpsMetadata {
         }
         if (json.coarse) {
             output.coarse = {};
-
             if (json.coarse.attitude) {
-                output.coarse.attitude = json.coarse.attitude;
+                output.coarse.attitude = Attitude.fromJson(json.coarse.attitude);
             }
-
             if (json.coarse.position) {
-                output.coarse.position = Coordinates.fromJson(json.coarse.position);
-            }
-            if (json.coarse.positionAccuracy) {
-                output.coarse.positionAccuracy = json.coarse.positionAccuracy;
+                output.coarse.position = UserPosition.fromJson(json.coarse.position);
             }
         }
+        if (typeof json.userAgent === 'object') {
+            output.userAgent = json.userAgent;
+        }
         return output;
     }
 }

package/src/providers/vision/vps/VpsRequest.js

@@ -0,0 +1,29 @@
+import { CameraUtils } from '@wemap/camera';
+
+import VpsMetadata from './VpsMetadata.js';
+
+class VpsRequest {
+
+    /** @type {VpsMetadata} */
+    metadata = new VpsMetadata();
+
+    /** @type {HTMLCanvasElement} */
+    image;
+
+    toJson() {
+        const base64Image = CameraUtils.canvasToBase64(this.image);
+        return {
+            image: base64Image,
+            ...this.metadata.toJson()
+        };
+    }
+
+    static fromJson(json) {
+        const vpsRequest = new VpsRequest();
+        vpsRequest.metadata = VpsMetadata.fromJson(json);
+        vpsRequest.image = CameraUtils.base64ToCanvas(json.image);
+        return vpsRequest;
+    }
+}
+
+export default VpsRequest;

package/src/providers/vision/vps/VpsResponse.js

@@ -0,0 +1,23 @@
+import { Attitude, UserPosition } from '@wemap/geo';
+
+class VpsResponse {
+
+    /** @type {Attitude} */
+    attitude;
+
+    /** @type {UserPosition} */
+    position;
+
+    /**
+     * @param {object} json
+     * @returns {VpsResponse}
+     */
+    fromJson(json) {
+        const response = new VpsResponse();
+        response.attitude = Attitude.fromJson(json.attitude);
+        response.userPosition = UserPosition.fromJson(json.userPosition);
+        return response;
+    }
+}
+
+export default VpsResponse;

package/src/mapmatching/MapMatchingHandler.spec.js

@@ -1,136 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import { Coordinates, Network } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
-import { Itinerary } from '@wemap/routers';
-import MMH from './MapMatchingHandler.js';
-
-
-const { expect } = chai;
-
-describe('MapMatchingHandler', () => {
-
-    const p0 = new Coordinates(0, 0, null, 0);
-    const p1 = p0.destinationPoint(5, 0);
-    const p2 = p1.destinationPoint(5, Math.PI / 2);
-    const p3 = p1.destinationPoint(10, 0);
-    const p4 = p0.destinationPoint(2, deg2rad(10));
-
-    const pos1 = p0.clone();
-    const pos2 = pos1.destinationPoint(3, 0);
-    const pos3 = pos2.destinationPoint(10, 0);
-
-    it('_hasTurnInCircle - itinerary', () => {
-
-        expect(MMH._hasTurnInCircle(pos1, Number.MAX_VALUE)).is.false;
-
-        // p4 -> p1 -> p2 is a turn
-        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p2]);
-
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p0))).is.false;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p2))).is.false;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
-
-        // Straight line
-        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p3]);
-
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.false;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.false;
-
-    });
-
-
-    it('_hasTurnInCircle - network', () => {
-
-        // p1 has turns
-        MMH.network = Network.fromCoordinates([[p0, p4, p1], [p1, p2], [p3, p1]]);
-
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
-
-    });
-
-    const p10 = new Coordinates(0, 0, null, 1);
-    const p11 = p10.destinationPoint(5, 0);
-    const p12 = p11.destinationPoint(5, Math.PI / 2);
-    const p13 = p11.destinationPoint(10, 0);
-
-    const pos12 = p10.clone().destinationPoint(3, 0);
-    const pos012 = new Coordinates(0, 0, null, [0, 1]).destinationPoint(3, 0);
-
-    it('_hasTurnInCircle - multi-levels', () => {
-
-        // level 1 is a straight line
-        MMH.network = Network.fromCoordinates([
-            [p0, p4, p1], [p1, p2], [p3, p1],
-            [p10, p11, p13]
-        ]);
-
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p1))).is.true;
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p11))).is.false;
-
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
-
-        // Changing level
-        // straight line
-        MMH.network = Network.fromCoordinates([
-            [p0, p4, p11], [p11, p13]
-        ]);
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p4))).is.false;
-        expect(MMH._hasTurnInCircle(pos2, Number.MAX_VALUE)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, Number.MAX_VALUE)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, Number.MAX_VALUE)).is.false;
-
-        // Changing level
-        // turn in p11
-        MMH.network = Network.fromCoordinates([
-            [p0, p4, p11], [p11, p12], [p11, p13]
-        ]);
-
-        expect(MMH._nodeHasTurn(MMH.network.getNodeByCoords(p11))).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos12, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
-
-    });
-
-});