@wemap/providers 9.0.3 → 9.0.4

package/index.js

@@ -36,7 +36,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 ArCore } from './src/providers/position/relative/ArCore.js';
 export { default as Pdr } from './src/providers/position/relative/Pdr.js';
 export { default as GeoRelativePositionFromArCore } from './src/providers/position/relative/GeoRelativePositionFromArCore.js';
 export { default as GeoRelativePosition } from './src/providers/position/relative/GeoRelativePosition.js';
@@ -46,8 +45,10 @@ export { default as PoleStar } from './src/providers/position/absolute/PoleStar.
 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 Barcode } from './src/providers/vision/Barcode.js';
 
-export { default as Barcode } from './src/providers/others/Barcode.js';
 export { default as CameraNative } from './src/providers/others/CameraNative.js';
 export { default as CameraProjectionMatrix } from './src/providers/others/CameraProjectionMatrix.js';

package/package.json

@@ -9,13 +9,13 @@
   ],
   "dependencies": {
     "@wemap/camera": "^9.0.0",
-    "@wemap/geo": "^9.0.3",
+    "@wemap/geo": "^9.0.4",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^9.0.0",
-    "@wemap/map": "^9.0.3",
+    "@wemap/map": "^9.0.4",
     "@wemap/maths": "^9.0.0",
-    "@wemap/osm": "^9.0.3",
-    "@wemap/routers": "^9.0.3",
+    "@wemap/osm": "^9.0.4",
+    "@wemap/routers": "^9.0.4",
     "@wemap/utils": "^9.0.0"
   },
   "description": "A package using different geoloc systems",
@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.0.3",
-  "gitHead": "ba88e7b5fa491af11700ba59f793ccf571e8f39d"
+  "version": "9.0.4",
+  "gitHead": "9d6b6776b86ae16dfa3fb71c3303d48a8289ceed"
 }

package/src/ProvidersInterface.js

@@ -10,7 +10,7 @@ import MapMatchingHandler from './mapmatching/MapMatchingHandler.js';
 
 import AbsoluteAttitude from './providers/attitude/absolute/AbsoluteAttitude.js';
 import AbsolutePosition from './providers/position/absolute/AbsolutePosition.js';
-import Barcode from './providers/others/Barcode.js';
+import Barcode from './providers/vision/Barcode.js';
 import CameraNative from './providers/others/CameraNative.js';
 import CameraProjectionMatrix from './providers/others/CameraProjectionMatrix.js';
 import Inclination from './providers/inclination/Inclination.js';

package/src/providers/attitude/relative/RelativeAttitude.js

@@ -3,7 +3,7 @@ import EventType from '../../../events/EventType.js';
 import ProviderState from '../../ProviderState.js';
 
 import RelativeAttitudeFromInertial from './RelativeAttitudeFromInertial.js';
-import ArCore from '../../position/relative/ArCore.js';
+import ArCore from '../../vision/ArCore.js';
 
 /**
  * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using

package/src/providers/others/CameraNative.js

@@ -1,6 +1,6 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import ArCore from '../position/relative/ArCore.js';
+import ArCore from '../vision/ArCore.js';
 import ProviderState from '../ProviderState.js';
 
 class CameraNative extends Provider {

package/src/providers/others/CameraProjectionMatrix.js

@@ -1,6 +1,6 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import ArCore from '../position/relative/ArCore.js';
+import ArCore from '../vision/ArCore.js';
 
 class CameraProjectionMatrix extends Provider {
 

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

@@ -20,13 +20,6 @@ class AbsolutePosition extends Provider {
     /** @type {boolean} */
     static USE_MM_FOR_FEED = true;
 
-    // /** @type {number} */
-    // static POLESTAR_TIME_DISCARD_GNSSWIFI_FROM_LAST_FIX = 3000;
-
-    // /** @type {number} */
-    // static GNSSWIFI_DISCARD_POLESTAR_IF_ACCURACY_RATIO_BETTER_THAN = 2;
-
-
     /** @type {number?} */
     _gnssWifiProviderId;
 
@@ -39,9 +32,6 @@ class AbsolutePosition extends Provider {
     /** @type {boolean?} */
     _waitUntilNextVpsPosition = false;
 
-    // /** @type {?number} */
-    // _lastPolestarFix;
-
     /**
     * @override
     */
@@ -81,45 +71,26 @@ class AbsolutePosition extends Provider {
                 // do nothing
             });
 
