@wemap/providers 6.0.2 → 6.1.0

package/package.json

@@ -8,6 +8,7 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
+    "@wemap/camera": "^6.1.0",
     "@wemap/geo": "^6.0.0",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^6.0.0",
@@ -39,6 +40,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "6.0.2",
-  "gitHead": "8851e7c4537556e51a3f0c52de9fc80d5e37ad73"
+  "version": "6.1.0",
+  "gitHead": "367774b6d8cbfa864886d9cc3344244c7da20639"
 }

package/src/Providers.js

@@ -32,6 +32,8 @@ export { default as GnssWifi } from './providers/position/absolute/GnssWifi.js';
 export { default as Ip } from './providers/position/absolute/Ip.js';
 export { default as AbsolutePosition } from './providers/position/absolute/AbsolutePosition.js';
 
+export { default as VisionRelocalization } from './providers/vision/VisionRelocalization.js';
+
 export { default as Barcode } from './providers/others/Barcode.js';
 export { default as CameraNative } from './providers/others/CameraNative.js';
 export { default as CameraProjectionMatrix } from './providers/others/CameraProjectionMatrix.js';

package/src/ProvidersOptions.js

@@ -7,10 +7,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}
@@ -23,7 +31,11 @@ const ProvidersOptions = {
 
     stepdetectionlocker: true,
 
-    smoother: true
+    smoother: true,
+
+    get hasVps() {
+        return this.optionalProviders.includes('VisionRelocalization');
+    }
 };
 
 export default ProvidersOptions;

package/src/providers/Provider.js

@@ -123,9 +123,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}

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

@@ -7,6 +7,8 @@ import ProviderEvent from '../../../events/ProviderEvent.js';
 import MapMatchingHandler from '../../../mapmatching/MapMatchingHandler.js';
 import GnssWifi from './GnssWifi.js';
 import { default as GeoRelativePositionProvider } from '../relative/GeoRelativePosition.js';
+import ProvidersOptions from '../../../ProvidersOptions.js';
+import VisionRelocalization from '../../vision/VisionRelocalization.js';
 
 class AbsolutePosition extends Provider {
 
@@ -65,13 +67,29 @@ class AbsolutePosition extends Provider {
                 // do nothing
             });
 
-        this._gnssWifiProviderId = GnssWifi.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.addEventListener(events => {
+                for (const providerEvent of events) {
+                    if (providerEvent.dataType === EventType.AbsolutePosition) {
+                        this._onAbsolutePosition(providerEvent);
+                        VisionRelocalization.removeEventListener(vpsProviderId);
+                        return;
+                    }
+                }
+            });
+
+        } else {
+
+            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._mapMatchingHandlerId = MapMatchingHandler.addEventListener();
     }

package/src/providers/vision/VisionRelocalization.js

@@ -0,0 +1,272 @@
+/* eslint-disable max-statements */
+import { SharedCameras, CameraUtils, Camera } from '@wemap/camera';
+import { Attitude, Level, UserPosition } from '@wemap/geo';
+import Logger from '@wemap/logger';
+import { deg2rad, Quaternion } from '@wemap/maths';
+import { TimeUtils } from '../../../../utils/index.js';
+
+import EventType from '../../events/EventType.js';
+import ProviderEvent from '../../events/ProviderEvent.js';
+import Provider from '../Provider.js';
+import ProviderState from '../ProviderState.js';
+
+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 = TimeUtils.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 = TimeUtils.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 = TimeUtils.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 };
+    }
+}
+
+export default new VisionRelocalization();