@wemap/providers 7.5.0 → 8.0.0

package/index.js

@@ -5,6 +5,8 @@ export * as Providers from './src/Providers.js';
 export { default as ProvidersInterface } from './src/ProvidersInterface.js';
 export { default as ProvidersOptions } from './src/ProvidersOptions.js';
 
+export { default as MapMatchingHandler } from './src/mapmatching/MapMatchingHandler.js';
+
 export { default as PositionSmoother } from './src/smoothers/PositionSmoother.js';
 export { default as AttitudeSmoother } from './src/smoothers/AttitudeSmoother.js';
 

package/package.json

@@ -9,12 +9,12 @@
   ],
   "dependencies": {
     "@wemap/camera": "^7.0.0",
-    "@wemap/geo": "^7.5.0",
+    "@wemap/geo": "^8.0.0-alpha.0",
     "@wemap/geomagnetism": "^0.1.1",
     "@wemap/logger": "^7.0.0",
-    "@wemap/map": "^7.5.0",
-    "@wemap/maths": "^7.5.0",
-    "@wemap/osm": "^7.5.0",
+    "@wemap/map": "^8.0.0-alpha.0",
+    "@wemap/maths": "^8.0.0-alpha.0",
+    "@wemap/osm": "^8.0.0-alpha.0",
     "@wemap/utils": "^7.0.0"
   },
   "description": "A package using different geoloc systems",
@@ -41,6 +41,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "7.5.0",
-  "gitHead": "a72fe36a5b1444444fa263c51b4d9eaf7284f824"
+  "version": "8.0.0",
+  "gitHead": "d22587d4aa616ff930742d34b6b14803863475e4"
 }

package/src/Providers.js

@@ -29,6 +29,7 @@ export { default as GeoRelativePositionFromArCore } from './providers/position/r
 export { default as GeoRelativePosition } from './providers/position/relative/GeoRelativePosition.js';
 
 export { default as GnssWifi } from './providers/position/absolute/GnssWifi.js';
+export { default as PoleStar } from './providers/position/absolute/PoleStar.js';
 export { default as Ip } from './providers/position/absolute/Ip.js';
 export { default as AbsolutePosition } from './providers/position/absolute/AbsolutePosition.js';
 

package/src/errors/MissingPoleStarError.js

@@ -0,0 +1,10 @@
+class MissingPoleStarError extends Error {
+
+    static DEFAULT_MESSAGE = 'PoleStar is missing';
+
+    constructor(message) {
+        super(message || MissingPoleStarError.DEFAULT_MESSAGE);
+    }
+}
+
+export default MissingPoleStarError;

package/src/mapmatching/MapMatchingHandler.js

