@wemap/providers 9.2.0 → 10.0.0-alpha.0

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