@wemap/providers 4.0.0 → 4.0.1

package/src/providers/position/absolute/{GnssWifiProvider.js → GnssWifi.js}

@@ -10,11 +10,6 @@ import GeolocationPermissionDeniedError from '../../../errors/GeolocationPermiss
 import GeolocationPositionUnavailableError from '../../../errors/GeolocationPositionUnavailableError.js';
 import Constants from '../../Constants.js';
 
-const POSITION_OPTIONS = {
-    enableHighAccuracy: true,
-    timeout: Infinity,
-    maximumAge: 0
-};
 
 /**
  * GnssWifiProvider is a provider based on navigator.geolocation.
@@ -22,7 +17,13 @@ const POSITION_OPTIONS = {
  *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
  *  "GnssWifi".
  */
-class GnssWifiProvider extends Provider {
+class GnssWifi extends Provider {
+
+    static POSITION_OPTIONS = {
+        enableHighAccuracy: true,
+        timeout: Infinity,
+        maximumAge: 0
+    };
 
     /**
     * @override
@@ -55,7 +56,7 @@ class GnssWifiProvider extends Provider {
         this.geoLocationId = navigator.geolocation.watchPosition(
             this.onNewPosition,
             this.onPositionError,
-            POSITION_OPTIONS
+            GnssWifi.POSITION_OPTIONS
         );
 
     }
@@ -122,4 +123,4 @@ class GnssWifiProvider extends Provider {
     };
 }
 
-export default GnssWifiProvider;
+export default new GnssWifi();

package/src/providers/position/absolute/{IpProvider.js → Ip.js}

@@ -11,7 +11,7 @@ import IpResolveServerError from '../../../errors/IpResolveServerError.js';
  *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
  *  "GnssWifi".
  */
-class IpProvider extends Provider {
+class Ip extends Provider {
 
     /**
      * @override
@@ -63,4 +63,4 @@ class IpProvider extends Provider {
 
 }
 
-export default IpProvider;
+export default new Ip();

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}

@@ -2,11 +2,11 @@ import { PromiseUtils } from '@wemap/utils';
 
 import MetaProvider from '../../MetaProvider.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 MetaProvider {
 
     /**
     * @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 StepDetection from '../../steps/StepDetection.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];
@@ -128,4 +128,4 @@ class PdrProvider extends Provider {
 
 }
 
-export default PdrProvider;
+export default new Pdr();

package/src/providers/steps/{StepDetectionProvider.js → StepDetection.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 StepDetection extends Provider {
 
     constructor() {
         super();
@@ -103,4 +104,4 @@ class StepDetectionProvider extends Provider {
     }
 }
 
-export default StepDetectionProvider;
+export default new StepDetection();

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;