@wemap/positioning 2.1.0 → 2.3.0

package/src.old/providers/steps/StepDetectionMinMaxPeaks2.js

@@ -1,108 +0,0 @@
-
-// in seconds
-const WINDOW_TIME = 0.3;
-
-// in seconds
-const MIN_TIME_BETWEEN_STEPS = 0.4;
-
-// in Hz
-const MAX_FRENQUENCY = 4;
-const MIN_FRENQUENCY = 1;
-
-// in m.s-2
-const VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75;
-const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3;
-
-
-class StepDetectionMinMaxPeaks2 {
-
-    constructor() {
-        this.slidingWindow = [];
-
-        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
-        this.previousVerticalAcc = 0;
-        this.influence = 0.2;
-    }
-
-
-    compute(timestamp, linearAcc, angularRate) {
-
-        const verticalAcc = this.influence * (linearAcc[2] * 2) + (1 - this.influence) * this.previousVerticalAcc;
-        this.previousVerticalAcc = verticalAcc;
-
-
-        if (Math.sqrt(angularRate[0] ** 2 + angularRate[1] ** 2 + angularRate[2] ** 2) > 0.75) {
-            return false;
-        }
-
-        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
-            return false;
-        }
-
-        let maxValue = Number.MIN_SAFE_INTEGER;
-        let minValue = Number.MAX_SAFE_INTEGER;
-
-        this.slidingWindow.forEach(function(item, index, object) {
-            if (item.timestamp < timestamp - WINDOW_TIME) {
-                object.splice(index, 1);
-            } else {
-                maxValue = Math.max(item.verticalAcc, maxValue);
-                minValue = Math.min(item.verticalAcc, minValue);
-            }
-        });
-        this.slidingWindow.push({
-            timestamp: timestamp,
-            verticalAcc: verticalAcc
-        });
-
-
-        if (maxValue > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && minValue < VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
-
-            const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
-            this.frequency = Math.min(Math.max((1 / timeInterval), MIN_FRENQUENCY), MAX_FRENQUENCY);
-
-            this.lastStepTimestamp = timestamp;
-            return true;
-        }
-
-        return false;
-    }
-
-    get lastStepSize() {
-
-        if (!this.frequency) {
-            return 0;
-        }
-
-        const kParamA = 0.45;
-        const kParamB = 0.2;
-        return kParamA + kParamB * this.frequency;
-    }
-
-    get speed() {
-        return this.lastStepSize && this.frequency ? this.lastStepSize * this.frequency : 0;
-    }
-
-    mean(data) {
-        let sum = 0.0, mean = 0.0;
-
-        for (let i = 0; i < data.length; ++i) {
-            sum += data[i].verticalAcc;
-        }
-        mean = sum / data.length;
-        return mean;
-    }
-
-    stddev(data) {
-        const theMean = this.mean(data);
-        let standardDeviation = 0;
-        for (let i = 0; i < data.length; ++i) {
-            standardDeviation += (data[i].verticalAcc - theMean) ** 2;
-        }
-
-        return Math.sqrt(standardDeviation / data.length);
-    }
-}
-
-export default StepDetectionMinMaxPeaks2;

package/src.old/sensors/SensorsCompatibility.js

