@wemap/providers 6.0.0 → 6.1.0

package/dist/wemap-providers.es.js

@@ -1,9 +1,10 @@
 import { deg2rad, Vector3, Matrix, Quaternion, Matrix3, Matrix4, Vector, Rotations, std, diffAngleLines, diffAngle, rad2deg } from '@wemap/maths';
 import { BrowserUtils, Browser, PromiseUtils, TimeUtils } from '@wemap/utils';
 import Logger from '@wemap/logger';
-import { Attitude, RelativePosition, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1, Network } from '@wemap/geo';
+import { GraphUtils, Level, Coordinates, Network, GraphRouterOptions, Attitude, RelativePosition, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1 } from '@wemap/geo';
 import geomagnetism from '@wemap/geomagnetism';
-import { Itinerary } from '@wemap/osm';
+import '@wemap/osm';
+import { SharedCameras, Camera, CameraUtils } from '@wemap/camera';
 
 /**
  * Event data types handled by {@link ProviderEvent}
@@ -185,10 +186,18 @@ const ProvidersOptions = {
 
     /**
      * Providers listed here will not be used by the system
-     * List of {@link Provider#name}
+     * List of {@link Provider#pname}
      */
     ignoreProviders: [],
 
+    /**
+     * Some providers are not used by default (VPS, QRCodeScanner) because they
+     * require data from an optional external service or because they drain more
+     * battery. They can be added to this list to be used
+     * List of {@link Provider#pname}
+     */
+    optionalProviders: ['VisionRelocalization'],
+
     /**
      * Define the list of EventType that are optionals
      * List of {@link EventType}
@@ -201,7 +210,11 @@ const ProvidersOptions = {
 
     stepdetectionlocker: true,
 
-    smoother: true
+    smoother: true,
+
+    get hasVps() {
+        return this.optionalProviders.includes('VisionRelocalization');
+    }
 };
 
 /**
@@ -321,9 +334,16 @@ class Provider {
         return false;
     }
 
+    /**
+     * Description of the function
+     * @name onEventsFunction
+     * @function
+     * @param {ProviderEvent[]} events the array of provider events
+    */
+
     /**
      *
-     * @param {Function} onEvents
+     * @param {onEventsFunction} onEvents
      * @param {Function} onError
      * @param {Boolean} startIfNecessary
      * @returns {Number}
@@ -883,6 +903,724 @@ class MissingMagnetometerError extends MissingSensorError {
     }
 }
 
+class LevelChange {
+
+    /** @type {!string} [up|down] */
+    direction;
+
+    /** @type {!number} [-2, -1, 1, ...] */
+    difference;
+
+    /** @type {?string} [elevator|conveyor|stairs] */
+    type = null;
+
+    /**
+     * @param {GraphNode<OsmElement>} firstNode
+     * @param {GraphNode<OsmElement>} secondNode
+     * @returns {LevelChange}
+     */
+    static fromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.builtFrom.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.builtFrom.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.builtFrom.areStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return {
+            direction: this.direction,
+            difference: this.difference,
+            type: this.type
+        };
+    }
+
+    /**
+     * @param {object} json
+     * @returns {LevelChange}
+     */
+    static fromJson(json) {
+        const levelChange = new LevelChange();
+        levelChange.direction = json.direction;
+        levelChange.difference = json.difference;
+        levelChange.type = json.type;
+        return levelChange;
+    }
+}
+
+class Step {
+
+    /** @type {!boolean} */
+    firstStep = false;
+
+    /** @type {!boolean} */
+    lastStep = false;
+
+    /** @type {!number} */
+    number;
+
+    /** @type {!Coordinates} */
+    coords = [];
+
+
+    /** @type {!number} */
+    angle;
+
+    /** @type {!number} */
+    previousBearing;
+
+    /** @type {!number} */
+    nextBearing;
+
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {?number} */
+    duration = null;
+
+    /** @type {?string} */
+    name = null;
+
+
+    /** @type {?LevelChange} */
+    levelChange = null;
+
+    /** @type {?{?subwayEntrance: boolean, ?subwayEntranceRef: string}} */
+    extras = {};
+
+    /** @type {!number} */
+    _idCoordsInLeg = null;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            number: this.number,
+            coords: this.coords.toCompressedJson(),
+            angle: this.angle,
+            previousBearing: this.previousBearing,
+            nextBearing: this.nextBearing,
+            distance: this.distance,
+            _idCoordsInLeg: this._idCoordsInLeg
+        };
+        if (this.firstStep) {
+            output.firstStep = true;
+        }
+        if (this.lastStep) {
+            output.lastStep = true;
+        }
+        if (this.duration !== null) {
+            output.duration = this.duration;
+        }
+        if (this.name !== null) {
+            output.name = this.name;
+        }
+        if (this.levelChange !== null) {
+            output.levelChange = this.levelChange.toJson();
+        }
+        if (this.extras && Object.keys(this.extras).length !== 0) {
+            output.extras = this.extras;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Step}
+     */
+    static fromJson(json) {
+        const step = new Step();
+        step.number = json.number;
+        step.coords = Coordinates.fromCompressedJson(json.coords);
+        step.angle = json.angle;
+        step.previousBearing = json.previousBearing;
+        step.nextBearing = json.nextBearing;
+        step.distance = json.distance;
+        step._idCoordsInLeg = json._idCoordsInLeg;
+        if (json.firstStep) {
+            step.firstStep = json.firstStep;
+        }
+        if (json.lastStep) {
+            step.lastStep = json.lastStep;
+        }
+        if (json.duration) {
+            step.duration = json.duration;
+        }
+        if (json.name) {
+            step.name = json.name;
+        }
+        if (json.levelChange) {
+            step.levelChange = LevelChange.fromJson(json.levelChange);
+        }
+        if (json.extras) {
+            step.extras = json.extras;
+        }
+        return step;
+    }
+}
+
+class Leg {
+
+    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    mode;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    from;
+
+    /** @type {!{name: ?string, coords: !Coordinates}} */
+    to;
+
+    /** @type {!Coordinates[]} */
+    coords;
+
+    /** @type {?{name: !string, routeColor: ?string, routeTextColor: ?string, directionName: ?string}} */
+    transportInfo = null;
+
+    /** @type {?(Step[])} */
+    steps = null;
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            mode: this.mode,
+            from: { coords: this.from.coords.toCompressedJson() },
+            to: { coords: this.to.coords.toCompressedJson() },
+            distance: this.distance,
+            duration: this.duration,
+            coords: this.coords.map(coords => coords.toCompressedJson())
+        };
+        if (this.from.name) {
+            output.from.name = this.from.name;
+        }
+        if (this.to.name) {
+            output.to.name = this.to.name;
+        }
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        if (this.transportInfo !== null) {
+            output.transportInfo = this.transportInfo;
+        }
+        if (this.steps !== null && this.steps.length > 0) {
+            output.steps = this.steps.map(step => step.toJson());
+        }
+        return output;
+    }
+
+
+    /**
+     * @param {object} json
+     * @returns {Leg}
+     */
+    static fromJson(json) {
+        const leg = new Leg();
+        leg.mode = json.mode;
+        leg.from = { coords: Coordinates.fromCompressedJson(json.from.coords) };
+        leg.to = { coords: Coordinates.fromCompressedJson(json.to.coords) };
+        leg.distance = json.distance;
+        leg.duration = json.duration;
+        leg.coords = json.coords.map(Coordinates.fromCompressedJson);
+        if (json.from.name) {
+            leg.from.name = json.from.name;
+        }
+        if (json.to.name) {
+            leg.to.name = json.to.name;
+        }
+        if (json.startTime) {
+            leg.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            leg.endTime = json.endTime;
+        }
+        if (json.transportInfo) {
+            leg.transportInfo = json.transportInfo;
+        }
+        if (json.steps) {
+            leg.steps = json.steps.map(Step.fromJson);
+        }
+        return leg;
+    }
+
+}
+
+/**
+ * Get route duration
+ * @param {Number} speed in km/h
+ * @returns {Number} duration in seconds
+ */
+function getDurationFromLength(length, speed = 5) {
+    return length / (speed * 1000 / 3600);
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * Main attributes are:
+ * nodes: the ordered list of Node
+ * edges: the ordered list of Edge
+ * start: the start point (Coordinates)
+ * end: the end point (Coordinates)
+ * length: the route length
+ */
+class Itinerary {
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {!string} can be WALK, BIKE, CAR, PT */
+    _mode;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!(Leg[])} */
+    legs = [];
+
+    /** @type {?Coordinates[]} */
+    _coords = null;
+
+    set coords(_) {
+        throw new Error('Itinerary.coords cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Coordinates[])} */
+    get coords() {
+        if (!this._coords) {
+            // Returns the coordinates contained in all legs and remove duplicates between array
+            this._coords = this.legs.reduce((acc, val) => {
+                const isDuplicate = acc.length && val.coords.length && acc[acc.length - 1].equalsTo(val.coords[0]);
+                acc.push(...val.coords.slice(isDuplicate ? 1 : 0));
+                return acc;
+            }, []);
+        }
+        return this._coords;
+    }
+
+    set steps(_) {
+        throw new Error('Itinerary.step cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Step[])} */
+    get steps() {
+        return this.legs.map(leg => leg.steps).flat();
+    }
+
+    set mode(_) {
+        throw new Error('Itinerary.mode cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    get mode() {
+        if (!this._mode) {
+            let isPublicTransport;
+            let isBicycle;
+            let isDriving;
+
+            this.legs.forEach((leg) => {
+                isPublicTransport = isPublicTransport || ['BUS', 'FUNICULAR', 'TRAM', 'TRAIN'].includes(leg.mode);
+                isBicycle = isBicycle || ['BIKE', 'BICYCLE'].includes(leg.mode);
+                isDriving = isDriving || leg.mode === 'CAR';
+            });
+
+            if (isPublicTransport) {
+                this._mode = 'PT';
+            } else if (isDriving) {
+                this._mode = 'CAR';
+            } else if (isBicycle) {
+                this._mode = 'BIKE';
+            } else {
+                this._mode = 'WALK';
+            }
+        }
+
+        return this._mode;
+
+    }
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @param {Itinerary[]} itineraries
+     * @returns {Itinerary}
+     */
+    static fromItineraries(...itineraries) {
+        const itinerary = new Itinerary();
+        itinerary.from = itineraries[0].from;
+        itinerary.to = itineraries[itineraries.length - 1].to;
+        itinerary.distance = 0;
+        itinerary.duration = 0;
+        itinerary.legs = [];
+
+        itineraries.forEach(_itinerary => {
+            itinerary.distance += _itinerary.distance;
+            itinerary.duration += _itinerary.duration;
+            itinerary.legs.push(..._itinerary.legs);
+            itinerary.legs.forEach(leg => {
+                leg.steps[0].firstStep = false;
+                leg.steps[leg.steps.length - 1].lastStep = false;
+            });
+        });
+
+        itinerary.legs[0].steps[0].firstStep = true;
+        const lastLeg = itinerary.legs[itinerary.legs.length - 1];
+        lastLeg.steps[lastLeg.steps.length - 1].lastStep = true;
+
+        return itinerary;
+    }
+
+    /**
+     * Convert lat/lng/level points to Itinerary
+     * @param {number[][]} points 2D points array of lat/lng/level (level is optional)
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedPointsArray(points, start, end) {
+
+        const pointToCoordinates = point => new Coordinates(point[0], point[1], null, point[2]);
+
+        return this.fromOrderedCoordinates(
+            points.map(pointToCoordinates),
+            pointToCoordinates(start),
+            pointToCoordinates(end)
+        );
+    }
+
+    /**
+     * Convert ordered Coordinates to Itinerary
+     * @param {Coordinates[]} points
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedCoordinates(points, from, to, mode = 'WALK') {
+
+        const itinerary = new Itinerary();
+        itinerary.from = from;
+        itinerary.to = to;
+
+        const leg = new Leg();
+        leg.mode = mode;
+        leg.from = { name: null, coords: from };
+        leg.to = { name: null, coords: to };
+
+        leg.coords = points;
+        leg.distance = points.reduce((acc, coords, idx, arr) => {
+            if (idx !== 0) {
+                return acc + arr[idx - 1].distanceTo(coords);
+            }
+            return acc;
+        }, 0);
+        leg.duration = getDurationFromLength(leg.distance);
+        itinerary.legs.push(leg);
+
+        itinerary.distance = leg.distance;
+        itinerary.duration = leg.duration;
+
+        return itinerary;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            mode: this.mode,
+            legs: this.legs.map(leg => leg.toJson())
+        };
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Itinerary}
+     */
+    static fromJson(json) {
+        const itinerary = new Itinerary();
+        itinerary.from = Coordinates.fromCompressedJson(json.from);
+        itinerary.to = Coordinates.fromCompressedJson(json.to);
+        itinerary.distance = json.distance;
+        itinerary.duration = json.duration;
+        itinerary.legs = json.legs.map(Leg.fromJson);
+        if (json.startTime) {
+            itinerary.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            itinerary.endTime = json.endTime;
+        }
+        return itinerary;
+    }
+}
+
+class WemapRouterOptions extends GraphRouterOptions {
+
+    /** @type {WemapRouterOptions} */
+    static DEFAULT = new WemapRouterOptions();
+
+    /**
+     * @returns {WemapRouterOptions}
+     */
+    static get WITHOUT_STAIRS() {
+        const options = new WemapRouterOptions();
+        options.acceptEdgeFn = edge => edge.builtFrom.tags.highway !== 'steps';
+        return options;
+    }
+
+    /**
+     * Get route duration
+     * @param {Number} speed in km/h
+     */
+    static getDurationFromLength(length, speed = 5) {
+        return length / (speed * 1000 / 3600);
+    }
+
+    /** @type {function(GraphEdge<OsmElement>):boolean} */
+    weightEdgeFn = edge => edge.builtFrom.isElevator ? 30 : WemapRouterOptions.getDurationFromLength(edge.length);
+
+
+}
+
+/* eslint-disable complexity */
+
+deg2rad(20);
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+createCommonjsModule(function (module) {
+
+/**
+ * Based off of [the offical Google document](https://developers.google.com/maps/documentation/utilities/polylinealgorithm)
+ *
+ * Some parts from [this implementation](http://facstaff.unca.edu/mcmcclur/GoogleMaps/EncodePolyline/PolylineEncoder.js)
+ * by [Mark McClure](http://facstaff.unca.edu/mcmcclur/)
+ *
+ * @module polyline
+ */
+
+var polyline = {};
+
+function py2_round(value) {
+    // Google's polyline algorithm uses the same rounding strategy as Python 2, which is different from JS for negative values
+    return Math.floor(Math.abs(value) + 0.5) * (value >= 0 ? 1 : -1);
+}
+
+function encode(current, previous, factor) {
+    current = py2_round(current * factor);
+    previous = py2_round(previous * factor);
+    var coordinate = current - previous;
+    coordinate <<= 1;
+    if (current - previous < 0) {
+        coordinate = ~coordinate;
+    }
+    var output = '';
+    while (coordinate >= 0x20) {
+        output += String.fromCharCode((0x20 | (coordinate & 0x1f)) + 63);
+        coordinate >>= 5;
+    }
+    output += String.fromCharCode(coordinate + 63);
+    return output;
+}
+
+/**
+ * Decodes to a [latitude, longitude] coordinates array.
+ *
+ * This is adapted from the implementation in Project-OSRM.
+ *
+ * @param {String} str
+ * @param {Number} precision
+ * @returns {Array}
+ *
+ * @see https://github.com/Project-OSRM/osrm-frontend/blob/master/WebContent/routing/OSRM.RoutingGeometry.js
+ */
+polyline.decode = function(str, precision) {
+    var index = 0,
+        lat = 0,
+        lng = 0,
+        coordinates = [],
+        shift = 0,
+        result = 0,
+        byte = null,
+        latitude_change,
+        longitude_change,
+        factor = Math.pow(10, Number.isInteger(precision) ? precision : 5);
+
+    // Coordinates have variable length when encoded, so just keep
+    // track of whether we've hit the end of the string. In each
+    // loop iteration, a single coordinate is decoded.
+    while (index < str.length) {
+
+        // Reset shift, result, and byte
+        byte = null;
+        shift = 0;
+        result = 0;
+
+        do {
+            byte = str.charCodeAt(index++) - 63;
+            result |= (byte & 0x1f) << shift;
+            shift += 5;
+        } while (byte >= 0x20);
+
+        latitude_change = ((result & 1) ? ~(result >> 1) : (result >> 1));
+
+        shift = result = 0;
+
+        do {
+            byte = str.charCodeAt(index++) - 63;
+            result |= (byte & 0x1f) << shift;
+            shift += 5;
+        } while (byte >= 0x20);
+
+        longitude_change = ((result & 1) ? ~(result >> 1) : (result >> 1));
+
+        lat += latitude_change;
+        lng += longitude_change;
+
+        coordinates.push([lat / factor, lng / factor]);
+    }
+
+    return coordinates;
+};
+
+/**
+ * Encodes the given [latitude, longitude] coordinates array.
+ *
+ * @param {Array.<Array.<Number>>} coordinates
+ * @param {Number} precision
+ * @returns {String}
+ */
+polyline.encode = function(coordinates, precision) {
+    if (!coordinates.length) { return ''; }
+
+    var factor = Math.pow(10, Number.isInteger(precision) ? precision : 5),
+        output = encode(coordinates[0][0], 0, factor) + encode(coordinates[0][1], 0, factor);
+
+    for (var i = 1; i < coordinates.length; i++) {
+        var a = coordinates[i], b = coordinates[i - 1];
+        output += encode(a[0], b[0], factor);
+        output += encode(a[1], b[1], factor);
+    }
+
+    return output;
+};
+
+function flipped(coords) {
+    var flipped = [];
+    for (var i = 0; i < coords.length; i++) {
+        var coord = coords[i].slice();
+        flipped.push([coord[1], coord[0]]);
+    }
+    return flipped;
+}
+
+/**
+ * Encodes a GeoJSON LineString feature/geometry.
+ *
+ * @param {Object} geojson
+ * @param {Number} precision
+ * @returns {String}
+ */
+polyline.fromGeoJSON = function(geojson, precision) {
+    if (geojson && geojson.type === 'Feature') {
+        geojson = geojson.geometry;
+    }
+    if (!geojson || geojson.type !== 'LineString') {
+        throw new Error('Input must be a GeoJSON LineString');
+    }
+    return polyline.encode(flipped(geojson.coordinates), precision);
+};
+
+/**
+ * Decodes to a GeoJSON LineString geometry.
+ *
+ * @param {String} str
+ * @param {Number} precision
+ * @returns {Object}
+ */
+polyline.toGeoJSON = function(str, precision) {
+    var coords = polyline.decode(str, precision);
+    return {
+        type: 'LineString',
+        coordinates: flipped(coords)
+    };
+};
+
+if (module.exports) {
+    module.exports = polyline;
+}
+});
+
 const DEFAULT_RELATIVE_NOISES = {
     acc: 0.5,
     gyr: 0.3
@@ -2933,6 +3671,277 @@ class GeoRelativePosition extends Provider {
 
 var GeoRelativePositionProvider = new GeoRelativePosition();
 
+function preciseTime() {
+    if (typeof window !== 'undefined' && window.performance) {
+        return window.performance.now();
+    }
+    const hrtime = process.hrtime();
+    return Math.round((hrtime[0] * 1e3) + (hrtime[1] / 1e6));
+}
+
+/* eslint-disable max-statements */
+
+class VisionRelocalization extends Provider {
+
+    // static SERVICE_URL = 'http://localhost:45678/';
+    static SERVICE_URL = 'https://vps.maaap.it/';
+    static MAP_ID = 'wemap';
+    static MIN_TIME_BETWEEN_TWO_REQUESTS = 1000;
+
+    /** @type {boolean} */
+    _serverError = false;
+
+    /** @type {boolean} */
+    _cameraError = false;
+
+    /** @type {Camera} */
+    _camera = null;
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'VisionRelocalization';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Promise.resolve();
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        // 1. Add listeners on shared cameras to detect new cameras
+        SharedCameras.on('added', this._onCameraDetected);
+        SharedCameras.on('removed', this._onCameraRemoved);
+
+        // 2. If a camera already exists, use it
+        if (SharedCameras.list.length) {
+            if (SharedCameras.list.length > 1) {
+                Logger.warn('It seems that more than 1 camera has been detected'
+                    + ' for VPS. Taking the first...');
+            }
+            this._useCamera(SharedCameras.list[0].camera);
+        }
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        SharedCameras.off('added', this._onCameraDetected);
+        SharedCameras.off('removed', this._onCameraRemoved);
+
+        this._camera = null;
+    }
+
+
+    _onCameraDetected = ({ camera }) => {
+        if (this._camera) {
+            Logger.warn('It seems that more than 1 camera has been detected'
+                + ' for VPS. Taking the first...');
+        }
+        this._useCamera(camera);
+    }
+
+    _onCameraRemoved = () => {
+        if (this._camera) {
+            this._camera.off('started', this._internalStart);
+            this._camera.off('stopped', this._internalStop);
+        } else {
+            Logger.warn('There is no previously detected camera but once has stopped');
+        }
+        this._camera = null;
+    }
+
+    /**
+     * @param {Camera} camera
+     */
+    _useCamera(camera) {
+        this._camera = camera;
+
+        camera.on('started', this._internalStart);
+        camera.on('stopped', this._internalStop);
+
+        if (camera.isStarted) {
+            this._internalStart();
+        }
+    }
+
+
+    _internalStart = async () => {
+
+        this._serverError = false;
+
+        let lastTimestamp = -1;
+
+        while (this.state !== ProviderState.STOPPPED) {
+
+            const diffTime = preciseTime() - lastTimestamp;
+            const timeToWait = Math.max(0, VisionRelocalization.MIN_TIME_BETWEEN_TWO_REQUESTS - diffTime);
+            await new Promise(resolve => setTimeout(resolve, timeToWait));
+
+            if (this.state === ProviderState.STOPPPED) {
+                break;
+            }
+
+            const url = VisionRelocalization.SERVICE_URL + VisionRelocalization.MAP_ID;
+
+            // 1. Prepare the request
+            if (!this._camera || this._camera.state !== Camera.State.STARTED) {
+                break;
+            }
+            const payload = await this._prepareRequest();
+
+            if (this.state === ProviderState.STOPPPED) {
+                break;
+            }
+
+            // 2. Send the request
+            const serverResponse = await fetch(url, {
+                method: 'POST',
+                body: JSON.stringify(payload),
+                headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }
+            });
+
+            if (this.state === ProviderState.STOPPPED) {
+                break;
+            }
+
+            // 3. Parse the response
+            const events = await this._parseResponse(serverResponse, url, payload.time);
+            if (this._serverError || this.state === ProviderState.STOPPPED) {
+                break;
+            }
+
+            // 4. Notify events
+            if (events.length) {
+                this.notify(...events);
+            }
+
+            lastTimestamp = preciseTime();
+        }
+
+        if (this.state !== ProviderState.STOPPPED) {
+            this.stop();
+        }
+    }
+
+    _internalStop = () => {
+        // do nothing
+    }
+
+
+    /**
+     * @returns {Object}
+     */
+    async _prepareRequest() {
+
+        const camera = this._camera;
+
+        // Retrieve the image
+        const image = await camera.currentImage;
+        const time = preciseTime();
+        // TODO: move the grayscale conversion in the currentImage getter
+        CameraUtils.convertToGrayscale(image);
+        const reducedImage = CameraUtils.reduceImageSize(image, 1280);
+        // const reducedImage = CameraUtils.reduceImageSize(image, 720, 720);
+        const { height, width } = reducedImage;
+        const base64Image = CameraUtils.canvasToBase64(reducedImage);
+
+        // Retrieve the calibration matrix
+        const calibration = CameraUtils.createCameraCalibrationFromWidthHeightFov(
+            width, height, deg2rad(camera.hardwareVerticalFov)
+        );
+
+        // Build the payload
+        return {
+            calibration,
+            size: [width, height],
+            image: base64Image,
+            time
+        };
+    }
+
+    /**
+     * @param {Response} res
+     * @param {String} url
+     * @param {Number} requestTime
+     * @returns {ProviderEvent[]}
+     */
+    async _parseResponse(res, url, requestTime) {
+        if (res.status !== 200) {
+            Logger.warn(`The VPS server (${url}) has encountered a problem`);
+            this._serverError = true;
+            return [];
+        }
+
+        const json = await res.json();
+        if (json.error) {
+            return [];
+        }
+
+        const { attitude, userPosition } = VisionRelocalization._parseJsonResponse(json, requestTime);
+
+        const events = [
+            this.createEvent(EventType.AbsoluteAttitude, attitude),
+            this.createEvent(EventType.AbsolutePosition, userPosition)
+        ];
+
+        return events;
+    }
+
+
+    static _parseJsonResponse(json, requestTime) {
+
+        const quaternion = [
+            json.attitude.w,
+            json.attitude.x,
+            json.attitude.y,
+            json.attitude.z
+        ];
+        const quaternionNorm = Quaternion.norm(quaternion);
+        quaternion[0] /= quaternionNorm;
+        quaternion[1] /= quaternionNorm;
+        quaternion[2] /= quaternionNorm;
+        quaternion[3] /= quaternionNorm;
+
+        const quaternionWithScreenRotation = Quaternion.multiply(
+            Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)), quaternion
+        );
+
+        const attitude = new Attitude(quaternionWithScreenRotation, requestTime, 0);
+
+
+        const userPosition = new UserPosition(
+            json.coordinates.lat,
+            json.coordinates.lng,
+            json.coordinates.alt,
+            json.coordinates.level ? new Level(json.coordinates.level) : null,
+            requestTime,
+            0,
+            attitude.heading
+        );
+
+
+        return { userPosition, attitude };
+    }
+}
+
+var VisionRelocalization$1 = new VisionRelocalization();
+
 class AbsolutePosition extends Provider {
 
     // Use the new absolute position if its accuracy is at least x times better than the last one.
@@ -2990,13 +3999,29 @@ class AbsolutePosition extends Provider {
                 // do nothing
             });
 
-        this._gnssWifiProviderId = GnssWifi$1.addEventListener(
-            events => {
-                // bearing from GnssWifi is not reliable for our usecase
-                events[0].data.bearing = null;
-                this._onAbsolutePosition(events[0], false);
-            }
-        );
+        if (ProvidersOptions.hasVps) {
+
+            const vpsProviderId = VisionRelocalization$1.addEventListener(events => {
+                for (const providerEvent of events) {
+                    if (providerEvent.dataType === EventType.AbsolutePosition) {
+                        this._onAbsolutePosition(providerEvent);
+                        VisionRelocalization$1.removeEventListener(vpsProviderId);
+                        return;
+                    }
+                }
+            });
+
+        } else {
+
+            this._gnssWifiProviderId = GnssWifi$1.addEventListener(
+                events => {
+                    // bearing from GnssWifi is not reliable for our usecase
+                    events[0].data.bearing = null;
+                    this._onAbsolutePosition(events[0], false);
+                }
+            );
+
+        }
 
         this._mapMatchingHandlerId = MapMatchingHandler$1.addEventListener();
     }
@@ -4267,6 +5292,7 @@ var Providers = /*#__PURE__*/Object.freeze({
     GnssWifi: GnssWifi$1,
     Ip: Ip$1,
     AbsolutePosition: AbsolutePosition$1,
+    VisionRelocalization: VisionRelocalization$1,
     Barcode: Barcode$1,
     CameraNative: CameraNative$1,
     CameraProjectionMatrix: CameraProjectionMatrix$1
@@ -4357,6 +5383,9 @@ class ProvidersInterface {
         case EventType.CameraProjectionMatrix:
             return CameraProjectionMatrix$1;
 
+        case EventType.MagnetometerNeedCalibration:
+            return MagnetometerCalibrationDetector$1;
+
         default:
             throw new Error(`Unable to deal with this event type: ${eventType}`);
         }