@@ -23,19 +23,19 @@ import ProvidersOptions from '../ProvidersOptions.js';
 class MapMatchingHandler extends Provider {
 
     /** @type {number} in radians */
-    static MM_MAX_ANGLE = deg2rad(30);
+    static DEFAULT_MM_MAX_ANGLE = deg2rad(30);
 
     /** @type {number} in meters */
-    static MM_MAX_DIST = 30;
+    static DEFAULT_MM_MAX_DIST = 30;
 
     /** @type {number} in meters */
-    static MM_MIN_DIST = 0;
+    static DEFAULT_MM_MIN_DIST = 0;
 
     /** @type {boolean} */
-    static ORIENTATION_MATCHING = true;
+    static DEFAULT_USE_ITINERARY_START_AS_POSITION = false;
 
     /** @type {boolean} */
-    static USE_ITINERARY_START_AS_POSITION = true;
+    static ORIENTATION_MATCHING = true;
 
     /** @type {number} in meters */
     static MM_HUGE_JUMP_DISTANCE = 3;
@@ -84,9 +84,10 @@ class MapMatchingHandler extends Provider {
         super();
 
         this._mapMatching = new MapMatching();
-        this._mapMatching.maxDistance = MapMatchingHandler.MM_MAX_DIST;
-        this._mapMatching.maxAngleBearing = MapMatchingHandler.MM_MAX_ANGLE;
-        this._mapMatchingMinDistance = MapMatchingHandler.MM_MIN_DIST;
+        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;
     }
 
     /**
@@ -187,7 +188,7 @@ class MapMatchingHandler extends Provider {
      */
     _notifyPositionFromItineraryInput(itinerary) {
 
-        if (!MapMatchingHandler.USE_ITINERARY_START_AS_POSITION || itinerary.start) {
+        if (!this._useItineraryStartAsPosition || itinerary.start) {
             return;
         }
 
@@ -508,6 +509,14 @@ class MapMatchingHandler extends Provider {
     set maxAngleBearing(maxAngleBearing) {
         this._mapMatching.maxAngleBearing = maxAngleBearing;
     }
+
+    get useItineraryStartAsPosition() {
+        return this._useItineraryStartAsPosition;
+    }
+
+    set useItineraryStartAsPosition(useItineraryStartAsPosition) {
+        this._useItineraryStartAsPosition = useItineraryStartAsPosition;
+    }
 }
 
 export default new MapMatchingHandler();

package/src/providers/Provider.js

@@ -119,6 +119,17 @@ class Provider {
         return typeof window !== 'undefined' ? (window.__nativeProviders || null) : null;
     }
 
+    get nativeJsInterface() {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+        if (!window.__nativeJsProviders) {
+            window.__nativeJsProviders = {};
+        }
+        return window.__nativeJsProviders;
+    }
+
+
     get useCameraNatively() {
         return false;
     }
@@ -137,7 +148,7 @@ class Provider {
      * @param {Boolean} startIfNecessary
      * @returns {Number}
      */
-    addEventListener(onEvents = () => {}, onError = () => {}, startIfNecessary = true) {
+    addEventListener(onEvents = () => { }, onError = () => { }, startIfNecessary = true) {
         const id = ++Provider._callbackUniqueId;
 
         /**
@@ -186,7 +197,7 @@ class Provider {
                 this.notifyError(e);
             })
             // notifyError can throw an error if onStop is not defined
-            .catch(() => {});
+            .catch(() => { });
 
         return id;
     }
@@ -239,7 +250,7 @@ class Provider {
      * @param {Function} onStopped
      * @returns {Number}
      */
-    addMonitoringListener(onStarted = () => {}, onStopped = () => {}) {
+    addMonitoringListener(onStarted = () => { }, onStopped = () => { }) {
         const id = ++this.constructor._callbackUniqueId;
         this._monitoringCallbacks.push({
             id,

package/src/providers/attitude/EkfAttitude.js

@@ -70,7 +70,7 @@ class EkfAttitude {
                 [H[2], M[2], accNormalized[2]]
             ];
 
-            this.quaternion = Quaternion.fromMatrix3(R);
+            this.quaternion = Quaternion.fromMatrix3Matlab(R);
 
         } else {
 
@@ -137,8 +137,8 @@ class EkfAttitude {
             const yc = Vector3.cross(accNormalized, magNormalized);
             const ycNormalized = Vector3.normalize(yc);
 
-            const dzYc = Vector3.subtract(ycNormalized, Quaternion.rotate(qAPriori, this.cRef));
-            const dzAcc = Vector3.subtract(accNormalized, Quaternion.rotate(qAPriori, this.accRef));
+            const dzYc = Vector3.subtract(ycNormalized, Quaternion.rotateMatlab(qAPriori, this.cRef));
+            const dzAcc = Vector3.subtract(accNormalized, Quaternion.rotateMatlab(qAPriori, this.accRef));
             dz = Vector.concat(dzYc, dzAcc);
 
             const HYc = this.jacobianES(qAPriori, this.cRef);
@@ -162,7 +162,7 @@ class EkfAttitude {
                 )
             );
         } else {
-            dz = Vector3.subtract(accNormalized, Quaternion.rotate(qAPriori, this.accRef));
+            dz = Vector3.subtract(accNormalized, Quaternion.rotateMatlab(qAPriori, this.accRef));
             H = this.jacobianES(qAPriori, this.accRef);
             const R = this.noises.relative.accelerometer;
 

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

@@ -0,0 +1,112 @@
+/* eslint-disable no-bitwise */
+
+import { Level, UserPosition } from '@wemap/geo';
+import { TimeUtils } from '@wemap/utils';
+
+import Provider from '../../Provider.js';
+import EventType from '../../../events/EventType.js';
+import MissingPoleStarError from '../../../errors/MissingPoleStarError.js';
+import MissingNativeInterfaceError from '../../../errors/MissingNativeInterfaceError.js';
+import Constants from '../../Constants.js';
+
+class PoleStar extends Provider {
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'PoleStar';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    constructor() {
+        super();
+        this.addMethodsToNativeJsProvider();
+    }
+
+    /**
+     * @param {string} apiKey
+     */
+    setApiKey(apiKey) {
+        this.nativeProvider.setApiKey(apiKey);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.nativeProvider.start();
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        this.nativeProvider.stop();
+    }
+
+    /** @type {?{setApiKey : (key: String) => {}, start: () => {}, stop: () => {}, checkAvailability: () => boolean }} */
+    get nativeProvider() {
+
+        if (!this.nativeInterface) {
+            throw new MissingNativeInterfaceError();
+        }
+
+        const nativeProvider = this.nativeInterface.getPoleStarProvider();
+        if (!nativeProvider) {
+            throw new MissingPoleStarError();
+        }
+
+        return nativeProvider;
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return new Promise((resolve) => {
+            this.nativeProvider.checkAvailability();
+            resolve();
+        });
+    }
+
+    addMethodsToNativeJsProvider() {
+
+        if (!this.nativeJsInterface) {
+            return;
+        }
+
+        this.nativeJsInterface.polestar = {
+            callbackError: errorMessage => this.notifyError(new Error(errorMessage)),
+            callbackPosition: jsonString => {
+
+                const json = JSON.parse(jsonString);
+
+                const timestamp = TimeUtils.unixTimestampToPreciseTime(json.time) / 1e3;
+
+                const position = new UserPosition(
+                    json.lat,
+                    json.lng,
+                    Constants.DEFAULT_ALTITUDE,
+                    new Level(json.alt / 5),
+                    timestamp,
+                    json.accuracy,
+                    json.bearing,
+                    this.pname);
+
+                this.notify(this.createEvent(
+                    EventType.AbsolutePosition, position
+                ));
+            }
+        };
+
+    }
+}
+
+export default new PoleStar();

package/src/providers/steps/StepDetector.js

@@ -98,7 +98,7 @@ class StepDetector extends Provider {
 
     // Linear acceleration in ENU
     static computeLinearAcceleration(quaternion, acc) {
-        const linearAcc = Quaternion.rotate(Quaternion.inverse(quaternion), acc);
+        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
         linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
         return linearAcc;
     }

package/src/providers/vision/Vps.js

@@ -12,9 +12,6 @@ import ProviderState from '../ProviderState.js';
 
 class Vps 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} */
@@ -26,6 +23,10 @@ class Vps extends Provider {
     /** @type {Camera} */
     _camera = null;
 
+    /** @type {?string} */
+    _endpoint = null;
+    // _endpoint = 'https://vps.maaap.it/wemap';
+
     /**
     * @override
     */
@@ -76,6 +77,12 @@ class Vps extends Provider {
         this._camera = null;
     }
 
+    /**
+     * @param {string} endpoint
+     */
+    setEndpoint(endpoint) {
+        this._endpoint = endpoint;
+    }
 
     _onCameraDetected = ({ camera }) => {
         if (this._camera) {
@@ -114,6 +121,13 @@ class Vps extends Provider {
 
         this._serverError = false;
 
+        if (!this._endpoint) {
+            this._serverError = true;
+            Logger.error('VPS endpoint has not been set before calling start()');
+            this.stop();
+            return;
+        }
+
         while (this.state !== ProviderState.STOPPPED) {
 
             if (this.lastEvent) {
@@ -126,7 +140,7 @@ class Vps extends Provider {
                 break;
             }
 
-            const url = Vps.SERVICE_URL + Vps.MAP_ID;
+            // const url = Vps.SERVICE_URL + Vps.MAP_ID;
 
             // 1. Prepare the request
             if (!this._camera || this._camera.state !== Camera.State.STARTED) {
@@ -139,7 +153,7 @@ class Vps extends Provider {
             }
 
             // 2. Send the request
-            const serverResponse = await fetch(url, {
+            const serverResponse = await fetch(this._endpoint, {
                 method: 'POST',
                 body: JSON.stringify(payload),
                 headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' }
@@ -150,7 +164,7 @@ class Vps extends Provider {
             }
 
             // 3. Parse the response
-            const events = await this._parseResponse(serverResponse, url, payload.time);
+            const events = await this._parseResponse(serverResponse, this._endpoint, payload.time);
             if (this._serverError || this.state === ProviderState.STOPPPED) {
                 break;
             }
@@ -245,6 +259,8 @@ class Vps extends Provider {
         quaternion[2] /= quaternionNorm;
         quaternion[3] /= quaternionNorm;
 
+        // TODO: Move camera to smartphone rotation here instead of server
+
         const quaternionWithScreenRotation = Quaternion.multiply(
             Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)), quaternion
         );