@@ -1,486 +0,0 @@
-/* global Accelerometer, Gyroscope, Magnetometer, AbsoluteOrientationSensor, RelativeOrientationSensor */
-
-import {
-    deg2rad, rad2deg, Quaternion, Rotations
-} from '@wemap/maths';
-
-import SensorsLogger from './SensorsLogger';
-
-
-const BROWSER = {
-    UNKNOWN: 0,
-    IOS_SAFARI: 1,
-    FIREFOX: 2,
-    OPERA: 3,
-    ANDROID_CHROME: 4,
-    ANDROID_STOCK: 5
-};
-
-const defaultMotionSensors = {
-    accelerometer: true,
-    gyroscope: true,
-    magnetometer: true
-};
-
-/**
- * 5 April 2019
- * The Generic Sensors API methods have been disabled due to a cross-origin problem.
- */
-/**
- * 13 August 2019
- * The Generic Sensors API methods have been disabled due to empty notifications when app is fullscreen and have no focus.
- */
-const ENABLE_GENERIC_SENSORS_API = false;
-
-/**
- * Keep a trace of each instance for SensorsLogger
- * TODO: Should be removed when logger will be updated with providers
- */
-const instances = [];
-
-
-// -----------------------------------
-// -----------------------------------
-// Overview of compatibilities:
-// -----------------------------------
-//
-// --------
-// Chrome Android (v72.0.3626)
-// --------
-// Accelerometer + Gyroscope: YES (via Sensors API if present or devicemotion otherwise)
-// Relative orientation: YES (via RelativeOrientationSensor if present or deviceorientation otherwise but deviceorientation.alpha is unreliable! Sometimes it starts at 0°, sometimes at 270°)
-// Absolute orientation: YES (via AbsoluteOrientationSensor if present or deviceorientationabsolute otherwise)
-// --------
-//
-// --------
-// Safari iOS (v12.0)
-// --------
-// Accelerometer + Gyroscope: YES (via devicemotion)
-// Relative orientation: YES (via deviceorientation)
-// Absolute orientation: YES (via deviceorientation and event.webkitCompassHeading)
-// --------
-//
-// --------
-// Opera (v50.2.2426)
-// --------
-// Accelerometer + Gyroscope: NO (https://developer.mozilla.org/en-US/docs/Web/API/DeviceMotionEvent)
-// Relative orientation: NO (https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation)
-// Absolute orientation: NO (https://developer.mozilla.org/en-US/docs/Web/API/Window/ondeviceorientation)
-// devicemotion and deviceorientation send only one callback and data is empty.
-// --------
-//
-// --------
-// Firefox (v65.0.1)
-// --------
-// Accelerometer + Gyroscope: YES (via devicemotion)
-// Relative orientation: YES (via deviceorientation)
-// Absolute orientation: NO (https://www.fxsitecompat.com/en-CA/docs/2018/various-device-sensor-apis-are-now-deprecated/)
-// --------
-// -----------------------------------
-
-class SensorsCompatibility {
-
-    imuTickInterval = null;
-
-    constructor() {
-        this.browser = this.retrieveBrowser();
-        instances.push(this);
-
-        this.lastGyroscopeValue = null;
-    }
-
-    // Parse the user agent to get OS and browser so we know how to normalize values
-    retrieveBrowser() {
-        const userAgent = window.navigator.userAgent;
-        // IOS uses a special property
-        if (userAgent.match(/(iPad|iPhone|iPod)/i)) {
-            return BROWSER.IOS_SAFARI;
-        } else if (userAgent.match(/Firefox/i)) {
-            return BROWSER.FIREFOX;
-        } else if (userAgent.match(/Opera/i)) {
-            return BROWSER.OPERA;
-        } else if (userAgent.match(/Android/i)) {
-            // TODO: check with android_stock browser
-            return BROWSER.ANDROID_CHROME;
-        }
-        return BROWSER.UNKNOWN;
-    }
-
-    setLogger(logger) {
-
-        if (logger && !(logger instanceof SensorsLogger)) {
-            throw new Error('logger is not an instance of SensorsLogger');
-        }
-
-        this.logger = logger;
-    }
-
-    static addLoggerOnKnownInstances(logger) {
-        instances.forEach(instance => instance.addLogger(logger));
-    }
-
-    hasArSensors() {
-        return this.startAbsoluteOrientation(this.stopAbsoluteOrientation);
-    }
-
-    /*
-     * Manage Accelerometer - Gyroscope - Magnetometer
-     */
-
-    startImu(callback, _sensors = defaultMotionSensors, frequency = 60) {
-
-        let isResolved = false;
-
-        const sensors = !_sensors ? defaultMotionSensors : _sensors;
-
-
-        if (ENABLE_GENERIC_SENSORS_API) {
-            if (sensors.accelerometer && window.Accelerometer) {
-                this.accelerometerSensor = new Accelerometer({ frequency: frequency });
-                this.accelerometerSensor.start();
-            }
-
-            if (sensors.gyroscope && window.Gyroscope) {
-                this.gyroscopeSensor = new Gyroscope({ frequency: frequency });
-                this.gyroscopeSensor.start();
-            }
-
-            if (sensors.magnetometer && window.Magnetometer) {
-                this.magnetometerSensor = new Magnetometer({ frequency: frequency });
-                this.magnetometerSensor.start();
-            }
-        }
-
-        return new Promise((resolve) => {
-
-            const notifyFn = (output) => {
-                if (sensors.accelerometer && !output.acc
-                    || sensors.gyroscope && !output.gyr
-                    || sensors.magnetometer && !output.mag) {
-                    return;
-                }
-
-                callback(output);
-
-                if (this.logger) {
-                    if (output.acc) {
-                        this.logger.feed(SensorsLogger.DataType.ACCELEROMETER, output.timestamp, output.acc, true);
-                    }
-                    if (output.gyr) {
-                        this.logger.feed(SensorsLogger.DataType.GYROSCOPE, output.timestamp, output.gyr, true);
-                    }
-                    if (output.mag) {
-                        this.logger.feed(SensorsLogger.DataType.MAGNETOMETER, output.timestamp, output.mag, true);
-                    }
-                }
-
-                if (!isResolved) {
-                    resolve();
-                    isResolved = true;
-                }
-            };
-
-            if (this.accelerometerSensor || this.gyroscopeSensor || this.magnetometerSensor) {
-
-                // Create a scheduler using frequency parameter
-                const schedulerFn = () => {
-                    this.imuTickInterval = setInterval(() => {
-                        notifyFn(this.onImuTick());
-                    }, 1 / frequency * 1000);
-                };
-
-                schedulerFn();
-
-            } else if (sensors.accelerometer || sensors.gyroscope || sensors.magnetometer) {
-
-                this.onDeviceMotionEventListener = (e) => {
-                    notifyFn(this.onDeviceMotion(e));
-                };
-                window.addEventListener('devicemotion', this.onDeviceMotionEventListener, true);
-            }
-
-        });
-    }
-
-    stopImu() {
-
-        if (this.imuTickInterval) {
-            clearInterval(this.imuTickInterval);
-            this.imuTickInterval = null;
-        }
-
-        if (this.accelerometerSensor || this.gyroscopeSensor || this.magnetometerSensor) {
-            if (this.accelerometerSensor) {
-                this.accelerometerSensor.stop();
-                this.accelerometerSensor = null;
-            }
-            if (this.gyroscopeSensor) {
-                this.gyroscopeSensor.stop();
-                this.gyroscopeSensor = null;
-            }
-            if (this.magnetometerSensor) {
-                this.magnetometerSensor.stop();
-                this.magnetometerSensor = null;
-            }
-        } else if (this.onDeviceMotionEventListener) {
-            window.removeEventListener('devicemotion', this.onDeviceMotionEventListener, true);
-        }
-    }
-
-    onImuTick() {
-        const acc = this.accelerometerSensor;
-        const accValues = acc && acc.x ? [acc.x, acc.y, acc.z] : null;
-
-        const gyr = this.gyroscopeSensor;
-        const gyrValues = gyr && gyr.x ? [gyr.x, gyr.y, gyr.z] : null;
-
-        const mag = this.magnetometerSensor;
-        const magValues = mag && mag.x ? [mag.x, mag.y, mag.z] : null;
-
-        let timestamp = 0;
-        if (accValues) {
-            timestamp = acc.timestamp;
-        } else if (gyrValues) {
-            timestamp = gyr.timestamp;
-        } else if (magValues) {
-            timestamp = mag.timestamp;
-        }
-
-        // Alignment of acc and gyr is made by taking the last value of accelerometer, gyroscope and magnetometer.
-        // This is not perfect but far enough for almost all algorithms.
-        const output = {
-            timestamp: timestamp / 1e3,
-            acc: accValues,
-            gyr: gyrValues,
-            mag: magValues
-        };
-
-        return output;
-    }
-
-    /**
-     * Verified for IOS_SAFARI, ANDROID_CHROME, FIREFOX
-     * Not working for OPERA
-     * @param {DeviceMotionEvent} e device motion event
-     */
-    onDeviceMotion(e) {
-        const timestamp = e.timeStamp / 1e3;
-
-        let acc = null;
-
-        if (e.accelerationIncludingGravity) {
-            const {
-                x, y, z
-            } = e.accelerationIncludingGravity;
-
-            if (x && y && z) {
-                acc = [x, y, z];
-            }
-        }
-
-        if (this.browser === BROWSER.IOS_SAFARI && acc) {
-            acc[0] *= -1;
-            acc[1] *= -1;
-            acc[2] *= -1;
-        }
-
-
-        let gyr = null;
-
-        if (e.rotationRate) {
-            const {
-                alpha, beta, gamma
-            } = e.rotationRate;
-
-            if (alpha && beta && gamma) {
-                gyr = [alpha * Math.PI / 180, beta * Math.PI / 180, gamma * Math.PI / 180];
-            }
-        }
-
-        const output = {
-            timestamp: timestamp,
-            acc: acc,
-            gyr: gyr,
-            mag: null
-        };
-        return output;
-    }
-
-
-    /*
-     * Manage absolute orientation
-     */
-
-    startAbsoluteOrientation(callback, frequency = 60) {
-
-
-        let isResolved = false;
-
-        return new Promise((resolve, reject) => {
-
-            const notifyFn = (timestamp, quaternion, extraData) => {
-                if (!quaternion) {
-                    return;
-                }
-
-                callback(quaternion, timestamp, extraData);
-
-                if (this.logger) {
-                    this.logger.feed(SensorsLogger.DataType.DEVICE_ORIENTATION_ABSOLUTE, timestamp, quaternion, true);
-                }
-
-                if (!isResolved) {
-                    resolve();
-                    isResolved = true;
-                }
-            };
-
-            if (ENABLE_GENERIC_SENSORS_API && window.AbsoluteOrientationSensor) {
-                // Cool! The device is compatible with Sensor_API.
-
-                this.absoluteOrientationSensor = new AbsoluteOrientationSensor({ frequency: frequency });
-                this.absoluteOrientationSensor.addEventListener('reading', (e) => {
-                    if (!e.target.quaternion) {
-                        return;
-                    }
-                    notifyFn(e.timeStamp, Quaternion.xyzw2wxyz(e.target.quaternion));
-                });
-                this.absoluteOrientationSensor.start();
-
-            } else {
-
-                switch (this.browser) {
-
-                case BROWSER.ANDROID_CHROME:
-
-                    this.onDeviceOrientationAbsoluteEventListener = (e) => {
-                        if (!e.alpha || !e.beta || !e.gamma) {
-                            return;
-                        }
-                        notifyFn(e.timeStamp / 1e3, Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]));
-                    };
-
-                    window.addEventListener('deviceorientationabsolute', this.onDeviceOrientationAbsoluteEventListener, true);
-
-                    break;
-
-                case BROWSER.IOS_SAFARI:
-
-                    this.onDeviceOrientationAbsoluteSafariEventListener = (e) => {
-
-                        if (!e.webkitCompassHeading || !e.beta || !e.gamma) {
-                            return;
-                        }
-
-                        let webkitCompassHeading = -e.webkitCompassHeading;
-                        if (e.beta > 62) {
-                            webkitCompassHeading = SensorsCompatibility.headingEusToEnu(180 - webkitCompassHeading, e.beta, e.gamma);
-                        }
-                        const quaternion = Rotations.eulerToQuaternionZXYDegrees([webkitCompassHeading, e.beta, e.gamma]);
-                        notifyFn(e.timeStamp / 1e3, quaternion, { 'webkitCompassHeading': e.webkitCompassHeading });
-                    };
-
-                    window.addEventListener('deviceorientation', this.onDeviceOrientationAbsoluteSafariEventListener, true);
-
-                    // Be Careful: webkitCompassHeading is not continuous.
-                    // It value changes with thresholds: beta > 30deg and beta < 62deg
-                    console.warn('[Sensors] Be careful, you are using webkitCompassHeading on iOS and this method is unreliable (not continuous)');
-
-                    break;
-
-                default:
-                    reject(new Error('Your browser cannot provide absolute orientation or we do not know how to parse its data'));
-                }
-            }
-        });
-    }
-
-    stopAbsoluteOrientation() {
-        if (this.absoluteOrientationSensor) {
-            this.absoluteOrientationSensor.stop();
-            this.absoluteOrientationSensor = null;
-        } else if (this.onDeviceOrientationAbsoluteEventListener) {
-            window.removeEventListener('deviceorientationabsolute', this.onDeviceOrientationAbsoluteEventListener, true);
-        } else if (this.onDeviceOrientationAbsoluteSafariEventListener) {
-            window.removeEventListener('deviceorientation', this.onDeviceOrientationAbsoluteSafariEventListener, true);
-        }
-    }
-
-    static headingEusToEnu(_alpha, _beta, _gamma) {
-        const alpha = deg2rad(_alpha);
-        const beta = deg2rad(_beta);
-        const gamma = deg2rad(_gamma);
-
-        return rad2deg(Math.atan2(
-            Math.cos(alpha) * Math.sin(gamma) + Math.cos(gamma) * Math.sin(alpha) * Math.sin(beta),
-            Math.sin(alpha) * Math.sin(gamma) - Math.cos(alpha) * Math.cos(gamma) * Math.sin(beta)));
-    }
-
-    /*
-     * Manage relative orientation
-     */
-
-    startRelativeOrientation(callback, frequency = 60) {
-
-        let isResolved = false;
-
-        return new Promise((resolve) => {
-
-            const notifyFn = (timestamp, quaternion) => {
-                if (!quaternion) {
-                    return;
-                }
-
-                if (!isResolved) {
-                    resolve();
-                    isResolved = true;
-                }
-
-                callback(quaternion, timestamp);
-
-                if (this.logger) {
-                    this.logger.feed(SensorsLogger.DataType.DEVICE_ORIENTATION_RELATIVE, timestamp, quaternion, true);
-                }
-            };
-
-            if (ENABLE_GENERIC_SENSORS_API && window.RelativeOrientationSensor) {
-                // Cool! The device is compatible with Sensor_API.
-
-                this.relativeOrientationSensor = new RelativeOrientationSensor({ frequency: frequency });
-                this.relativeOrientationSensor.addEventListener('reading', (e) => {
-                    if (!e.target.quaternion) {
-                        return;
-                    }
-                    notifyFn(e.timeStamp / 1e3, Quaternion.xyzw2wxyz(e.target.quaternion));
-                });
-                this.relativeOrientationSensor.start();
-
-            } else {
-
-                this.onDeviceOrientationRelativeEventListener = (e) => {
-                    if (!e.alpha || !e.beta || !e.gamma) {
-                        return;
-                    }
-                    notifyFn(e.timeStamp / 1e3, Rotations.eulerToQuaternionZXYDegrees([e.alpha, e.beta, e.gamma]));
-                };
-                window.addEventListener('deviceorientation', this.onDeviceOrientationRelativeEventListener, true);
-
-            }
-
-            if (this.browser === BROWSER.ANDROID_CHROME) {
-                console.warn('[Sensors] Be careful, you are using relative orientation on Android Chrome and this method is unreliable');
-            }
-        });
-    }
-
-    stopRelativeOrientation() {
-        if (this.relativeOrientationSensor) {
-            this.relativeOrientationSensor.stop();
-            this.relativeOrientationSensor = null;
-        } else if (this.onDeviceOrientationRelativeEventListener) {
-            window.removeEventListener('deviceorientation', this.onDeviceOrientationRelativeEventListener, true);
-        }
-    }
-}
-
-export default SensorsCompatibility;