@wemap/positioning 1.2.0

package/src/providers/steps/StepDetectionMinMaxPeaks2.js

@@ -0,0 +1,108 @@
+
+// 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/sensors/SensorsCompatibility.js

@@ -0,0 +1,484 @@
+/* global Accelerometer, Gyroscope, Magnetometer, AbsoluteOrientationSensor, RelativeOrientationSensor */
+
+import { Quaternion, Rotations, Utils as MathUtils } 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 = MathUtils.deg2rad(_alpha);
+        const beta = MathUtils.deg2rad(_beta);
+        const gamma = MathUtils.deg2rad(_gamma);
+
+        return MathUtils.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;