@wemap/providers 3.3.0 → 4.0.0

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

@@ -39,7 +39,7 @@ class IpProvider extends Provider {
                     return;
                 }
 
-                const timestamp = TimeUtils.preciseTime / 1e3;
+                const timestamp = TimeUtils.preciseTime() / 1e3;
 
                 const latLngStr = response.loc.split(',');
                 const position = new UserPosition(
@@ -50,9 +50,7 @@ class IpProvider extends Provider {
                     timestamp
                 );
 
-                this.notify(this.createEvent(
-                    EventType.AbsolutePosition, position, timestamp
-                ));
+                this.notify(this.createEvent(EventType.AbsolutePosition, position));
             });
     }
 

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

@@ -95,7 +95,7 @@ class ArCoreProvider extends Provider {
 
         const events = [];
 
-        const time = TimeUtils.preciseTime / 1e3;
+        const time = TimeUtils.preciseTime() / 1e3;
 
         if (ref & Payload.Pose.ref) {
 

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

@@ -84,7 +84,6 @@ class GeoRelativePositionFromArCoreProvider extends Provider {
         this.notify(this.createEvent(
             EventType.GeoRelativePosition,
             position,
-            relativePosition.time,
             [relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent]
         ));
     }

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

@@ -72,7 +72,6 @@ class PdrProvider extends Provider {
             return;
         }
 
-        const timestamp = stepEvent.timestamp;
         const stepSize = stepEvent.data.size;
 
         /**
@@ -106,6 +105,7 @@ class PdrProvider extends Provider {
          */
         const deviceDirectionAccuracy = deviceAttitude.accuracy + this.misalignmentError;
         const accuracy = (stepSize / 2) * Math.sin(deviceDirectionAccuracy / 2);
+        const timestamp = deviceAttitude.time;
 
         /**
          * Relative position is defined in ENU frame
@@ -122,7 +122,6 @@ class PdrProvider extends Provider {
         this.notify(this.createEvent(
             EventType.GeoRelativePosition,
             position,
-            timestamp,
             [stepEvent, this.attitudeEvent]
         ));
     }

package/src/providers/steps/StepDetectionProvider.js

@@ -71,15 +71,16 @@ class StepDetectionProvider extends Provider {
             return;
         }
 
-        const { timestamp } = accelerationEvent;
-        const acceleration = accelerationEvent.data;
+        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);
+        const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
 
         if (stepDetected) {
             const size = this.stepDetector.lastStepSize;
@@ -89,7 +90,6 @@ class StepDetectionProvider extends Provider {
                     size,
                     number: this.numOfSteps
                 },
-                timestamp,
                 [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
             ));
         }

package/src/smoothers/AttitudeSmoother.js

@@ -0,0 +1,100 @@
+/* eslint-disable max-statements */
+import { Attitude } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+class AttitudeSmoother {
+
+    // Generated attitude by second
+    static DEFAULT_FREQUENCY = 60;
+
+    // In radians/s
+    static MAX_ROTATE_SPEED = 0.5;
+
+    /** @type {Attitude[]} */
+    queue;
+
+    /**
+     * @param {Function} callback
+     * @param {Number} frequency in Hz
+     */
+    constructor(callback, frequency = this.constructor.DEFAULT_FREQUENCY) {
+        this.callback = callback;
+        this.queue = [];
+        this.frequency = frequency;
+    }
+
+    /**
+     * @param {Attitude} attitude
+     */
+    feed(newAttitude) {
+
+        if (!(newAttitude instanceof Attitude)) {
+            throw new TypeError('newAttitude is not instance of Attitude');
+        }
+
+        if (newAttitude.time === null) {
+            throw new Error('newAttitude does not have time property');
+        }
+
+        let previousAttitude;
+        if (this.queue.length !== 0) {
+            previousAttitude = this.queue[0];
+            this.queue = [];
+        } else {
+            previousAttitude = this.previousAttitude;
+        }
+
+        if (previousAttitude) {
+            const previousQuat = previousAttitude.quaternion;
+            const nextQuat = newAttitude.quaternion;
+            const quatAngle = Quaternion.distance(previousQuat, nextQuat);
+
+            /** max rotation for the next value (radians) */
+            const maxRotAtEpoch = this.constructor.MAX_ROTATE_SPEED / this.frequency;
+
+            if (quatAngle > maxRotAtEpoch) {
+                for (let i = 1; i <= Math.floor(quatAngle / maxRotAtEpoch); i++) {
+
+                    // coef is contained in [0; 1[
+                    const coef = i * maxRotAtEpoch / quatAngle;
+
+                    const smoothedAttitude = new Attitude(
+                        Quaternion.slerp(previousQuat, nextQuat, coef),
+                        newAttitude.time + i / this.frequency,
+                        Math.max(
+                            previousAttitude.accuracy + (newAttitude.accuracy - previousAttitude.accuracy) * coef,
+                            0
+                        )
+                    );
+                    this.queue.push(smoothedAttitude);
+                }
+
+            }
+        }
+
+        this.queue.push(newAttitude.clone());
+
+        this.previousAttitude = newAttitude;
+
+        if (!this.timeoutNotify) {
+            this._notifyNext();
+        }
+    }
+
+    _notifyNext = () => {
+        this.callback(this.queue.shift());
+        if (this.queue.length !== 0) {
+            this.timeoutNotify = setTimeout(this._notifyNext, 1e3 / this.frequency);
+        } else {
+            delete this.timeoutNotify;
+        }
+    }
+
+    clear() {
+        clearTimeout(this.timeoutNotify);
+        delete this.timeoutNotify;
+        this.queue = [];
+    }
+}
+
+export default AttitudeSmoother;