@wemap/providers 5.6.1 → 5.7.0

package/dist/wemap-providers.es.js

@@ -1,7 +1,7 @@
 import { deg2rad, Vector3, Matrix, Quaternion, Matrix3, Matrix4, Vector, Rotations, std, diffAngleLines, diffAngle, rad2deg } from '@wemap/maths';
 import { BrowserUtils, Browser, PromiseUtils, TimeUtils } from '@wemap/utils';
 import Logger from '@wemap/logger';
-import { Attitude, RelativePosition, AbsoluteHeading, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, GeoRelativePosition as GeoRelativePosition$1, Network } from '@wemap/geo';
+import { Attitude, RelativePosition, Constants as Constants$1, MapMatching, UserPosition, GraphEdge, AbsoluteHeading, GeoRelativePosition as GeoRelativePosition$1, Network } from '@wemap/geo';
 import geomagnetism from '@wemap/geomagnetism';
 import { Itinerary } from '@wemap/osm';
 
@@ -14,6 +14,7 @@ var EventType = {
     MagneticField: 'MAGNETIC_FIELD',
     AngularRate: 'ANGULAR_RATE',
     Acceleration: 'ACCELERATION',
+    MagnetometerNeedCalibration: 'MAGNETOMETER_NEED_CALIBRATION',
 
     RelativeAttitude: 'RELATIVE_ATTITUDE',
     AbsoluteAttitude: 'ABSOLUTE_ATTITUDE',
@@ -876,6 +877,12 @@ class HighRotationsDetector extends Provider {
 
 var HighRotationsDetector$1 = new HighRotationsDetector();
 
+class MissingMagnetometerError extends MissingSensorError {
+    constructor(message) {
+        super(message);
+    }
+}
+
 const DEFAULT_RELATIVE_NOISES = {
     acc: 0.5,
     gyr: 0.3
@@ -1196,86 +1203,6 @@ class RelativeAttitudeFromEkf extends Provider {
 
 var RelativeAttitudeFromEkf$1 = new RelativeAttitudeFromEkf();
 
-class RelativeAttitudeFromInertial extends Provider {
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    DEFAULT_DRIFT = deg2rad(5) / 60;
-
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'RelativeAttitudeFromInertial';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.RelativeAttitude];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return PromiseUtils.any([
-            RelativeAttitudeFromEkf$1.availability,
-            RelativeAttitudeFromBrowser$1.availability,
-            HighRotationsDetector$1.availability
-        ]);
-    }
-
-    /**
-     * @override
-     */
-    start() {
-
-        RelativeAttitudeFromEkf$1.availability
-            .then(() => (this.provider = RelativeAttitudeFromEkf$1))
-            .catch(() => (this.provider = RelativeAttitudeFromBrowser$1))
-            .finally(() => {
-                this.listenerId = this.provider.addEventListener(
-                    events => this._parseEvent(events[0]),
-                    error => this.notifyError(error)
-                );
-                this._highRotationsDetector = HighRotationsDetector$1.addEventListener(
-                    () => {},
-                    error => this.notifyError(error)
-                );
-            });
-    }
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _parseEvent(event) {
-        const relativeAttitudeEvent = event.clone();
-        if (HighRotationsDetector$1.isInProgress()) {
-            let accuracy = relativeAttitudeEvent.data.accuracy + (this.DEFAULT_DRIFT * 100);
-            accuracy = Math.min(accuracy, Math.PI);
-            relativeAttitudeEvent.data.accuracy = accuracy;
-        }
-        this.notify(relativeAttitudeEvent);
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        if (this.provider) {
-            this.provider.removeEventListener(this.listenerId);
-            this.provider = null;
-        }
-        HighRotationsDetector$1.removeEventListener(this._highRotationsDetector);
-    }
-}
-
-var RelativeAttitudeFromInertial$1 = new RelativeAttitudeFromInertial();
-
 /**
  * Relative attitude provider gives the device attitude in a custom frame (x-right, y-front, z-up) using
  *  browser deviceorientation
@@ -1363,6 +1290,86 @@ class RelativeAttitudeFromBrowser extends Provider {
 
 var RelativeAttitudeFromBrowser$1 = new RelativeAttitudeFromBrowser();
 
+class RelativeAttitudeFromInertial extends Provider {
+
+    /**
+     * default relative attitude drift in rad.second-1
+     */
+    DEFAULT_DRIFT = deg2rad(5) / 60;
+
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'RelativeAttitudeFromInertial';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativeAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return PromiseUtils.any([
+            RelativeAttitudeFromEkf$1.availability,
+            RelativeAttitudeFromBrowser$1.availability,
+            HighRotationsDetector$1.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        RelativeAttitudeFromEkf$1.availability
+            .then(() => (this.provider = RelativeAttitudeFromEkf$1))
+            .catch(() => (this.provider = RelativeAttitudeFromBrowser$1))
+            .finally(() => {
+                this.listenerId = this.provider.addEventListener(
+                    events => this._parseEvent(events[0]),
+                    error => this.notifyError(error)
+                );
+                this._highRotationsDetector = HighRotationsDetector$1.addEventListener(
+                    () => {},
+                    error => this.notifyError(error)
+                );
+            });
+    }
+
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _parseEvent(event) {
+        const relativeAttitudeEvent = event.clone();
+        if (HighRotationsDetector$1.isInProgress()) {
+            let accuracy = relativeAttitudeEvent.data.accuracy + (this.DEFAULT_DRIFT * 100);
+            accuracy = Math.min(accuracy, Math.PI);
+            relativeAttitudeEvent.data.accuracy = accuracy;
+        }
+        this.notify(relativeAttitudeEvent);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        if (this.provider) {
+            this.provider.removeEventListener(this.listenerId);
+            this.provider = null;
+        }
+        HighRotationsDetector$1.removeEventListener(this._highRotationsDetector);
+    }
+}
+
+var RelativeAttitudeFromInertial$1 = new RelativeAttitudeFromInertial();
+
 class MissingArCoreError extends Error {
 
     static DEFAULT_MESSAGE = 'ARCore is missing';
@@ -1658,327 +1665,70 @@ class RelativeAttitude extends Provider {
 
 var RelativeAttitude$1 = new RelativeAttitude();
 
-class MissingMagnetometerError extends MissingSensorError {
-    constructor(message) {
-        super(message);
-    }
-}
-
-/**
- * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
- */
-class AbsoluteAttitude extends Provider {
-
-    /** @type {boolean} */
-    _attitudeFromBrowserErrored = false;
-
-    /** @type {boolean} */
-    _attitudeFromRelativeErrored = false;
-
-    /*
-     * RELATIVE
-     */
-
-    /** @type {Attitude} */
-    _relativeAttitude = null;
-
-    /** @type {number} in radians/s */
-    _relativeAccuracy = 0;
-
-    /** @type {ProviderEvent<Attitude|AbsoluteHeading>} */
-    _lastForcedHeadingEvent;
+class TurnDetector extends Provider {
 
-    /** @type {number[]} quaternion offset from relative to absolute */
-    _relAbsQuat;
+    // in seconds
+    static SLIDING_WINDOW_TIME = 0.3;
 
+    static STD_THRESHOLD = 0.075;
 
-    constructor() {
-        super();
+    /** @type {number} in seconds */
+    static CONSIDER_TURN_UNTIL = 1;
 
-        this._attitudeFromBrowserErrored = false;
-        this._attitudeFromRelativeErrored = false;
-    }
+    /** @type {number[]} */
+    slidingWindow = [];
 
     /**
     * @override
     */
     static get pname() {
-        return 'AbsoluteAttitude';
+        return 'TurnDetector';
     }
 
     /**
      * @override
      */
     static get eventsType() {
-        return [EventType.AbsoluteAttitude];
+        return [EventType.Turn];
     }
 
     /**
      * @override
      */
     get _availability() {
-        return PromiseUtils.any([
-            AbsoluteAttitudeFromBrowser$1.availability,
-            RelativeAttitude$1.availability
-        ]);
+        return RelativeAttitude$1.availability;
     }
 
     /**
      * @override
      */
     start() {
-
-        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser$1.addEventListener(
-            events => this._onAttitudeFromBrowser(events[0]),
-            error => {
-                this._attitudeFromBrowserErrored = true;
-                this.onError(error);
-            }
-        );
-
-        this.relativeAttitudeProviderId = RelativeAttitude$1.addEventListener(
-            events => this._onRelativeAttitudeEvent(events[0]),
-            error => {
-                this._attitudeFromRelativeErrored = true;
-                this.onError(error);
-            }
+        this.providerId = RelativeAttitude$1.addEventListener(
+            events => this._parseRelativeAttitude(events[0]),
+            error => this.notifyError(error)
         );
-
     }
 
     /**
      * @override
      */
     stop() {
-        AbsoluteAttitudeFromBrowser$1.removeEventListener(this.fromBrowserProviderId);
-        RelativeAttitude$1.removeEventListener(this.relativeAttitudeProviderId);
+        RelativeAttitude$1.removeEventListener(this.providerId);
     }
 
-    onError(error) {
-        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
-            this.notifyError(error);
+    isTurning() {
+        if (!this.lastEvent || !RelativeAttitude$1.lastEvent) {
+            return false;
         }
-    }
 
+        const diffTime = RelativeAttitude$1.lastEvent.data.time - this.lastEvent.data.timestamp;
+        return diffTime < TurnDetector.CONSIDER_TURN_UNTIL;
+    }
 
     /**
-     * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
+     * @private
      */
-    _forceHeadingForRelative = (absoluteHeadingEvent) => {
-
-        if (this.lastEvent && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
-            return;
-        }
-
-
-        /**
-         * @param {Attitude} relativeAttitude
-         */
-        const calcForceHeading = (relativeAttitude) => {
-            const currentRelativeHeading = relativeAttitude.heading;
-
-            this._relAbsQuat = Quaternion.fromAxisAngle(
-                [0, 0, 1],
-                currentRelativeHeading - absoluteHeadingEvent.data.heading
-            );
-
-            this._relativeAccuracy = 0;
-            this._lastForcedHeadingEvent = absoluteHeadingEvent;
-        };
-
-        // If relativeAttitude does not exist yet, wait the next
-        if (this._relativeAttitude) {
-            calcForceHeading(this._relativeAttitude);
-            return;
-        }
-
-        // If this._relativeAttitude does not exist, wait the first value
-        // /!\ This works only if the relative attitude event is provided rapidly.
-        const providerId = RelativeAttitude$1.addEventListener(
-            events => {
-                calcForceHeading(events[0].data);
-                RelativeAttitude$1.removeEventListener(providerId);
-            }
-        );
-
-    };
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _onRelativeAttitudeEvent(event) {
-
-        const { quaternion, accuracy, time } = event.data;
-
-        // Calculate relative accuracy
-        if (this._relativeAttitude) {
-            this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
-        }
-
-        // Keep the relative attitude event for the calculation of relAbsQuat
-        // /!\ Keep this even if forced heading is not set /!\
-        this._relativeAttitude = event.data;
-
-
-        if (!this._lastForcedHeadingEvent) {
-            return;
-        }
-
-        const accuracyWithRelative = Math.min(
-            this._lastForcedHeadingEvent.data.accuracy + this._relativeAccuracy,
-            Math.PI
-        );
-
-        let newAccuracy = accuracyWithRelative;
-        let relAbsQuat = this._relAbsQuat;
-
-        if (this._eventFromBrowser) {
-
-            const {
-                accuracy: accuracyWithAbsolute,
-                heading: headingFromAbsolute
-            } = this._eventFromBrowser.data;
-
-            if (accuracyWithAbsolute < accuracyWithRelative) {
-                newAccuracy = accuracyWithAbsolute;
-                relAbsQuat = Quaternion.fromAxisAngle([0, 0, 1], event.data.heading - headingFromAbsolute);
-            }
-        }
-
-        const absoluteQuat = Quaternion.multiply(relAbsQuat, quaternion);
-        const attitude = new Attitude(absoluteQuat, time, newAccuracy);
-
-        this.notify(this.createEvent(
-            EventType.AbsoluteAttitude,
-            attitude,
-            [event, this._lastForcedHeadingEvent]
-        ));
-    }
-
-
-    /**
-     * @param {ProviderEvent<Attitude>} event
-     */
-    _onAttitudeFromBrowser(event) {
-        this._eventFromBrowser = event;
-
-        if (!this._lastForcedHeadingEvent) {
-            this._forceHeadingForRelative(event);
-            return;
-        }
-
-        // Absolute attitude from browser is not used anymore due to magnetometer inaccuracy on pitch and roll
-    }
-
-    /**
-     * @override
-     * @param {AbsoluteHeading|Attitude|ProviderEvent} data
-     */
-    feed(data) {
-
-        if (data instanceof AbsoluteHeading) {
-
-            if (data.time === null) {
-                throw Error('the time of the absolute heading is not defined');
-            }
-            if (data.accuracy === null) {
-                throw Error('the accuracy of the absolute heading is not defined');
-            }
-
-            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
-
-        } else if (data instanceof Attitude) {
-
-            if (data.time === null) {
-                throw Error('the time of the attitude is not defined');
-            }
-            if (data.accuracy === null) {
-                throw Error('the accuracy of the attitude is not defined');
-            }
-
-            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
-
-        } else if (data instanceof ProviderEvent) {
-
-            if (data.dataType !== EventType.AbsoluteHeading
-                || !(data.data instanceof AbsoluteHeading)) {
-                throw Error('the provider event is not an AbsoluteHeading');
-            }
-
-            this._forceHeadingForRelative(data);
-
-        } else {
-            throw new Error('data is nor an AbsoluteHeading or an Attitude object');
-        }
-    }
-}
-
-var AbsoluteAttitude$1 = new AbsoluteAttitude();
-
-class TurnDetector extends Provider {
-
-    // in seconds
-    static SLIDING_WINDOW_TIME = 0.3;
-
-    static STD_THRESHOLD = 0.075;
-
-    /** @type {number} in seconds */
-    static CONSIDER_TURN_UNTIL = 1;
-
-    /** @type {number[]} */
-    slidingWindow = [];
-
-    /**
-    * @override
-    */
-    static get pname() {
-        return 'TurnDetector';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.Turn];
-    }
-
-    /**
-     * @override
-     */
-    get _availability() {
-        return RelativeAttitude$1.availability;
-    }
-
-    /**
-     * @override
-     */
-    start() {
-        this.providerId = RelativeAttitude$1.addEventListener(
-            events => this._parseRelativeAttitude(events[0]),
-            error => this.notifyError(error)
-        );
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        RelativeAttitude$1.removeEventListener(this.providerId);
-    }
-
-    isTurning() {
-        if (!this.lastEvent || !RelativeAttitude$1.lastEvent) {
-            return false;
-        }
-
-        const diffTime = RelativeAttitude$1.lastEvent.data.time - this.lastEvent.data.timestamp;
-        return diffTime < TurnDetector.CONSIDER_TURN_UNTIL;
-    }
-
-    /**
-     * @private
-     */
-    _parseRelativeAttitude = relativeAttitudeEvent => {
+    _parseRelativeAttitude = relativeAttitudeEvent => {
 
         const { heading, time: timestamp } = relativeAttitudeEvent.data;
 
@@ -3884,6 +3634,392 @@ class Inclination extends Provider {
 
 var Inclination$1 = new Inclination();
 
+/* eslint-disable max-statements */
+
+/**
+ * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
+ */
+class AbsoluteAttitude extends Provider {
+
+    /** @type {number} */
+    static REL_ABS_DIVERGENCE_ANGLE_THRESHOLD = deg2rad(25);
+
+    /** @type {number} in seconds */
+    static REL_ABS_DIVERGENCE_TIME_THRESHOLD = 2.5;
+
+    /** @type {number} */
+    static REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD = deg2rad(15);
+
+    /** @type {boolean} */
+    _attitudeFromBrowserErrored = false;
+
+    /** @type {boolean} */
+    _attitudeFromRelativeErrored = false;
+
+    /*
+     * RELATIVE
+     */
+
+    /** @type {Attitude} */
+    _relativeAttitude = null;
+
+    /** @type {number} in radians/s */
+    _relativeAccuracy = 0;
+
+    /** @type {ProviderEvent<Attitude|AbsoluteHeading>} */
+    _lastForcedHeadingEvent;
+
+    /** @type {number[]} quaternion offset from relative to absolute */
+    _relAbsQuat;
+
+    /** @type {boolean} */
+    _wasHighRotationInProgress = false;
+
+    /** @type {?number} */
+    _timeFirstDivergence = null;
+
+
+    constructor() {
+        super();
+
+        this._attitudeFromBrowserErrored = false;
+        this._attitudeFromRelativeErrored = false;
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'AbsoluteAttitude';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.AbsoluteAttitude];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return PromiseUtils.any([
+            AbsoluteAttitudeFromBrowser$1.availability,
+            RelativeAttitude$1.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowser$1.addEventListener(
+            events => this._onAttitudeFromBrowser(events[0]),
+            error => {
+                this._attitudeFromBrowserErrored = true;
+                this.onError(error);
+            }
+        );
+
+        this.relativeAttitudeProviderId = RelativeAttitude$1.addEventListener(
+            events => this._onRelativeAttitudeEvent(events[0]),
+            error => {
+                this._attitudeFromRelativeErrored = true;
+                this.onError(error);
+            }
+        );
+
+        this.inclinationProviderId = Inclination$1.addEventListener();
+
+        this.highRotationDetectorId = HighRotationsDetector$1.addEventListener();
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitudeFromBrowser$1.removeEventListener(this.fromBrowserProviderId);
+        RelativeAttitude$1.removeEventListener(this.relativeAttitudeProviderId);
+        Inclination$1.removeEventListener(this.inclinationProviderId);
+        HighRotationsDetector$1.removeEventListener(this.highRotationDetectorId);
+    }
+
+    onError(error) {
+        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
+            this.notifyError(error);
+        }
+    }
+
+
+    /**
+     * @param {ProviderEvent<Attitude|AbsoluteHeading>} absoluteHeadingEvent
+     */
+    _forceHeadingForRelative = (absoluteHeadingEvent) => {
+
+        if (this.lastEvent && absoluteHeadingEvent.data.accuracy > this.lastEvent.data.accuracy) {
+            return;
+        }
+
+
+        /**
+         * @param {Attitude} relativeAttitude
+         */
+        const calcForceHeading = (relativeAttitude) => {
+            const currentRelativeHeading = relativeAttitude.heading;
+
+            this._relAbsQuat = Quaternion.fromAxisAngle(
+                [0, 0, 1],
+                currentRelativeHeading - absoluteHeadingEvent.data.heading
+            );
+
+            this._relativeAccuracy = 0;
+            this._lastForcedHeadingEvent = absoluteHeadingEvent;
+        };
+
+        // If relativeAttitude does not exist yet, wait the next
+        if (this._relativeAttitude) {
+            calcForceHeading(this._relativeAttitude);
+            return;
+        }
+
+        // If this._relativeAttitude does not exist, wait the first value
+        // /!\ This works only if the relative attitude event is provided rapidly.
+        const providerId = RelativeAttitude$1.addEventListener(
+            events => {
+                calcForceHeading(events[0].data);
+                RelativeAttitude$1.removeEventListener(providerId);
+            }
+        );
+
+    };
+
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _onRelativeAttitudeEvent(event) {
+
+        const { quaternion, accuracy, time } = event.data;
+
+        // Calculate relative accuracy
+        if (this._relativeAttitude) {
+            this._relativeAccuracy += (time - this._relativeAttitude.time) * accuracy;
+        }
+
+        // Keep the relative attitude event for the calculation of relAbsQuat
+        // /!\ Keep this even if forced heading is not set /!\
+        this._relativeAttitude = event.data;
+
+
+        if (!this._lastForcedHeadingEvent) {
+            return;
+        }
+
+        const accuracyWithRelative = Math.min(
+            this._lastForcedHeadingEvent.data.accuracy + this._relativeAccuracy,
+            Math.PI
+        );
+
+        const highRotationInProgress = HighRotationsDetector$1.isInProgress();
+
+        let magnetometerNeedCalibrationEvent = null;
+        let divergenceDetected = false;
+
+        if (this._eventFromBrowser) {
+
+            const {
+                accuracy: accuracyWithAbsolute,
+                heading: headingFromAbsolute
+            } = this._eventFromBrowser.data;
+
+            if (this._wasHighRotationInProgress && !highRotationInProgress) {
+                // Update heading for relative if it the end of high rotations
+                // (probably due to a magnetometer calibratiton)
+                this._forceHeadingForRelative(this._eventFromBrowser);
+
+            } else if (accuracyWithAbsolute < accuracyWithRelative) {
+                // Update heading for relative if:
+                // (1) accuracy from absolute is better than relative
+                // (2) heading divergence is greater than REL_ABS_DIVERGENCE_THRESHOLD
+                const relativeQuaternion = Quaternion.multiply(this._relAbsQuat, quaternion);
+                const relativeAttitude = new Attitude(relativeQuaternion);
+                const angle = Math.abs(diffAngle(relativeAttitude.heading, headingFromAbsolute));
+                const inclination = Inclination$1.lastEvent.data;
+
+
+                if (angle > AbsoluteAttitude.REL_ABS_DIVERGENCE_ANGLE_THRESHOLD
+                    && Math.abs(inclination - Math.PI / 4) > AbsoluteAttitude.REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD
+                ) {
+                    divergenceDetected = true;
+
+                    // Be sure before forcing heading
+                    if (this._timeFirstDivergence !== null
+                        && time - this._timeFirstDivergence > AbsoluteAttitude.REL_ABS_DIVERGENCE_TIME_THRESHOLD) {
+
+                        this._forceHeadingForRelative(this._eventFromBrowser);
+                        magnetometerNeedCalibrationEvent = this.createEvent(
+                            EventType.MagnetometerNeedCalibration,
+                            {
+                                angle
+                            }, [event, this._lastForcedHeadingEvent]
+                        );
+                        this._timeFirstDivergence = null;
+                    } else if (this._timeFirstDivergence === null) {
+                        this._timeFirstDivergence = time;
+                    }
+
+                }
+            }
+
+        }
+
+        if (!divergenceDetected) {
+            this._timeFirstDivergence = null;
+        }
+
+        this._wasHighRotationInProgress = highRotationInProgress;
+
+        const absoluteQuat = Quaternion.multiply(this._relAbsQuat, quaternion);
+        const attitude = new Attitude(absoluteQuat, time, accuracyWithRelative);
+
+        const eventsToNotify = [
+            this.createEvent(
+                EventType.AbsoluteAttitude,
+                attitude,
+                [event, this._lastForcedHeadingEvent]
+            )
+        ];
+        if (magnetometerNeedCalibrationEvent) {
+            eventsToNotify.push(magnetometerNeedCalibrationEvent);
+        }
+
+        this.notify(...eventsToNotify);
+    }
+
+
+    /**
+     * @param {ProviderEvent<Attitude>} event
+     */
+    _onAttitudeFromBrowser(event) {
+        this._eventFromBrowser = event;
+
+        if (!this._lastForcedHeadingEvent) {
+            this._forceHeadingForRelative(event);
+            return;
+        }
+
+        // Absolute attitude from browser is not used anymore due to magnetometer inaccuracy on pitch and roll
+    }
+
+    /**
+     * @override
+     * @param {AbsoluteHeading|Attitude|ProviderEvent} data
+     */
+    feed(data) {
+
+        if (data instanceof AbsoluteHeading) {
+
+            if (data.time === null) {
+                throw Error('the time of the absolute heading is not defined');
+            }
+            if (data.accuracy === null) {
+                throw Error('the accuracy of the absolute heading is not defined');
+            }
+
+            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
+
+        } else if (data instanceof Attitude) {
+
+            if (data.time === null) {
+                throw Error('the time of the attitude is not defined');
+            }
+            if (data.accuracy === null) {
+                throw Error('the accuracy of the attitude is not defined');
+            }
+
+            this._forceHeadingForRelative(new ProviderEvent(EventType.AbsoluteHeading, data));
+
+        } else if (data instanceof ProviderEvent) {
+
+            if (data.dataType !== EventType.AbsoluteHeading
+                || !(data.data instanceof AbsoluteHeading)) {
+                throw Error('the provider event is not an AbsoluteHeading');
+            }
+
+            this._forceHeadingForRelative(data);
+
+        } else {
+            throw new Error('data is nor an AbsoluteHeading or an Attitude object');
+        }
+    }
+}
+
+var AbsoluteAttitude$1 = new AbsoluteAttitude();
+
+class MagnetometerCalibrationDetector extends Provider {
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'MagnetometerCalibrationDetector';
+    }
+
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.MagnetometerNeedCalibration];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return AbsoluteAttitude$1.availability;
+    }
+
+    /**
+     * @override
+     */
+    start() {
+        this.providerId = AbsoluteAttitude$1.addEventListener(
+            events => this._parseAbsoluteAttitudeEvents(events),
+            error => this.notifyError(error),
+            false
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        AbsoluteAttitude$1.removeEventListener(this.providerId);
+    }
+
+    /**
+     * @private
+     * @param {ProviderEvent[]} absoluteAttitudeEvents
+     */
+    _parseAbsoluteAttitudeEvents = absoluteAttitudeEvents => {
+
+        if (absoluteAttitudeEvents.length < 2) {
+            return;
+        }
+
+        const magnetometerNeedCalibrationEvent = absoluteAttitudeEvents[1];
+        if (magnetometerNeedCalibrationEvent.dataType !== EventType.MagnetometerNeedCalibration) {
+            return;
+        }
+
+        this.notify(magnetometerNeedCalibrationEvent);
+    }
+}
+
+var MagnetometerCalibrationDetector$1 = new MagnetometerCalibrationDetector();
+
 class IpResolveServerError extends Error {
 
     static DEFAULT_MESSAGE = 'IP Resolver failed';
@@ -4111,6 +4247,7 @@ var Providers = /*#__PURE__*/Object.freeze({
     Accelerometer: Accelerometer$1,
     Gyroscope: Gyroscope$1,
     HighRotationsDetector: HighRotationsDetector$1,
+    MagnetometerCalibrationDetector: MagnetometerCalibrationDetector$1,
     RelativeAttitudeFromBrowser: RelativeAttitudeFromBrowser$1,
     RelativeAttitudeFromEkf: RelativeAttitudeFromEkf$1,
     RelativeAttitudeFromInertial: RelativeAttitudeFromInertial$1,