@wemap/providers 4.0.0 → 4.0.3

package/src/providers/attitude/relative/{RelativeAttitudeFromEkfProvider.js → RelativeAttitudeFromEkf.js}

@@ -3,10 +3,10 @@ import { Attitude } from '@wemap/geo';
 import Provider from '../../Provider.js';
 import EventType from '../../../events/EventType.js';
 import EkfAttitude from '../EkfAttitude.js';
-import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertialProvider.js';
-import {
-    Accelerometer, Gyroscope
-} from '../../../Providers.js';
+import RelativeAttitudeFromInertial from './RelativeAttitudeFromInertial.js';
+
+import Accelerometer from '../../imu/Accelerometer.js';
+import Gyroscope from '../../imu/Gyroscope.js';
 
 
 /**
@@ -14,7 +14,7 @@ import {
  *  browser deviceorientation
  * The provider does not work until an offset is given.
  */
-class RelativeAttitudeFromEkfProvider extends Provider {
+class RelativeAttitudeFromEkf extends Provider {
 
     lastTimestamp = 0;
 
@@ -99,8 +99,7 @@ class RelativeAttitudeFromEkfProvider extends Provider {
         if (quaternion) {
             const attitude = new Attitude(quaternion,
                 timestamp,
-                RelativeAttitudeFromInertialProvider.DEFAULT_DRIFT,
-                this.pname
+                RelativeAttitudeFromInertial.DEFAULT_DRIFT
             );
             this.notify(this.createEvent(
                 EventType.RelativeAttitude,
@@ -110,4 +109,4 @@ class RelativeAttitudeFromEkfProvider extends Provider {
     };
 }
 
-export default RelativeAttitudeFromEkfProvider;
+export default new RelativeAttitudeFromEkf();

package/src/providers/attitude/relative/{RelativeAttitudeFromInertialProvider.js → RelativeAttitudeFromInertial.js}

@@ -1,18 +1,21 @@
+import { Attitude } from '@wemap/geo';
 import { deg2rad } from '@wemap/maths';
 import { PromiseUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
+import ProviderEvent from '../../../events/ProviderEvent.js';
 import EventType from '../../../events/EventType.js';
-import {
-    RelativeAttitudeFromEkf, RelativeAttitudeFromBrowser
-} from '../../../Providers.js';
+import RelativeAttitudeFromEkf from './RelativeAttitudeFromEkf.js';
+import RelativeAttitudeFromBrowser from './RelativeAttitudeFromBrowser.js';
+import HighRotationsDetector from '../../imu/HighRotationsDetector.js';
 
-class RelativeAttitudeFromInertialProvider extends Provider {
+
+class RelativeAttitudeFromInertial extends Provider {
 
     /**
      * default relative attitude drift in rad.second-1
      */
-    static DEFAULT_DRIFT = deg2rad(5) / 60;
+    DEFAULT_DRIFT = deg2rad(5) / 60;
 
 
     /**
@@ -49,11 +52,24 @@ class RelativeAttitudeFromInertialProvider extends Provider {
             .catch(() => (this.provider = RelativeAttitudeFromBrowser))
             .finally(() => {
                 this.listenerId = this.provider.addEventListener(
-                    events => this.notify(events[0].clone()),
+                    events => this._parseEvent(events[0]),
                     error => this.notifyError(error)
                 );
+                this._highRotationsDetector = HighRotationsDetector.addEventListener();
             });
+    }
 
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _parseEvent(event) {
+        const relativeAttitudeEvent = event.clone();
+        if (HighRotationsDetector.isInProgress()) {
+            let accuracy = relativeAttitudeEvent.data.accuracy + (this.DEFAULT_DRIFT * 100);
+            accuracy = Math.min(accuracy, Math.PI);
+            relativeAttitudeEvent.data.accuracy = accuracy;
+        }
+        this.notify(relativeAttitudeEvent);
     }
 
     /**
@@ -64,7 +80,8 @@ class RelativeAttitudeFromInertialProvider extends Provider {
             this.provider.removeEventListener(this.listenerId);
             this.provider = null;
         }
+        HighRotationsDetector.removeEventListener(this._highRotationsDetector);
     }
 }
 
-export default RelativeAttitudeFromInertialProvider;
+export default new RelativeAttitudeFromInertial();

package/src/providers/imu/{AccelerometerProvider.js → Accelerometer.js}

@@ -1,9 +1,9 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import MissingAccelerometerError from '../../errors/MissingAccelerometerError.js';
-import { Imu } from '../../Providers.js';
+import Imu from './Imu.js';
 
-class AccelerometerProvider extends Provider {
+class Accelerometer extends Provider {
 
     /**
      * @override
@@ -58,4 +58,4 @@ class AccelerometerProvider extends Provider {
 
 }
 
-export default AccelerometerProvider;
+export default new Accelerometer();

package/src/providers/imu/{GyroscopeProvider.js → Gyroscope.js}

@@ -1,9 +1,9 @@
 import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import MissingGyroscopeError from '../../errors/MissingGyroscopeError.js';
-import { Imu } from '../../Providers.js';
+import Imu from './Imu.js';
 
-class GyroscopeProvider extends Provider {
+class Gyroscope extends Provider {
 
     /**
      * @override
@@ -58,4 +58,4 @@ class GyroscopeProvider extends Provider {
 
 }
 
-export default GyroscopeProvider;
+export default new Gyroscope();

package/src/providers/imu/HighRotationsDetector.js

@@ -0,0 +1,62 @@
+import { Vector3 } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import Provider from '../Provider.js';
+import Gyroscope from './Gyroscope.js';
+
+class HighRotationsDetector extends Provider {
+
+    // in radians by second
+    static THRESHOLD = 10;
+
+    /** @type {number} in seconds */
+    static DELAY_CONSIDERATION = 3;
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'HighRotationsDetector';
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = Gyroscope.addEventListener(
+            events => this._parseGyroscopeEvent(events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Gyroscope.removeEventListener(this.providerId);
+    }
+
+    isInProgress() {
+        if (!this.lastEvent || !Gyroscope.lastEvent) {
+            return false;
+        }
+
+        const diffTime = Gyroscope.lastEvent.data.timestamp - this.lastEvent.data.timestamp;
+        return diffTime < HighRotationsDetector.DELAY_CONSIDERATION;
+    }
+
+    /**
+     * @private
+     */
+    _parseGyroscopeEvent = gyroscopeEvent => {
+
+        const { values, timestamp } = gyroscopeEvent.data;
+        const speed = Vector3.norm(values);
+        if (speed > HighRotationsDetector.THRESHOLD) {
+            this.notify(this.createEvent(EventType.HighRotation, { timestamp }, [gyroscopeEvent]));
+        }
+
+    }
+}
+
+export default new HighRotationsDetector();

package/src/providers/imu/{ImuProvider.js → Imu.js}

@@ -22,7 +22,7 @@ import AskImuOnDesktopError from '../../errors/AskImuOnDesktopError.js';
  *
  * -----------------------------------
  */
-class ImuProvider extends Provider {
+class Imu extends Provider {
 
     /**
     * @override
@@ -41,7 +41,7 @@ class ImuProvider extends Provider {
     /**
      * @override
      */
-    get _availability() {
+    static get _availability() {
         return BrowserUtils.isMobile
             ? Promise.resolve()
             : Promise.reject(new AskImuOnDesktopError());
@@ -136,4 +136,4 @@ class ImuProvider extends Provider {
 
 }
 
-export default ImuProvider;
+export default new Imu();

package/src/providers/inclination/{InclinationProvider.js → Inclination.js}

@@ -1,10 +1,9 @@
 import { PromiseUtils } from '@wemap/utils';
 
-import MetaProvider from '../MetaProvider.js';
+import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
-import {
-    InclinationFromRelativeAttitude, InclinationFromAcc
-} from '../../Providers.js';
+import InclinationFromAcc from './InclinationFromAcc.js';
+import InclinationFromRelativeAttitude from './InclinationFromRelativeAttitude.js';
 
 /**
  * Inclination provider gives the inclination of the device using Imu Sensor
@@ -12,7 +11,7 @@ import {
  *              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 InclinationProvider extends MetaProvider {
+class Inclination extends Provider {
 
     /**
      * @override
@@ -75,4 +74,4 @@ class InclinationProvider extends MetaProvider {
     }
 }
 
-export default InclinationProvider;
+export default new Inclination();

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 {
 
 
     /**
@@ -83,4 +84,4 @@ class InclinationFromAccProvider extends Provider {
     };
 }
 
-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
@@ -73,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}

@@ -1,9 +1,9 @@
-import MetaProvider from '../MetaProvider.js';
+import Provider from '../Provider.js';
 import EventType from '../../events/EventType.js';
 import { ArCore } from '../../Providers.js';
 import ProviderState from '../ProviderState.js';
 
-class CameraNativeProvider extends MetaProvider {
+class CameraNative extends Provider {
 
     /**
      * @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 Provider from '../Provider.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 Provider {
 
     /**
      * @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,217 @@
+import { UserPosition, GeoRelativePosition } from '@wemap/geo';
+import { PromiseUtils } from '@wemap/utils';
+
+import Provider from '../../Provider.js';
+import EventType from '../../../events/EventType.js';
+import ProviderEvent from '../../../events/ProviderEvent.js';
+import MapMatchingHandler from '../../../mapmatching/MapMatchingHandler.js';
+import GnssWifi from './GnssWifi.js';
+import { default as GeoRelativePositionProvider } from '../relative/GeoRelativePosition.js';
+
+class AbsolutePosition extends Provider {
+
+    // Use the new absolute position if its accuracy is at least x times better than the last one.
+    static ACCURACY_RELOC_RATIO = 1.5;
+
+    /** @type {boolean} */
+    static USE_MM_FOR_FEED = true;
+
+
+    /** @type {number?} */
+    _gnssWifiProviderId;
+
+    /** @type {number?} */
+    _relativePositionProviderId;
+
+    /** @type {number?} */
+    _mapMatchingHandlerId
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'AbsolutePosition';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsolutePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return PromiseUtils.any([
+            GeoRelativePositionProvider.availability,
+            GnssWifi.availability
+        ]);
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+        GeoRelativePositionProvider.availability
+            .then(() => {
+                this._relativePositionProviderId = GeoRelativePositionProvider.addEventListener(
+                    events => this._onRelativePosition(events[0])
+                );
+            })
+            .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);
+            }
+        );
+
+        this._mapMatchingHandlerId = MapMatchingHandler.addEventListener();
+    }
+
+
+    /**
+     * @override
+     */
+    stop() {
+        if (this._relativePositionProviderId) {
+            GeoRelativePositionProvider.removeEventListener(this._relativePositionProviderId);
+        }
+        GnssWifi.removeEventListener(this._gnssWifiProviderId);
+
+        MapMatchingHandler.removeEventListener(this._mapMatchingHandlerId);
+    }
+
+    /**
+     * @param {ProviderEvent<UserPosition>} positionEvent
+     * @param {boolean} canContainLevel
+     */
+    _onAbsolutePosition(positionEvent, canContainLevel = true) {
+
+        const newPosition = positionEvent.data.clone();
+        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
+
+        if (lastPosition) {
+
+            // Reject if the new position accuracy is not twice better than the last position accuracy
+            if (newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO > lastPosition.accuracy) {
+                return;
+            }
+
+            if (!canContainLevel) {
+                newPosition.level = lastPosition.level;
+            }
+
+            // If the new position does not have a bearing, retrieve the bearing from the last position
+            if (newPosition.bearing === null) {
+                newPosition.bearing = lastPosition.bearing;
+            }
+        }
+
+
+        const newPositionEvent = this.createEvent(
+            EventType.AbsolutePosition,
+            newPosition,
+            [positionEvent]
+        );
+
+        // If the MM is disable or the network is not set yet, use the new position as it is.
+        // If the position bearing is null, do not use MM, it is too dangerous.
+        if (!MapMatchingHandler.canUseMapMatching()) {
+            this.notify(newPositionEvent);
+            return;
+        }
+
+        MapMatchingHandler.notifyPositionFromAbsolute(newPositionEvent);
+    }
+
+    /**
+     * @param {ProviderEvent<GeoRelativePosition>} relativeEvent
+     */
+    _onRelativePosition(relativeEvent) {
+
+        if (!this.lastEvent) {
+            return;
+        }
+
+        const lastPosition = this.lastEvent.data;
+
+        const offsetPos = relativeEvent.data;
+
+        const dist = Math.sqrt(offsetPos.x ** 2 + offsetPos.y ** 2);
+        const bearing = Math.atan2(offsetPos.x, offsetPos.y);
+        const alt = lastPosition.alt !== null ? offsetPos.z : null;
+
+        const newPosition = lastPosition.destinationPoint(dist, bearing, alt);
+        newPosition.bearing = offsetPos.bearing;
+        newPosition.time = offsetPos.time;
+        newPosition.accuracy += offsetPos.accuracy;
+
+
+        const newPositionEvent = this.createEvent(
+            EventType.AbsolutePosition,
+            newPosition,
+            [relativeEvent]
+        );
+
+
+        if (!MapMatchingHandler.canUseMapMatching()) {
+            this.notify(newPositionEvent);
+            return;
+        }
+
+        MapMatchingHandler.notifyPositionFromRelative(newPositionEvent);
+    }
+
+
+    /**
+     * @override
+     * @param {UserPosition|ProviderEvent} data
+     */
+    feed(data) {
+
+        /** @type {ProviderEvent<UserPosition>} */
+        let newPositionEvent;
+
+        if (data instanceof UserPosition) {
+
+            if (data.time === null) {
+                throw Error('the time of the position is not defined');
+            }
+            if (data.accuracy === null) {
+                throw Error('the accuracy of the position is not defined');
+            }
+
+            newPositionEvent = new ProviderEvent(EventType.AbsolutePosition, data);
+
+        } else if (data instanceof ProviderEvent) {
+
+            if (data.dataType !== EventType.AbsolutePosition
+                || !(data.data instanceof UserPosition)) {
+                throw Error('the provider event is not an UserPosition');
+            }
+
+            newPositionEvent = data;
+
+        } else {
+            throw new Error('data is nor an UserPosition or a ProviderEvent');
+        }
+
+        // If the MM is disable or the network is not set yet, use the new position as it is.
+        if (!AbsolutePosition.USE_MM_FOR_FEED || !MapMatchingHandler.canUseMapMatching()) {
+            this.notify(newPositionEvent);
+            return;
+        }
+
+        MapMatchingHandler.notifyPositionFromFeed(newPositionEvent);
+    }
+}
+
+export default new AbsolutePosition();

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();