@wemap/providers 3.3.0 → 4.0.1

package/src/providers/inclination/{InclinationFromAccProvider.js → InclinationFromAcc.js}

@@ -1,6 +1,7 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import { Accelerometer } from '../../Providers.js';
+
+import Accelerometer from '../imu/Accelerometer.js';
 
 /**
  * Inclination provider gives the inclination of the device using Imu Sensor
@@ -8,7 +9,7 @@ import { Accelerometer } from '../../Providers.js';
  *              when the device is layed on a table, inclination = 0
  * This provider use window.orientation to return a result in function of screen orientation
  */
-class InclinationFromAccProvider extends Provider {
+class InclinationFromAcc extends Provider {
 
 
     /**
@@ -53,7 +54,7 @@ class InclinationFromAccProvider extends Provider {
      * @private
      */
     onAccelerometerEvent = accelerometerEvent => {
-        const acc = accelerometerEvent.data;
+        const acc = accelerometerEvent.data.values;
 
         const screenOrientation = window.orientation || 0;
 
@@ -78,10 +79,9 @@ class InclinationFromAccProvider extends Provider {
         this.notify(this.createEvent(
             EventType.Inclination,
             inclination,
-            accelerometerEvent.timestamp,
             [accelerometerEvent]
         ));
     };
 }
 
-export default InclinationFromAccProvider;
+export default new InclinationFromAcc();

package/src/providers/inclination/{InclinationFromRelativeAttitudeProvider.js → InclinationFromRelativeAttitude.js}

@@ -1,6 +1,7 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import { RelativeAttitudeFromInertial } from '../../Providers.js';
+import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeFromInertial.js';
+
 
 /**
  * Inclination provider gives the inclination of the device using Relative Attitude
@@ -8,7 +9,7 @@ import { RelativeAttitudeFromInertial } from '../../Providers.js';
  *              when the device is layed on a table, inclination = 0
  * This provider use window.orientation to return a result in function of screen orientation
  */
-class InclinationFromRelativeAttitudeProvider extends Provider {
+class InclinationFromRelativeAttitude extends Provider {
 
     /**
     * @override
@@ -44,7 +45,6 @@ class InclinationFromRelativeAttitudeProvider extends Provider {
                 this.notify(this.createEvent(
                     EventType.Inclination,
                     inclination,
-                    attitudeEvent.timestamp,
                     [attitudeEvent]
                 ));
             },
@@ -74,4 +74,4 @@ class InclinationFromRelativeAttitudeProvider extends Provider {
     }
 }
 
-export default InclinationFromRelativeAttitudeProvider;
+export default new InclinationFromRelativeAttitude();

package/src/providers/legacy/helpers/ThugDetector.js

@@ -1,14 +1,14 @@
 import { Constants as GeoConstants } from '@wemap/geo';
 import { Vector3 } from '@wemap/maths';
 
-// in seconds
-const MIN_TIME_BETWEEN_DETECTIONS = 0.5;
 
-// in m.s^-2
-const EXT_ACC_NORM_THRESHOLD = 4;
+class ThugDetector {
 
+    // in seconds
+    static MIN_TIME_BETWEEN_DETECTIONS = 0.5;
 
-class ThugDetector {
+    // in m.s^-2
+    static EXT_ACC_NORM_THRESHOLD = 4;
 
     constructor() {
         this.lastDetectionTimestamp = 0;
@@ -18,12 +18,12 @@ class ThugDetector {
 
         let detection = false;
 
-        if (timestamp - this.lastDetectionTimestamp < MIN_TIME_BETWEEN_DETECTIONS) {
+        if (timestamp - this.lastDetectionTimestamp < ThugDetector.MIN_TIME_BETWEEN_DETECTIONS) {
             return detection;
         }
 
         const extAccNorm = Vector3.norm(acceleration) - GeoConstants.EARTH_GRAVITY;
-        if (Math.abs(extAccNorm) > EXT_ACC_NORM_THRESHOLD) {
+        if (Math.abs(extAccNorm) > ThugDetector.EXT_ACC_NORM_THRESHOLD) {
             detection = true;
             this.lastDetectionTimestamp = timestamp;
         }

package/src/providers/others/{BarcodeProvider.js → Barcode.js}

@@ -1,8 +1,8 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import { ArCore } from '../../Providers.js';
+import ArCore from '../position/relative/ArCore.js';
 
-class BarcodeProvider extends Provider {
+class Barcode extends Provider {
 
     /**
      * @override
@@ -51,4 +51,4 @@ class BarcodeProvider extends Provider {
     }
 }
 
-export default BarcodeProvider;
+export default new Barcode();

package/src/providers/others/{CameraNativeProvider.js → CameraNative.js}

@@ -3,7 +3,7 @@ import EventType from '../../events/EventType.js';
 import { ArCore } from '../../Providers.js';
 import ProviderState from '../ProviderState.js';
 
-class CameraNativeProvider extends MetaProvider {
+class CameraNative extends MetaProvider {
 
     /**
      * @override
@@ -52,4 +52,4 @@ class CameraNativeProvider extends MetaProvider {
     }
 }
 
-export default CameraNativeProvider;
+export default new CameraNative();

package/src/providers/others/{CameraProjectionMatrixProvider.js → CameraProjectionMatrix.js}

@@ -1,8 +1,8 @@
 import MetaProvider from '../MetaProvider.js';
 import EventType from '../../events/EventType.js';
-import { ArCore } from '../../Providers.js';
+import ArCore from '../position/relative/ArCore.js';
 
-class CameraProjectionMatrixProvider extends MetaProvider {
+class CameraProjectionMatrix extends MetaProvider {
 
     /**
      * @override
@@ -48,4 +48,4 @@ class CameraProjectionMatrixProvider extends MetaProvider {
     }
 }
 
-export default CameraProjectionMatrixProvider;
+export default new CameraProjectionMatrix();

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

@@ -0,0 +1,187 @@
+import noop from 'lodash.noop';
+
+import { UserPosition } from '@wemap/geo';
+import { PromiseUtils } from '@wemap/utils';
+
+import MetaProvider from '../../MetaProvider.js';
+import EventType from '../../../events/EventType.js';
+import ProviderEvent from '../../../events/ProviderEvent.js';
+import MapMatchingHandler from '../../../mapmatching/MapMatchingHandler.js';
+import AbsolutePositionFromRel from './AbsolutePositionFromRel.js';
+import GnssWifi from './GnssWifi.js';
+class AbsolutePosition extends MetaProvider {
+
+    // Position accuracy uncertainty ratio
+    static ACCURACY_NEW_POS_EPS_RATIO = 1.5;
+    static ACCURACY_RELOC_RATIO = 2;
+    static MM_MIN_TIME = 0.4;
+
+    /** @type {number} */
+    lastMMAttempt = -Infinity;
+
+    constructor() {
+        super();
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'AbsolutePosition';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return PromiseUtils.any([
+            AbsolutePositionFromRel.availability,
+            GnssWifi.availability
+        ]);
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+        AbsolutePositionFromRel.availability
+            .then(() => {
+                this.fromRelPosProviderId = AbsolutePositionFromRel.addEventListener(
+                    events => this.onAbsolutePositionFromRel(events[0]),
+                    noop
+                );
+            })
+            .catch(() => {
+                // do nothing
+            });
+
+        this.gnssWifiProviderId = GnssWifi.addEventListener(
+            events => {
+                // bearing from GnssWifi is not reliable for our usecase
+                events[0].data.bearing = null;
+                this.onAbsolutePosition(events[0], false);
+            },
+            noop
+        );
+
+    }
+
+
+    /**
+     * @override
+     */
+    stop() {
+        if (this.fromRelPosProviderId) {
+            AbsolutePositionFromRel.removeEventListener(this.fromRelPosProviderId);
+        }
+        GnssWifi.removeEventListener(this.gnssWifiProviderId);
+    }
+
+    /**
+     * @param {ProviderEvent} newPositionEvent
+     * @param {boolean} canContainLevel
+     */
+    onAbsolutePosition(newPositionEvent, canContainLevel = true) {
+
+        if (!this._useNewAbsolutePosition(newPositionEvent.data)) {
+            return;
+        }
+
+        const newPosition = newPositionEvent.data.clone();
+
+        if (this.lastEvent && !canContainLevel) {
+            newPosition.level = this.lastEvent.data.level;
+        }
+
+        // If the new position does not have a bearing, retrieve the bearing from the last position
+        if (newPosition.bearing === null && this.lastEvent !== null) {
+            newPosition.bearing = this.lastEvent.data.bearing;
+        }
+
+        const shouldTryMmOnNodes = !newPositionEvent.providersStack.includes(AbsolutePositionFromRel.pname);
+        const position = MapMatchingHandler.calcProjection(newPosition, shouldTryMmOnNodes) || newPosition;
+
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            position,
+            [newPositionEvent]
+        ));
+
+    }
+
+    /**
+     * @param {ProviderEvent} newPositionEvent
+     */
+    onAbsolutePositionFromRel(newPositionEvent) {
+
+        let position = newPositionEvent.data;
+
+        if (newPositionEvent.data.time - this.lastMMAttempt > AbsolutePosition.MM_MIN_TIME) {
+            position = MapMatchingHandler.calcProjection(position) || position;
+            this.lastMMAttempt = newPositionEvent.data.time;
+        }
+
+        if (position === newPositionEvent.data) {
+            position = position.clone();
+        }
+
+        this.notify(this.createEvent(
+            EventType.AbsolutePosition,
+            position,
+            [newPositionEvent]
+        ));
+    }
+
+    _useNewAbsolutePosition(newPosition) {
+
+        if (!this.lastEvent) {
+            return true;
+        }
+
+        const lastPosition = this.lastEvent.data;
+
+        if (newPosition.accuracy <= newPosition.distanceTo(lastPosition) / AbsolutePosition.ACCURACY_NEW_POS_EPS_RATIO) {
+            return true;
+        }
+
+        if (newPosition.accuracy <= lastPosition.accuracy / AbsolutePosition.ACCURACY_RELOC_RATIO) {
+            return true;
+        }
+
+        return false;
+
+    }
+
+    /**
+     * @override
+     * @param {UserPosition} data
+     */
+    feed(data) {
+        if (data instanceof UserPosition) {
+            const position = data;
+            if (position.time === null) {
+                throw Error('the time of the position is not defined');
+            }
+            if (position.accuracy === null) {
+                throw Error('the accuracy of the position is not defined');
+            }
+
+            this.onAbsolutePosition(this.createEvent(
+                EventType.AbsolutePosition, position
+            ));
+        } else {
+            throw new Error('Unknown feed object');
+        }
+    }
+
+}
+
+export default new AbsolutePosition();

package/src/providers/position/absolute/{AbsolutePositionFromRelProvider.js → AbsolutePositionFromRel.js}

@@ -1,11 +1,10 @@
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import ProviderEvent from '../../../events/ProviderEvent.js';
-import {
-    AbsolutePosition, GeoRelativePosition
-} from '../../../Providers.js';
+import GeoRelativePosition from '../relative/GeoRelativePosition.js';
+import AbsolutePosition from './AbsolutePosition.js';
 
-class AbsolutePositionFromRelProvider extends Provider {
+class AbsolutePositionFromRel extends Provider {
 
     position = null;
 
@@ -68,7 +67,7 @@ class AbsolutePositionFromRelProvider extends Provider {
         /**
          * Use absolute position events only when they are not from this provider
          */
-        if (absolutePositionEvent.providersStack.includes(this.pname)) {
+        if (absolutePositionEvent.data === this.position) {
             return;
         }
 
@@ -91,13 +90,12 @@ class AbsolutePositionFromRelProvider extends Provider {
 
             this.position = this.position.destinationPoint(dist, bearing, alt);
             this.position.bearing = offsetPos.bearing;
-            this.position.time = event.timestamp;
+            this.position.time = offsetPos.time;
             this.position.accuracy += offsetPos.accuracy;
 
             this.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 this.position,
-                event.timestamp,
                 [event]
             ));
         }
@@ -105,4 +103,4 @@ class AbsolutePositionFromRelProvider extends Provider {
 
 }
 
-export default AbsolutePositionFromRelProvider;
+export default new AbsolutePositionFromRel();

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
         );
 
     }
@@ -97,7 +98,7 @@ class GnssWifiProvider extends Provider {
             this.pname);
 
         this.notify(this.createEvent(
-            EventType.AbsolutePosition, position, timestamp
+            EventType.AbsolutePosition, position
         ));
 
     };
@@ -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
@@ -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));
             });
     }
 
@@ -65,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
@@ -95,9 +93,9 @@ class ArCoreProvider extends Provider {
 
         const events = [];
 
-        const time = TimeUtils.preciseTime / 1e3;
+        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
@@ -84,10 +83,9 @@ class GeoRelativePositionFromArCoreProvider extends Provider {
         this.notify(this.createEvent(
             EventType.GeoRelativePosition,
             position,
-            relativePosition.time,
             [relativePositionEvent, relativeAttitudeEvent, absoluteAttitudeEvent]
         ));
     }
 }
 
-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];
@@ -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,11 +122,10 @@ class PdrProvider extends Provider {
         this.notify(this.createEvent(
             EventType.GeoRelativePosition,
             position,
-            timestamp,
             [stepEvent, this.attitudeEvent]
         ));
     }
 
 }
 
-export default PdrProvider;
+export default new Pdr();