-        if (ProvidersOptions.hasVps) {
-
-            this._vpsProviderId = Vps.addEventListener(events => {
-                this._onAbsolutePosition(events.find(event => event.dataType === EventType.AbsolutePosition));
-                Vps.removeEventListener(this._vpsProviderId);
-                this._vpsProviderId = null;
-            });
 
-        } else {
+        // GnssWifi
+        this._gnssWifiProviderId = GnssWifi.addEventListener(
+            events => {
+                // bearing from GnssWifi is not reliable for our usecase
+                events[0].data.bearing = null;
+                this._onAbsolutePosition(events[0], false);
+            }
+        );
 
-            this._gnssWifiProviderId = GnssWifi.addEventListener(
-                events => {
-                    // const useLevel = false;
-                    // if (typeof this._lastPolestarFix !== 'undefined'
-                    //     && TimeUtils.preciseTime() - this._lastPolestarFix < AbsolutePosition.POLESTAR_TIME_DISCARD_GNSSWIFI_FROM_LAST_FIX) {
-                    //     // Discard the GNSSWifi position if the last Polestar position is too recent
-                    //     console.log(`[Dev] Formula - PS: ${PoleStar.lastEvent.data.accuracy},
-                    //         GNSSWifi: ${events[0].data.accuracy},
-                    //         ratio: ${PoleStar.lastEvent.data.accuracy / events[0].data.accuracy}`);
-                    //     if (PoleStar.lastEvent.data.accuracy / events[0].data.accuracy > AbsolutePosition.GNSSWIFI_DISCARD_POLESTAR_IF_ACCURACY_RATIO_BETTER_THAN) {
-                    //         // Except if the accuracy of the Polestar position is really better than the GNSSWifi position
-                    //         // In this case we add the level provided by Pole Star to the position
-                    //         console.log(`[Dev] Apply PS level ${PoleStar.lastEvent.data.level} to GnssWifi`);
-                    //         events[0].data.level = PoleStar.lastEvent.data.level;
-                    //         useLevel = true;
-                    //     } else {
-                    //         console.log('[Dev] Discard GnssWifi fix with accuracy: ', events[0].data.accuracy);
-                    //         return;
-                    //     }
-                    // }
-                    // console.log('[Dev] Use GnssWifi fix with accuracy: ', events[0].data.accuracy);
-                    // bearing from GnssWifi is not reliable for our usecase
-                    events[0].data.bearing = null;
-                    this._onAbsolutePosition(events[0], false);
-                }
+        // Vps
+        if (ProvidersOptions.hasVps) {
+            this._vpsProviderId = Vps.addEventListener(
+                events => this._onAbsolutePosition(events.find(event => event.dataType === EventType.AbsolutePosition)),
+                error => this.notifyError(error),
+                false
             );
-
         }
 
+        // PoleStar
         if (ProvidersOptions.hasPoleStar) {
             this._polestarProviderId = PoleStar.addEventListener(events => {
 

package/src/providers/position/relative/GeoRelativePositionFromArCore.js

@@ -3,7 +3,7 @@ import { GeoRelativePosition } from '@wemap/geo';
 import EventType from '../../../events/EventType.js';
 import AbsoluteAttitude from '../../attitude/absolute/AbsoluteAttitude.js';
 import Provider from '../../Provider.js';
-import ArCore from './ArCore.js';
+import ArCore from '../../vision/ArCore.js';
 
 class GeoRelativePositionFromArCore extends Provider {
 

package/src/providers/{position/relative → vision}/ArCore.js

@@ -5,11 +5,12 @@ import {
 import { deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
-import Provider from '../../Provider.js';
-import EventType from '../../../events/EventType.js';
-import MissingArCoreError from '../../../errors/MissingArCoreError.js';
-import MissingNativeInterfaceError from '../../../errors/MissingNativeInterfaceError.js';
-import ProviderState from '../../ProviderState.js';
+import Provider from '../Provider.js';
+import EventType from '../../events/EventType.js';
+import MissingArCoreError from '../../errors/MissingArCoreError.js';
+import MissingNativeInterfaceError from '../../errors/MissingNativeInterfaceError.js';
+import ProviderState from '../ProviderState.js';
+
 class ArCore extends Provider {
 
     static Payload = {

package/src/providers/{others → vision}/Barcode.js

@@ -1,6 +1,6 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import ArCore from '../position/relative/ArCore.js';
+import ArCore from './ArCore.js';
 
 class Barcode extends Provider {
 

package/src/providers/vision/ImageRelocalization.js

@@ -0,0 +1,120 @@
+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';
+
+class ImageRelocalization {
+
+    /**
+     * @param {HTMLCanvasElement} imageCanvas
+     * @param {{intrinsic:number[], distortions:number[]}} calibration
+     * @param {{position: Coordinates, positionAccuracy: number}} coarsePose
+     * @returns {object}
+     */
+    static _prepareRequest(imageCanvas, calibration, coarsePose) {
+        const requestTime = TimeUtils.preciseTime() / 1e3;
+
+        CameraUtils.convertToGrayscale(imageCanvas);
+        const reducedImage = CameraUtils.reduceImageSize(imageCanvas, 1280);
+        const base64Image = CameraUtils.canvasToBase64(reducedImage);
+
+        const metadata = new VpsMetadata();
+        metadata.time = requestTime;
+        metadata.size = { width: reducedImage.width, height: reducedImage.height };
+        metadata.calibration = calibration;
+        metadata.coarse = coarsePose;
+
+        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 };
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {HTMLCanvasElement} imageCanvas
+     * @param {{intrinsic:number[], distortions:number[]}} calibration
+     * @param {{position: Coordinates, positionAccuracy: number}} coarsePose
+     * @returns {{userPosition: UserPosition, attitude: Attitude}|null}
+     */
+    static async relocalize(endpointUrl, imageCanvas, calibration = null, coarsePose = null) {
+
+        // 1. Prepare the request
+        const jsonPayload = this._prepareRequest(imageCanvas, calibration, coarsePose);
+
+        // 2. Send the request
+        let serverResponse;
+        try {
+            serverResponse = await fetch(endpointUrl, {
+                method: 'POST',
+                body: JSON.stringify(jsonPayload),
+                headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }
+            });
+        } catch (e) {
+            return null;
+        }
+
+        if (serverResponse.status !== 200) {
+            return null;
+        }
+
+        const json = await serverResponse.json();
+        if (json.error) {
+            Logger.warn(json.error);
+            return null;
+        }
+
+        // 3. Parse the response
+        const { userPosition, attitude } = this._parseJsonResponse(json, jsonPayload.time);
+
+        return { userPosition, attitude };
+    }
+
+    static getHeadingFromQuaternion(quaternion) {
+
+        const [qw, qx, qy, qz] = quaternion;
+
+        const s = Math.sqrt(2) / 2;
+        const C = [s * (qw - qx), s * (qw + qx), s * (qy + qz), s * (qz - qy)];
+        return -Math.atan2(2 * C[3] * C[0] - 2 * C[2] * C[1], 1 - 2 * C[1] ** 2 - 2 * C[3] ** 2);
+
+        // ---- Not optimized version ----
+
+        // const eulerAnglesAR = Rotations.quaternionToEulerZXY(
+        //     Quaternion.multiply(
+        //         quaternion,
+        //         Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2)
+        //     )
+        // );
+
+        // return -eulerAnglesAR[0];
+    }
+}
+
+export default ImageRelocalization;

package/src/providers/vision/Vps.js

@@ -1,19 +1,21 @@
 /* eslint-disable max-statements */
-import { SharedCameras, CameraUtils, Camera } from '@wemap/camera';
-import { Attitude, UserPosition } from '@wemap/geo';
+import { SharedCameras, Camera } from '@wemap/camera';
+import { Attitude } from '@wemap/geo';
 import Logger from '@wemap/logger';
-import { deg2rad, Quaternion } from '@wemap/maths';
+import { Quaternion, deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import EventType from '../../events/EventType.js';
-import ProviderEvent from '../../events/ProviderEvent.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 CAMERA_TO_SMARTPHONE_ROT = Quaternion.fromAxisAngle([1, 0, 0], Math.PI);
+
     /** @type {boolean} */
     _serverError = false;
 
@@ -25,7 +27,7 @@ class Vps extends Provider {
 
     /** @type {?string} */
     _endpoint = null;
-    // _endpoint = 'https://vps.maaap.it/wemap';
+
 
     /**
     * @override
@@ -119,170 +121,64 @@ class Vps extends Provider {
 
     _internalStart = async () => {
 
-        this._serverError = false;
-
         if (!this._endpoint) {
-            this._serverError = true;
-            Logger.error('VPS endpoint has not been set before calling start()');
-            this.stop();
+            this.notifyError(new Error('VPS endpoint has not been set before calling start()'));
             return;
         }
 
         while (this.state !== ProviderState.STOPPPED) {
 
+            // 1. Handle the time to wait between two requests (MIN_TIME_BETWEEN_TWO_REQUESTS)
             if (this.lastEvent) {
                 const diffTime = TimeUtils.preciseTime() - this.lastEvent.data.time * 1e3;
                 const timeToWait = Math.max(0, Vps.MIN_TIME_BETWEEN_TWO_REQUESTS - diffTime);
                 await new Promise(resolve => setTimeout(resolve, timeToWait));
             }
 
-            if (this.state === ProviderState.STOPPPED) {
+            // 2. Check if Vps is not stopped and camera is still started
+            if (this.state === ProviderState.STOPPPED
+                || !this._camera
+                || this._camera.state !== Camera.State.STARTED) {
                 break;
             }
 
-            // const url = Vps.SERVICE_URL + Vps.MAP_ID;
+            // 3. Get current image from camera and relocalize it.
+            const image = await this._camera.currentImage;
+            const res = await ImageRelocalization.relocalize(this._endpoint, image);
 
-            // 1. Prepare the request
-            if (!this._camera || this._camera.state !== Camera.State.STARTED) {
-                break;
+            if (!res) {
+                continue;
             }
-            const payload = await this._prepareRequest();
 
-            if (this.state === ProviderState.STOPPPED) {
-                break;
-            }
+            // 4. If relocalization is successful, apply the transforms
+            const enuToCameraRot = res.attitude.quaternion;
+            const enuToSmartphoneRot = Quaternion.multiply(
+                enuToCameraRot,
+                Vps.CAMERA_TO_SMARTPHONE_ROT
+            );
 
-            // 2. Send the request
-            const serverResponse = await fetch(this._endpoint, {
-                method: 'POST',
-                body: JSON.stringify(payload),
-                headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }
-            });
+            const deviceQuaternion = Quaternion.multiply(
+                Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)),
+                enuToSmartphoneRot
+            );
+            const attitude = new Attitude(deviceQuaternion, res.attitude.time, res.attitude.accuracy);
 
+            // 5. Finally, notify the listeners if the VPS is not stopped
             if (this.state === ProviderState.STOPPPED) {
                 break;
             }
 
-            // 3. Parse the response
-            const events = await this._parseResponse(serverResponse, this._endpoint, payload.time);
-            if (this._serverError || this.state === ProviderState.STOPPPED) {
-                break;
-            }
+            this.notify(
+                this.createEvent(EventType.AbsoluteAttitude, attitude),
+                this.createEvent(EventType.AbsolutePosition, res.userPosition)
+            );
 
-            // 4. Notify events
-            if (events.length) {
-                this.notify(...events);
-            }
-        }
-
-        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 = TimeUtils.preciseTime() / 1e3;
-        // 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 } = Vps._parseJsonResponse(json, requestTime);
-
-        const events = [
-            this.createEvent(EventType.AbsoluteAttitude, attitude),
-            this.createEvent(EventType.AbsolutePosition, userPosition)
-        ];
-
-        return events;
-    }
-
-
-    static _parseJsonResponse(json, requestTime) {
-
-        const enuToCameraRot = [
-            json.attitude.w,
-            json.attitude.x,
-            json.attitude.y,
-            json.attitude.z
-        ];
-
-        const cameraToSmartphoneRot = Quaternion.fromAxisAngle(
-            [1, 0, 0],
-            Math.PI
-        );
-        const enuToSmartphoneRot = Quaternion.multiply(
-            enuToCameraRot,
-            cameraToSmartphoneRot
-        );
-
-        const quaternionWithScreenRotation = Quaternion.multiply(
-            Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)),
-            enuToSmartphoneRot
-        );
-
-        const attitude = new Attitude(quaternionWithScreenRotation, 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 };
-    }
 }
 
 export default new Vps();