@wemap/providers 10.0.0-alpha.8 → 10.0.0

package/src/providers/steps/StepDetectorMinMaxPeaks3.js

@@ -0,0 +1,109 @@
+import { Constants as GeoConstants } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+import AvailabilityHelper from '../../events/AvailabilityHelper.js';
+import EventType from '../../events/EventType.js';
+import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeFromInertial.js';
+import Accelerometer from '../imu/Accelerometer.js';
+import Gyroscope from '../imu/Gyroscope.js';
+import Provider from '../Provider.js';
+import StepDetectionMinMaxPeaks3 from './StepDetectionMinMaxPeaks3.js';
+
+
+class StepDetectorMinMaxPeaks3 extends Provider {
+
+    constructor() {
+        super();
+        this.stepDetector = new StepDetectionMinMaxPeaks3();
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'StepDetectorMinMaxPeaks3';
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return AvailabilityHelper.every([
+            Accelerometer.availability,
+            Gyroscope.availability,
+            RelativeAttitudeFromInertial.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.numOfSteps = 0;
+
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.angularRateEvent = events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.attitudeProviderId = RelativeAttitudeFromInertial.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+        RelativeAttitudeFromInertial.removeEventListener(this.attitudeProviderId);
+    }
+
+    onAccelerometerEvent(accelerationEvent) {
+
+        if (!this.attitudeEvent || !this.angularRateEvent) {
+            return;
+        }
+
+        const {
+            values: acceleration, timestamp
+        } = accelerationEvent.data;
+
+        /**
+         * Step Detection and Step Size Detection
+         */
+        const linearAcc = this.constructor.computeLinearAcceleration(
+            this.attitudeEvent.data.quaternion, acceleration);
+        const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
+
+        if (stepDetected) {
+            const size = this.stepDetector.lastStepSize;
+            this.numOfSteps++;
+            this.notify(this.createEvent(
+                EventType.Step, {
+                    size,
+                    number: this.numOfSteps
+                },
+                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
+            ));
+        }
+    }
+
+    // Linear acceleration in ENU
+    static computeLinearAcceleration(quaternion, acc) {
+        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
+        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
+        return linearAcc;
+    }
+
+}
+
+export default new StepDetectorMinMaxPeaks3();

package/src/providers/steps/StraightLineDetector.js

@@ -1,3 +1,4 @@
+import AvailabilityHelper from '../../events/AvailabilityHelper.js';
 import Provider from '../Provider.js';
 import StepDetector from './StepDetector.js';
 import TurnDectector from '../attitude/TurnDectector.js';
@@ -27,6 +28,16 @@ class StraightLineDetector extends Provider {
         return 'StraightLineDetector';
     }
 
+    /**
+     * @override
+     */
+    get _availability() {
+        return AvailabilityHelper.every([
+            TurnDectector.availability,
+            StepDetector.availability
+        ]);
+    }
+
     /**
      * @override
      */

package/src/providers/vision/ArCore.js

@@ -162,11 +162,11 @@ class ArCore extends Provider {
             const nativeProvider = this.nativeProvider;
 
             if (!nativeProvider.checkAvailability()) {
-                return Promise.reject(new MissingArCoreError());
+                return Promise.resolve(new MissingArCoreError());
             }
 
         } catch (e) {
-            return Promise.reject(e);
+            return Promise.resolve(e);
         }
 
         return Promise.resolve();

package/src/providers/vision/vps/ImageRelocalization.js

@@ -35,7 +35,7 @@ class ImageRelocalization {
      * @param {{intrinsic:number[], distortions:number[]}} calibration
      * @param {{position: Coordinates,  attitude?: Attitude}} coarsePose
      * @param {Record<string, string> | null} customHeaders
-     * @returns {{position: UserPosition, attitude: Attitude}|null}
+     * @returns {Promise<{position: UserPosition, attitude: Attitude}|null>}
      */
     static async relocalize(endpointUrl, imageCanvas, calibration = null,
         coarsePose = null, customHeaders = null) {

package/src/providers/vision/vps/RelativeRotationCalc.js

@@ -0,0 +1,60 @@
+import { Attitude } from '@wemap/geo';
+import Logger from '@wemap/logger';
+import RelativeAttitudeFromBrowser from '../../attitude/relative/RelativeAttitudeFromBrowser.js';
+
+export default class RelativeRotationCalc {
+
+    _isRunning = false;
+    _dataOnStart = null;
+
+    tickStart() {
+        this._dataOnStart = null;
+
+        if (this._isRunning) {
+            // Do not start the provider if tickStart() has already been called without tickEnd()
+            return;
+        }
+
+        this._isRunning = true;
+
+        this._providerId = RelativeAttitudeFromBrowser.addEventListener(events => {
+            if (!this._dataOnStart) {
+                this._dataOnStart = events[0].data;
+            }
+        });
+    }
+
+    /**
+     * @returns {Attitude|null}
+     */
+    tickEnd() {
+        if (!this._isRunning) {
+            Logger.warn('You have to call tickStart before tickEnd');
+            return null;
+        }
+
+        this._internalStop();
+
+        if (!this._dataOnStart) {
+            Logger.warn('Delay was too short between tickStart and tickEnd '
+                + 'or RelativeAttitude cannot be retrieved.');
+            return null;
+        }
+
+        const dataOnEnd = RelativeAttitudeFromBrowser.lastEvent.data;
+        return Attitude.diff(this._dataOnStart, dataOnEnd);
+    }
+
+    _internalStop() {
+        RelativeAttitudeFromBrowser.removeEventListener(this._providerId);
+        this._providerId = null;
+        this._isRunning = false;
+    }
+
+    release() {
+        if (this._isRunning) {
+            this._internalStop();
+        }
+    }
+
+}

package/src/providers/vision/vps/Vps.js

@@ -1,3 +1,4 @@
+/* eslint-disable complexity */
 /* eslint-disable max-statements */
 import { SharedCameras, Camera } from '@wemap/camera';
 import { Attitude } from '@wemap/geo';
@@ -12,6 +13,7 @@ import ProviderState from '../../ProviderState.js';
 import ImageRelocalization from './ImageRelocalization.js';
 import AbsolutePosition from '../../position/absolute/AbsolutePosition.js';
 import AbsoluteAttitude from '../../attitude/absolute/AbsoluteAttitude.js';
+import RelativeRotationCalc from './RelativeRotationCalc.js';
 
 class Vps extends Provider {
 
@@ -21,6 +23,8 @@ class Vps extends Provider {
 
     static DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST = 200;
 
+    static DEFAULT_USE_COARSE_POSE = true;
+
     static CAMERA_TO_SMARTPHONE_ROT = Quaternion.fromAxisAngle([1, 0, 0], Math.PI);
 
     /** @type {boolean} */
@@ -44,6 +48,9 @@ class Vps extends Provider {
     /** @type {number} */
     _waitTimeMinInclinationForRequest = Vps.DEFAULT_WAIT_TIME_MIN_INCLINATION_FOR_REQUEST;
 
+    /** @type {number} */
+    _useCoarsePose = Vps.DEFAULT_USE_COARSE_POSE;
+
     /**
     * @override
     */
@@ -70,11 +77,17 @@ class Vps extends Provider {
      */
     start() {
 
-        // 1. Add listeners on shared cameras to detect new cameras
+        // 1. Inclination
+        this._inclinationProviderId = Inclination.addEventListener();
+
+        // 2. Relative Rotation Calc
+        this._relativeRotationCalc = new RelativeRotationCalc();
+
+        // 3. 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
+        // 4. 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'
@@ -82,21 +95,21 @@ class Vps extends Provider {
             }
             this._useCamera(SharedCameras.list[0].camera);
         }
-
-        // 3. Inclination
-        this._inclinationProviderId = Inclination.addEventListener();
     }
 
     /**
      * @override
      */
     stop() {
+
+        Inclination.removeEventListener(this._inclinationProviderId);
+
+        this._relativeRotationCalc.release();
+
         SharedCameras.off('added', this._onCameraDetected);
         SharedCameras.off('removed', this._onCameraRemoved);
 
         this._camera = null;
-
-        Inclination.removeEventListener(this._inclinationProviderId);
     }
 
     _onCameraDetected = ({ camera }) => {
@@ -166,9 +179,10 @@ class Vps extends Provider {
             }
 
             // 3. Get current image from camera and relocalize it.
+            this._relativeRotationCalc.tickStart();
             const image = await this._camera.currentImage;
             let coarsePose = null;
-            if (AbsolutePosition.lastEvent || AbsoluteAttitude.lastEvent) {
+            if (this._useCoarsePose && (AbsolutePosition.lastEvent || AbsoluteAttitude.lastEvent)) {
                 coarsePose = {};
                 if (AbsolutePosition.lastEvent) {
                     coarsePose.position = AbsolutePosition.lastEvent.data;
@@ -194,7 +208,17 @@ class Vps extends Provider {
                 Quaternion.fromAxisAngle([0, 0, 1], deg2rad(window.orientation || 0)),
                 enuToSmartphoneRot
             );
-            const attitude = new Attitude(deviceQuaternion, res.attitude.time, res.attitude.accuracy);
+
+            const diffAttitude = this._relativeRotationCalc.tickEnd() || new Attitude([1, 0, 0, 0]);
+            const deviceQuaternionWithRelOffset = Quaternion.multiply(
+                deviceQuaternion,
+                diffAttitude.quaternion
+            );
+            const attitude = new Attitude(
+                deviceQuaternionWithRelOffset,
+                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,
@@ -247,6 +271,14 @@ class Vps extends Provider {
     set waitTimeMinInclinationForRequest(waitTimeMinInclinationForRequest) {
         this._waitTimeMinInclinationForRequest = waitTimeMinInclinationForRequest;
     }
+
+    get useCoarsePose() {
+        return this._useCoarsePose;
+    }
+
+    set useCoarsePose(useCoarsePose) {
+        this._useCoarsePose = useCoarsePose;
+    }
 }
 
 export default new Vps();