@wemap/providers 12.10.8 → 12.10.9

package/src/providers/attitude/absolute/AbsoluteAttitudeProvider.ts

@@ -1,268 +0,0 @@
-/* eslint-disable max-statements */
-import { AbsoluteHeading, Attitude } from '@wemap/geo';
-import { deg2rad, diffAngle, Quaternion, Quaternion_t } from '@wemap/maths';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import AbsoluteAttitudeFromBrowserProvider from './AbsoluteAttitudeFromBrowserProvider.js';
-import RelativeAttitudeProvider from '../relative/RelativeAttitudeProvider.js';
-import InclinationProvider from '../../inclination/InclinationProvider.js';
-import HighRotationsProvider from '../../imu/HighRotationsProvider.js';
-import VpsProvider from '../../vision/vps/VpsProvider.js';
-import { AbsoluteAttitude, RelativeAttitude } from '../../../events/Types.js';
-
-/**
- * Absolute attitude provider gives the device attitude in East-North-Up (ENU) frame
- */
-class AbsoluteAttitudeProvider extends Provider<AbsoluteAttitude> {
-
-    static REL_ABS_DIVERGENCE_ANGLE_THRESHOLD = deg2rad(25) // in radians;
-    static REL_ABS_DIVERGENCE_TIME_THRESHOLD = 2.5; // in seconds
-    static REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD = deg2rad(15) // in radians;
-
-    private _absAttitudeFromBrowser?: AbsoluteAttitude;
-    private _vpsProviderId?: number;
-    fromBrowserProviderId?: number;
-    highRotationProviderId?: number;
-    inclinationProviderId?: number;
-    relativeAttitudeProviderId?: number;
-
-    _attitudeFromBrowserErrored = false;
-    _attitudeFromRelativeErrored = false;
-
-    /*
-     * RELATIVE
-     */
-
-    _relativeAttitude: RelativeAttitude | null = null;
-    _relativeAccuracy = 0; // in radians/s
-
-    _lastForcedHeadingEvent?: AbsoluteAttitude | AbsoluteHeading;
-    _relAbsQuat?: Quaternion_t;
-    _wasHighRotationInProgress = false;
-    _timeFirstDivergence: number | null = null;
-    _callbackMagCalibration?: (data: { angle: number }) => void;
-
-    getName = () => 'AbsoluteAttitude';
-
-    availability() {
-        return AvailabilityHelper.some([
-            AbsoluteAttitudeFromBrowserProvider.getAvailability(),
-            RelativeAttitudeProvider.getAvailability()
-        ]);
-    }
-
-    start() {
-
-        this.fromBrowserProviderId = AbsoluteAttitudeFromBrowserProvider.addEventListener(
-            this._onAttitudeFromBrowser,
-            error => {
-                this._attitudeFromBrowserErrored = true;
-                this._onError(error);
-            }
-        );
-
-        // Vps
-        this._vpsProviderId = VpsProvider.addEventListener(
-            event => this._onAttitudeFromVps(event.absoluteAttitude),
-            error => this.notifyError(error),
-            false
-        );
-
-        this.relativeAttitudeProviderId = RelativeAttitudeProvider.addEventListener(
-            this._onRelativeAttitudeEvent,
-            error => {
-                this._attitudeFromRelativeErrored = true;
-                this._onError(error);
-            }
-        );
-
-        this.inclinationProviderId = InclinationProvider.addEventListener();
-
-        this.highRotationProviderId = HighRotationsProvider.addEventListener();
-    }
-
-    stop() {
-        AbsoluteAttitudeFromBrowserProvider.removeEventListener(this.fromBrowserProviderId);
-        RelativeAttitudeProvider.removeEventListener(this.relativeAttitudeProviderId);
-        InclinationProvider.removeEventListener(this.inclinationProviderId);
-        HighRotationsProvider.removeEventListener(this.highRotationProviderId);
-        VpsProvider.removeEventListener(this._vpsProviderId);
-    }
-
-    _setCallbackMagCalibration(cb: (data: { angle: number }) => void) {
-        this._callbackMagCalibration = cb;
-    }
-
-    private _onError = (error: Error) => {
-        if (this._attitudeFromBrowserErrored && this._attitudeFromRelativeErrored) {
-            this.notifyError(error);
-        }
-    }
-
-
-    _forceHeadingForRelative = (absoluteHeadingEvent: AbsoluteAttitude | AbsoluteHeading) => {
-
-        if (this.lastEvent && absoluteHeadingEvent.accuracy! > this.lastEvent.accuracy!) {
-            return;
-        }
-
-        const calcForceHeading = (relativeAttitude: RelativeAttitude) => {
-            const currentRelativeHeading = relativeAttitude.heading;
-
-            this._relAbsQuat = Quaternion.fromAxisAngle(
-                [0, 0, 1],
-                currentRelativeHeading - absoluteHeadingEvent.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 = RelativeAttitudeProvider.addEventListener(
-            event => {
-                calcForceHeading(event);
-                RelativeAttitudeProvider.removeEventListener(providerId);
-            }
-        );
-
-    };
-
-    _onRelativeAttitudeEvent = (event: RelativeAttitude) => {
-
-        const { quaternion, accuracy, time } = event;
-
-        // 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;
-
-
-        if (!this._lastForcedHeadingEvent || !this._relAbsQuat) {
-            return;
-        }
-
-        const accuracyWithRelative = Math.min(
-            (this._lastForcedHeadingEvent.accuracy || 0) + this._relativeAccuracy,
-            Math.PI
-        );
-
-        const highRotationInProgress = HighRotationsProvider.isInProgress();
-
-        let divergenceDetected = false;
-
-        if (this._absAttitudeFromBrowser) {
-
-            const {
-                accuracy: accuracyWithAbsolute,
-                heading: headingFromAbsolute
-            } = this._absAttitudeFromBrowser;
-
-            if (this._wasHighRotationInProgress && !highRotationInProgress) {
-                // Update heading for relative if it the end of high rotations
-                // (probably due to a magnetometer calibratiton)
-                this._forceHeadingForRelative(this._absAttitudeFromBrowser);
-
-            } 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 = InclinationProvider.lastEvent;
-
-
-                if (angle > AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_ANGLE_THRESHOLD
-                    && inclination !== null
-                    && Math.abs(inclination - Math.PI / 4) > AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_INCLINATION_THRESHOLD
-                ) {
-                    divergenceDetected = true;
-
-                    // Be sure before forcing heading
-                    if (this._timeFirstDivergence !== null
-                        && time! - this._timeFirstDivergence > AbsoluteAttitudeProvider.REL_ABS_DIVERGENCE_TIME_THRESHOLD) {
-
-                        this._forceHeadingForRelative(this._absAttitudeFromBrowser);
-                        this._callbackMagCalibration?.({ angle });
-                        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 AbsoluteAttitude(absoluteQuat, time, accuracyWithRelative);
-        this.notify(attitude);
-    }
-
-
-    _onAttitudeFromBrowser = (event: AbsoluteAttitude) => {
-        this._absAttitudeFromBrowser = event;
-
-        if (!this._lastForcedHeadingEvent) {
-            this._forceHeadingForRelative(event);
-            return;
-        }
-
-        // Absolute attitude from browser is not used anymore due to magnetometer inaccuracy on pitch and roll
-    }
-
-
-    _onAttitudeFromVps = (event: AbsoluteAttitude) => {
-        this._forceHeadingForRelative(event);
-    }
-
-    feed(data: AbsoluteHeading | AbsoluteAttitude) {
-
-        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(data);
-
-        } else if (data instanceof AbsoluteAttitude) {
-
-            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(data);
-
-        } else {
-            throw new Error('data is nor an AbsoluteHeading or an Attitude object');
-        }
-    }
-}
-
-export default new AbsoluteAttitudeProvider();

package/src/providers/attitude/relative/RelativeAttitudeFromBrowserProvider.ts

@@ -1,84 +0,0 @@
-import { deg2rad, Rotations } from '@wemap/maths';
-import { BrowserUtils } from '@wemap/utils';
-
-import Provider from '../../Provider.js';
-import AskImuOnDesktopError from '../../../errors/AskImuOnDesktopError.js';
-import MissingSensorError from '../../../errors/MissingSensorError.js';
-import { RelativeAttitude } from '../../../events/Types.js';
-
-// https://stackoverflow.com/a/73369838/2239938
-interface DeviceOrientationEventiOS extends DeviceOrientationEvent {
-    requestPermission?: () => Promise<'granted' | 'denied'>;
-}
-
-/**
- * Relative attitude provider gives the device attitude in a custom frame (x-right, y-front, z-up) using
- *  browser deviceorientation
- *
- * -----------------------------------
- * Overview of compatibilities:
- * -----------------------------------
- *
- * Chrome Android (v72.0.3626): YES (via deviceorientation but deviceorientation.alpha is unreliable! Sometimes it starts at 0°, sometimes at 270°)
- * Safari iOS (v12.0): YES (via deviceorientation)
- * Opera Android (v50.2.2426): NO {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation}
- * Firefox Android (v65.0.1): YES (via deviceorientation)
- *
- * -----------------------------------
- */
-
-class RelativeAttitudeFromBrowser extends Provider<RelativeAttitude> {
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    static DEFAULT_DRIFT = deg2rad(5) / 60;
-
-    getName = () => 'RelativeAttitudeFromBrowser';
-
-    availability() {
-        return BrowserUtils.isMobile
-            ? Promise.resolve()
-            : Promise.resolve(new AskImuOnDesktopError());
-    }
-
-    start() {
-        const subscribe = () => window.addEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
-
-        const requestPermission = (DeviceOrientationEvent as unknown as DeviceOrientationEventiOS).requestPermission || undefined;
-
-        if (requestPermission) {
-            requestPermission()
-                .then(response => {
-                    if (response !== 'granted') {
-                        throw new Error('Permission not granted');
-                    }
-                    subscribe();
-                })
-                .catch(error => this.notifyError(error));
-        } else {
-            subscribe();
-        }
-    }
-
-    stop() {
-        window.removeEventListener('deviceorientation', this.onDeviceOrientationEvent, true);
-    }
-
-    onDeviceOrientationEvent = (e: DeviceOrientationEvent) => {
-
-        if (typeof e.alpha !== 'number' || typeof e.beta !== 'number' || typeof e.gamma !== 'number') {
-            this.notifyError(new MissingSensorError().from('deviceorientation'));
-            return;
-        }
-
-        const quaternion = Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]);
-        const attitude = new RelativeAttitude(quaternion,
-            e.timeStamp / 1e3,
-            RelativeAttitudeFromBrowser.DEFAULT_DRIFT
-        );
-        this.notify(attitude);
-    };
-}
-
-export default new RelativeAttitudeFromBrowser();

package/src/providers/attitude/relative/RelativeAttitudeFromEkfProvider.ts

@@ -1,89 +0,0 @@
-import { deg2rad, Vector3_t } from '@wemap/maths';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import EkfAttitude from '../EkfAttitude.js';
-import Accelerometer from '../../imu/AccelerometerProvider.js';
-import Gyroscope from '../../imu/GyroscopeProvider.js';
-import { Acceleration, AngularRate, RelativeAttitude } from '../../../events/Types.js';
-
-/**
- * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation
- * The provider does not work until an offset is given.
- */
-class RelativeAttitudeFromEkf extends Provider<RelativeAttitude> {
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    static DEFAULT_DRIFT = deg2rad(5) / 60;
-
-    accelerometerProviderId?: number;
-    ekfAttitude = new EkfAttitude();
-    gyroscopeEvent?: AngularRate;
-    gyroscopeProviderId?: number;
-
-    lastTimestamp = 0;
-
-    getName = () => 'RelativeAttitudeFromEkf';
-
-    availability() {
-        return AvailabilityHelper.every([
-            Accelerometer.getAvailability(),
-            Gyroscope.getAvailability()
-        ]);
-    }
-
-    start() {
-        this.accelerometerProviderId = Accelerometer.addEventListener(
-            event => this.onAccelerometerEvent(event),
-            error => this.notifyError(error)
-        );
-
-        this.gyroscopeProviderId = Gyroscope.addEventListener(
-            event => this.gyroscopeEvent = event,
-            error => this.notifyError(error)
-        );
-    }
-
-    stop() {
-        Accelerometer.removeEventListener(this.accelerometerProviderId);
-        Gyroscope.removeEventListener(this.gyroscopeProviderId);
-    }
-
-    private onAccelerometerEvent = (accelerationEvent: Acceleration) => {
-
-        if (!this.gyroscopeEvent) {
-            return;
-        }
-
-        const {
-            values: acceleration, timestamp
-        } = accelerationEvent;
-
-        // Handle timestamps and dt
-        if (this.lastTimestamp === 0) {
-            this.lastTimestamp = timestamp;
-            return;
-        }
-        const diffTime = timestamp - this.lastTimestamp;
-        this.lastTimestamp = timestamp;
-
-        const quaternion = this.ekfAttitude.update(
-            diffTime,
-            acceleration as Vector3_t,
-            this.gyroscopeEvent.values as Vector3_t
-        );
-
-        if (quaternion) {
-            const attitude = new RelativeAttitude(quaternion,
-                timestamp,
-                RelativeAttitudeFromEkf.DEFAULT_DRIFT
-            );
-            this.notify(attitude);
-        }
-    };
-}
-
-export default new RelativeAttitudeFromEkf();

package/src/providers/attitude/relative/RelativeAttitudeFromInertialProvider.ts

@@ -1,66 +0,0 @@
-import { deg2rad } from '@wemap/maths';
-
-import Provider from '../../Provider.js';
-import RelativeAttitudeFromEkfProvider from './RelativeAttitudeFromEkfProvider.js';
-import RelativeAttitudeFromBrowserProvider from './RelativeAttitudeFromBrowserProvider.js';
-import HighRotationsProvider from '../../imu/HighRotationsProvider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import { RelativeAttitude } from '../../../events/Types.js';
-
-
-class RelativeAttitudeFromInertial extends Provider<RelativeAttitude> {
-
-    /**
-     * default relative attitude drift in rad.second-1
-     */
-    static DEFAULT_DRIFT = deg2rad(5) / 60;
-
-    _highRotationsProviderId?: number;
-    listenerId?: number;
-    provider?: Provider<RelativeAttitude>;
-
-    getName = () => 'RelativeAttitudeFromInertial';
-
-    availability() {
-        return AvailabilityHelper.some([
-            RelativeAttitudeFromEkfProvider.getAvailability(),
-            RelativeAttitudeFromBrowserProvider.getAvailability()
-        ]);
-    }
-
-    start() {
-
-        RelativeAttitudeFromEkfProvider.getAvailability().then(availabilityError => {
-            this.provider = !availabilityError ? RelativeAttitudeFromEkfProvider : RelativeAttitudeFromBrowserProvider;
-
-            this.listenerId = this.provider.addEventListener(
-                event => this._parseEvent(event),
-                this.notifyError
-            );
-            this._highRotationsProviderId = HighRotationsProvider.addEventListener(
-                null,
-                this.notifyError
-            );
-        });
-    }
-
-    _parseEvent(event: RelativeAttitude) {
-        const relativeAttitude = event.clone();
-        if (HighRotationsProvider.isInProgress()) {
-            let accuracy = (relativeAttitude.accuracy || 0) + (RelativeAttitudeFromInertial.DEFAULT_DRIFT * 100);
-            accuracy = Math.min(accuracy, Math.PI);
-            relativeAttitude.accuracy = accuracy;
-        }
-        this.notify(relativeAttitude);
-    }
-
-    stop() {
-        if (this.provider) {
-            this.provider.removeEventListener(this.listenerId);
-            delete this.provider;
-        }
-        HighRotationsProvider.removeEventListener(this._highRotationsProviderId);
-    }
-}
-
-export default new RelativeAttitudeFromInertial();

package/src/providers/attitude/relative/RelativeAttitudeProvider.ts

@@ -1,70 +0,0 @@
-import Provider from '../../Provider.js';
-import RelativeAttitudeFromInertialProvider from './RelativeAttitudeFromInertialProvider.js';
-import ArCoreProvider from '../../vision/ArCoreProvider.js';
-import { RelativeAttitude } from '../../../events/Types.js';
-
-/**
- * Relative attitude provider gives the device attitude in East-North-Up (ENU) frame using
- *  browser deviceorientation
- * The provider does not work until an offset is given.
- */
-class RelativeAttitudeProvider extends Provider<RelativeAttitude> {
-
-    arCoreMonitoringId?: number;
-    arCoreProviderId?: number;
-    inertialProviderId?: number;
-
-    getName = () => 'RelativeAttitude';
-
-    availability = () => RelativeAttitudeFromInertialProvider.getAvailability();
-
-    start() {
-        this.arCoreMonitoringId = ArCoreProvider.addMonitoringListener(
-            () => {
-                this.listenArCore();
-                this.unlistenInertial();
-            }, () => {
-                this.unlistenArCore();
-                this.listenInertial();
-            });
-
-        if (ArCoreProvider.state === 'started') {
-            this.listenArCore();
-        } else {
-            this.listenInertial();
-        }
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        ArCoreProvider.removeMonitoringListener(this.arCoreMonitoringId);
-        this.unlistenArCore();
-        this.unlistenInertial();
-    }
-
-
-    listenInertial = () => {
-        this.inertialProviderId = RelativeAttitudeFromInertialProvider.addEventListener(
-            this.notify,
-            this.notifyError
-        );
-    }
-
-    unlistenInertial = () => {
-        RelativeAttitudeFromInertialProvider.removeEventListener(this.inertialProviderId);
-    }
-
-    listenArCore = () => {
-        this.arCoreProviderId = ArCoreProvider.addEventListener(
-            event => this.notify(event.relativeAttitude), null, false
-        );
-    };
-
-    unlistenArCore = () => {
-        ArCoreProvider.removeEventListener(this.arCoreProviderId);
-    }
-}
-
-export default new RelativeAttitudeProvider();

package/src/providers/imu/AccelerometerProvider.ts

@@ -1,28 +0,0 @@
-import Provider from '../Provider.js';
-import ImuProvider from './ImuProvider.js';
-import MissingAccelerometerError from '../../errors/MissingAccelerometerError.js';
-import { Acceleration } from '../../events/Types.js';
-
-class AccelerometerProvider extends Provider<Acceleration> {
-
-    private imuProviderId?: number;
-
-    getName = () => 'Accelerometer';
-
-    availability = () => ImuProvider.getAvailability();
-
-    start() {
-        this.imuProviderId = ImuProvider.addEventListener(event => {
-            event.acceleration
-                ? this.notify(event.acceleration)
-                : this.notifyError(new MissingAccelerometerError().from('devicemotion'));
-
-        }, this.notifyError);
-    }
-
-    stop() {
-        ImuProvider.removeEventListener(this.imuProviderId);
-    }
-}
-
-export default new AccelerometerProvider();

package/src/providers/imu/GyroscopeProvider.ts

@@ -1,27 +0,0 @@
-import Provider from '../Provider.js';
-import ImuProvider from './ImuProvider.js';
-import MissingGyroscopeError from '../../errors/MissingGyroscopeError.js';
-import { AngularRate } from '../../events/Types.js';
-
-class GyroscopeProvider extends Provider<AngularRate> {
-
-    private imuProviderId?: number;
-
-    getName = () => 'Gyroscope';
-
-    availability = () => ImuProvider.getAvailability();
-
-    start() {
-        this.imuProviderId = ImuProvider.addEventListener(event => {
-            event.angularRate
-                ? this.notify(event.angularRate)
-                : this.notifyError(new MissingGyroscopeError().from('devicemotion'));
-        }, this.notifyError);
-    }
-
-    stop() {
-        ImuProvider.removeEventListener(this.imuProviderId);
-    }
-}
-
-export default new GyroscopeProvider();

package/src/providers/imu/HighRotationsProvider.ts

@@ -1,49 +0,0 @@
-import { Vector3, Vector3_t } from '@wemap/maths';
-
-import Provider from '../Provider.js';
-import GyroscopeProvider from './GyroscopeProvider.js';
-import { AngularRate, HighRotation } from '../../events/Types.js';
-
-class HighRotationsProvider extends Provider<HighRotation> {
-
-    static THRESHOLD = 10; // in radians by second
-    static DELAY_CONSIDERATION = 3; // in seconds
-
-    gyroscopeProviderId?: number;
-
-    getName = () => 'HighRotationsProvider';
-
-    availability = () => GyroscopeProvider.getAvailability();
-
-    start() {
-        this.gyroscopeProviderId = GyroscopeProvider.addEventListener(
-            this._parseGyroscopeEvent,
-            this.notifyError
-        );
-    }
-
-    stop() {
-        GyroscopeProvider.removeEventListener(this.gyroscopeProviderId);
-    }
-
-    isInProgress() {
-        if (!this.lastEvent || !GyroscopeProvider.lastEvent) {
-            return false;
-        }
-
-        const diffTime = GyroscopeProvider.lastEvent.timestamp - this.lastEvent.timestamp;
-        return diffTime < HighRotationsProvider.DELAY_CONSIDERATION;
-    }
-
-    private _parseGyroscopeEvent = (gyroscopeEvent: AngularRate) => {
-
-        const { values, timestamp } = gyroscopeEvent;
-        const speed = Vector3.norm(values as Vector3_t);
-        if (speed > HighRotationsProvider.THRESHOLD) {
-            this.notify({ timestamp });
-        }
-
-    }
-}
-
-export default new HighRotationsProvider();