@wemap/providers 4.0.0 → 4.0.3

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

@@ -10,28 +10,26 @@ import EventType from '../../../events/EventType.js';
 import MissingArCoreError from '../../../errors/MissingArCoreError.js';
 import MissingNativeInterfaceError from '../../../errors/MissingNativeInterfaceError.js';
 import ProviderState from '../../ProviderState.js';
-
-
-const Payload = {
-    Pose: {
-        ref: 2 ** 0,
-        size: 7
-    },
-    Barcode: {
-        ref: 2 ** 1,
-        size: 1
-    },
-    ProjMat: {
-        ref: 2 ** 2,
-        size: 16
-    },
-    ImageRef: {
-        ref: 2 ** 3,
-        size: 1
-    }
-};
-
-class ArCoreProvider extends Provider {
+class ArCore extends Provider {
+
+    static Payload = {
+        Pose: {
+            ref: 2 ** 0,
+            size: 7
+        },
+        Barcode: {
+            ref: 2 ** 1,
+            size: 1
+        },
+        ProjMat: {
+            ref: 2 ** 2,
+            size: 16
+        },
+        ImageRef: {
+            ref: 2 ** 3,
+            size: 1
+        }
+    };
 
     /**
      * default relative attitude drift in rad.second-1
@@ -97,7 +95,7 @@ class ArCoreProvider extends Provider {
 
         const time = TimeUtils.preciseTime() / 1e3;
 
-        if (ref & Payload.Pose.ref) {
+        if (ref & ArCore.Payload.Pose.ref) {
 
             const attitude = new Attitude(
                 payload.slice(bufferIndex, bufferIndex + 4),
@@ -117,18 +115,18 @@ class ArCoreProvider extends Provider {
             this.previousPosition = newPosition;
             events.push(this.createEvent(EventType.RelativePosition, position));
 
-            bufferIndex += Payload.Pose.size;
+            bufferIndex += ArCore.Payload.Pose.size;
         }
 
-        if (ref & Payload.Barcode.ref) {
+        if (ref & ArCore.Payload.Barcode.ref) {
             events.push(this.createEvent(EventType.Barcode, payload[bufferIndex]));
-            bufferIndex += Payload.Barcode.size;
+            bufferIndex += ArCore.Payload.Barcode.size;
         }
 
-        if (ref & Payload.ProjMat.ref) {
-            const projMatrix = payload.slice(bufferIndex, bufferIndex + Payload.ProjMat.size);
+        if (ref & ArCore.Payload.ProjMat.ref) {
+            const projMatrix = payload.slice(bufferIndex, bufferIndex + ArCore.Payload.ProjMat.size);
             events.push(this.createEvent(EventType.CameraProjectionMatrix, projMatrix));
-            bufferIndex += Payload.ProjMat.size;
+            bufferIndex += ArCore.Payload.ProjMat.size;
         }
 
         if (events.length !== 0) {
@@ -197,4 +195,4 @@ class ArCoreProvider extends Provider {
     }
 }
 
-export default ArCoreProvider;
+export default new ArCore();

package/src/providers/position/relative/{GeoRelativePositionProvider.js → GeoRelativePosition.js}

@@ -1,12 +1,12 @@
 import { PromiseUtils } from '@wemap/utils';
 
-import MetaProvider from '../../MetaProvider.js';
+import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
-import {
-    Pdr, GeoRelativePositionFromArCore
-} from '../../../Providers.js';
+import GeoRelativePositionFromArCore from './GeoRelativePositionFromArCore.js';
+import Pdr from './Pdr.js';
 
-class GeoRelativePositionProvider extends MetaProvider {
+
+class GeoRelativePosition extends Provider {
 
     /**
     * @override
@@ -65,4 +65,4 @@ class GeoRelativePositionProvider extends MetaProvider {
     }
 }
 
-export default GeoRelativePositionProvider;
+export default new GeoRelativePosition();

package/src/providers/position/relative/{GeoRelativePositionFromArCoreProvider.js → GeoRelativePositionFromArCore.js}

@@ -1,12 +1,11 @@
 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, AbsoluteAttitude
-} from '../../../Providers.js';
+import ArCore from './ArCore.js';
 
-class GeoRelativePositionFromArCoreProvider extends Provider {
+class GeoRelativePositionFromArCore extends Provider {
 
     /**
      * @override
@@ -89,4 +88,4 @@ class GeoRelativePositionFromArCoreProvider extends Provider {
     }
 }
 
-export default GeoRelativePositionFromArCoreProvider;
+export default new GeoRelativePositionFromArCore();

package/src/providers/position/relative/{PdrProvider.js → Pdr.js}

@@ -3,11 +3,11 @@ import { deg2rad } from '@wemap/maths';
 
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
-import {
-    StepDetection, AbsoluteAttitude
-} from '../../../Providers.js';
+import StepDetector from '../../steps/StepDetector.js';
+import AbsoluteAttitude from '../../attitude/absolute/AbsoluteAttitude.js';
 
-class PdrProvider extends Provider {
+
+class Pdr extends Provider {
 
     // https://ieeexplore.ieee.org/document/7346766
     misalignment = [1, 0, 0, 0];
@@ -32,7 +32,7 @@ class PdrProvider extends Provider {
      */
     get _availability() {
         return Promise.all([
-            StepDetection.availability,
+            StepDetector.availability,
             AbsoluteAttitude.availability
         ]);
     }
@@ -43,7 +43,7 @@ class PdrProvider extends Provider {
      */
     start() {
 
-        this.stepDetectionProviderId = StepDetection.addEventListener(
+        this.stepDetectionProviderId = StepDetector.addEventListener(
             events => this.onStepEvent(events[0]),
             error => this.notifyError(error)
         );
@@ -59,7 +59,7 @@ class PdrProvider extends Provider {
      * @override
      */
     stop() {
-        StepDetection.removeEventListener(this.stepDetectionProviderId);
+        StepDetector.removeEventListener(this.stepDetectionProviderId);
         AbsoluteAttitude.removeEventListener(this.absoluteAttitudeProviderId);
     }
 
@@ -128,4 +128,4 @@ class PdrProvider extends Provider {
 
 }
 
-export default PdrProvider;
+export default new Pdr();

package/src/providers/steps/StepDetectionLadetto.js

@@ -1,20 +1,19 @@
+class StepDetectionLadetto {
 
-// in seconds
-const MIN_TIME_BETWEEN_STEPS = 0.4;
-
-// in Hz
-const MAX_FRENQUENCY = 4;
-const MIN_FRENQUENCY = 1;
+    // in seconds
+    static MIN_TIME_BETWEEN_STEPS = 0.4;
 
-// in m.s-2
-const VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1;
+    // in Hz
+    static MAX_FRENQUENCY = 4;
+    static MIN_FRENQUENCY = 1;
 
+    // in m.s-2
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1;
 
-class StepDetectionLadetto {
 
     lastVerticalAcc = 0;
     maxAcceleration = 0;
-    lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+    lastStepTimestamp = -StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS;
 
     compute(timestamp, linearAcc) {
 
@@ -29,12 +28,12 @@ class StepDetectionLadetto {
             if (verticalAcc > this.maxAcceleration) {
                 this.maxAcceleration = verticalAcc;
             }
-        } else if (this.maxAcceleration > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && timeInterval > MIN_TIME_BETWEEN_STEPS) {
+        } else if (this.maxAcceleration > StepDetectionLadetto.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
+            && timeInterval > StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS) {
             this.maxAcceleration = 0;
 
             const diffTime = timestamp - this.lastStepTimestamp;
-            this.frequency = Math.min(Math.max((1 / diffTime), MIN_FRENQUENCY), MAX_FRENQUENCY);
+            this.frequency = Math.min(Math.max((1 / diffTime), StepDetectionLadetto.MIN_FRENQUENCY), StepDetectionLadetto.MAX_FRENQUENCY);
 
             stepDetected = true;
             this.lastStepTimestamp = timestamp;

package/src/providers/steps/StepDetectionMinMaxPeaks.js

@@ -1,38 +1,40 @@
 
-// in seconds
-const WINDOW_TIME = 0.3;
 
-// in seconds
-const MIN_TIME_BETWEEN_STEPS = 0.4;
+class StepDetectionMinMaxPeaks {
 
-// in Hz
-const MAX_FRENQUENCY = 4;
-const MIN_FRENQUENCY = 1;
 
-// in m.s-2
-const VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1.5;
-const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -1;
+    // in seconds
+    static WINDOW_TIME = 0.3;
 
+    // in seconds
+    static MIN_TIME_BETWEEN_STEPS = 0.4;
+
+    // in Hz
+    static MAX_FRENQUENCY = 4;
+    static MIN_FRENQUENCY = 1;
+
+    // in m.s-2
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1.5;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -1;
 
-class StepDetectionMinMaxPeaks {
 
     constructor() {
         this.slidingWindow = [];
 
-        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+        this.lastStepTimestamp = -StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS;
     }
 
 
     compute(timestamp, linearAcc) {
 
-        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
+        if (this.lastStepTimestamp && this.lastStepTimestamp + StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS > timestamp) {
             return false;
         }
 
         let maxValue = Number.MIN_SAFE_INTEGER;
         let minValue = Number.MAX_SAFE_INTEGER;
 
-        const windowTime = WINDOW_TIME;
+        const windowTime = StepDetectionMinMaxPeaks.WINDOW_TIME;
         this.slidingWindow.forEach(function(item, index, object) {
             if (item.timestamp < timestamp - windowTime) {
                 object.splice(index, 1);
@@ -47,11 +49,11 @@ class StepDetectionMinMaxPeaks {
         });
 
 
-        if (maxValue > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && minValue < VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+        if (maxValue > StepDetectionMinMaxPeaks.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
+            && minValue < StepDetectionMinMaxPeaks.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
 
             const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
-            this.frequency = Math.min(Math.max((1 / timeInterval), MIN_FRENQUENCY), MAX_FRENQUENCY);
+            this.frequency = Math.min(Math.max((1 / timeInterval), StepDetectionMinMaxPeaks.MIN_FRENQUENCY), StepDetectionMinMaxPeaks.MAX_FRENQUENCY);
 
             this.lastStepTimestamp = timestamp;
             return true;

package/src/providers/steps/StepDetectionMinMaxPeaks2.js

@@ -1,25 +1,24 @@
+class StepDetectionMinMaxPeaks2 {
 
-// in seconds
-const WINDOW_TIME = 0.3;
-
-// in seconds
-const MIN_TIME_BETWEEN_STEPS = 0.4;
+    // in seconds
+    static WINDOW_TIME = 0.3;
 
-// in Hz
-const MAX_FRENQUENCY = 4;
-const MIN_FRENQUENCY = 1;
+    // in seconds
+    static MIN_TIME_BETWEEN_STEPS = 0.4;
 
-// in m.s-2
-const VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75;
-const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3;
+    // in Hz
+    static MAX_FRENQUENCY = 4;
+    static MIN_FRENQUENCY = 1;
 
+    // in m.s-2
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3;
 
-class StepDetectionMinMaxPeaks2 {
 
     constructor() {
         this.slidingWindow = [];
 
-        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+        this.lastStepTimestamp = -StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS;
         this.previousVerticalAcc = 0;
         this.influence = 0.2;
     }
@@ -35,7 +34,7 @@ class StepDetectionMinMaxPeaks2 {
             return false;
         }
 
-        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
+        if (this.lastStepTimestamp && this.lastStepTimestamp + StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS > timestamp) {
             return false;
         }
 
@@ -43,7 +42,7 @@ class StepDetectionMinMaxPeaks2 {
         let minValue = Number.MAX_SAFE_INTEGER;
 
         this.slidingWindow.forEach(function(item, index, object) {
-            if (item.timestamp < timestamp - WINDOW_TIME) {
+            if (item.timestamp < timestamp - StepDetectionMinMaxPeaks2.WINDOW_TIME) {
                 object.splice(index, 1);
             } else {
                 maxValue = Math.max(item.verticalAcc, maxValue);
@@ -56,11 +55,11 @@ class StepDetectionMinMaxPeaks2 {
         });
 
 
-        if (maxValue > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && minValue < VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+        if (maxValue > StepDetectionMinMaxPeaks2.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
+            && minValue < StepDetectionMinMaxPeaks2.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
 
             const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
-            this.frequency = Math.min(Math.max((1 / timeInterval), MIN_FRENQUENCY), MAX_FRENQUENCY);
+            this.frequency = Math.min(Math.max((1 / timeInterval), StepDetectionMinMaxPeaks2.MIN_FRENQUENCY), StepDetectionMinMaxPeaks2.MAX_FRENQUENCY);
 
             this.lastStepTimestamp = timestamp;
             return true;

package/src/providers/steps/{StepDetectionProvider.js → StepDetector.js}

@@ -2,13 +2,14 @@ import { Constants as GeoConstants } from '@wemap/geo';
 import { Quaternion } from '@wemap/maths';
 
 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 StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2.js';
-import {
-    Accelerometer, Gyroscope, RelativeAttitudeFromInertial
-} from '../../Providers.js';
 
-class StepDetectionProvider extends Provider {
+
+class StepDetector extends Provider {
 
     constructor() {
         super();
@@ -19,7 +20,7 @@ class StepDetectionProvider extends Provider {
     * @override
     */
     static get pname() {
-        return 'StepDetection';
+        return 'StepDetector';
     }
 
     /**
@@ -86,7 +87,7 @@ class StepDetectionProvider extends Provider {
             const size = this.stepDetector.lastStepSize;
             this.numOfSteps++;
             this.notify(this.createEvent(
-                EventType.STEP, {
+                EventType.Step, {
                     size,
                     number: this.numOfSteps
                 },
@@ -103,4 +104,4 @@ class StepDetectionProvider extends Provider {
     }
 }
 
-export default StepDetectionProvider;
+export default new StepDetector();

package/src/providers/steps/StraightLineDetector.js

@@ -0,0 +1,80 @@
+import Provider from '../Provider.js';
+import StepDetector from './StepDetector.js';
+import TurnDectector from '../attitude/TurnDectector.js';
+import EventType from '../../events/EventType.js';
+
+class StraightLineDetector extends Provider {
+
+    /** @type {number} */
+    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 3;
+
+    /** @type {number?} */
+    _turnDetectorProviderId = null;
+
+    /** @type {number?} */
+    _stepDetectorProviderId = null;
+
+    /** @type {number} */
+    _countSteps = 0;
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'StraightLineDetector';
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this._turnDetectorProviderId = TurnDectector.addEventListener(this._onTurn);
+        this._stepDetectorProviderId = StepDetector.addEventListener(this._onStep);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        TurnDectector.removeEventListener(this._turnDetectorProviderId);
+        StepDetector.removeEventListener(this._stepDetectorProviderId);
+    }
+
+    _onTurn = (event) => {
+        if (this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
+
+            const fromEvents = [event];
+            if (StepDetector.lastEvent !== null) {
+                fromEvents.push(StepDetector.lastEvent);
+            }
+
+            this.notify(this.createEvent(EventType.StraightLine, false, fromEvents));
+
+        }
+        this._countSteps = 0;
+    }
+
+    _onStep = (event) => {
+        this._countSteps++;
+
+        if (this._countSteps === StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
+
+            const fromEvents = [event];
+            if (TurnDectector.lastEvent !== null) {
+                fromEvents.push(TurnDectector.lastEvent);
+            }
+            this.notify(this.createEvent(EventType.StraightLine, true, fromEvents));
+
+        }
+
+    }
+
+    /**
+     * @returns {boolean}
+     */
+    isStraight() {
+        return this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
+    }
+}
+
+export default new StraightLineDetector();