@wemap/providers 3.0.0

package/src/providers/position/relative/PdrProvider.js

@@ -0,0 +1,132 @@
+import { GeoRelativePosition } from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+
+import Provider from '../../Provider';
+import Availability from '../../../events/Availability';
+import EventType from '../../../events/EventType';
+import {
+    StepDetection, AbsoluteAttitude
+} from '../../../Providers';
+
+class PdrProvider extends Provider {
+
+    // https://ieeexplore.ieee.org/document/7346766
+    misalignment = [1, 0, 0, 0];
+    misalignmentError = deg2rad(3);
+
+    /**
+    * @override
+    */
+    static get displayName() {
+        return 'PDR';
+    }
+
+    /**
+     * @override
+     */
+    static get eventsType() {
+        return [EventType.RelativePosition];
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.merge(
+            StepDetection.availability,
+            AbsoluteAttitude.availability
+        );
+    }
+
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.stepDetectionProviderId = StepDetection.addEventListener(
+            events => this.onStepEvent(events[0]),
+            this.notifyError,
+            this.name);
+
+        this.absoluteAttitudeProviderId = AbsoluteAttitude.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            this.notifyError,
+            this.name);
+
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        StepDetection.removeEventListener(this.stepDetectionProviderId);
+        AbsoluteAttitude.removeEventListener(this.absoluteAttitudeProviderId);
+    }
+
+    /**
+     * @private
+     */
+    onStepEvent = stepEvent => {
+
+        if (!this.attitudeEvent) {
+            return;
+        }
+
+        const timestamp = stepEvent.timestamp;
+        const stepSize = stepEvent.data.size;
+
+        /**
+         * There is three frames because (device heading != walking direction):
+         *
+         * Device frame (x-Device Right, y-Device Top, z-Device Front)
+         * Navigation frame (x-Nav East, y-Nav North, z-Nav Up)
+         * Earth local frame (x-East y-North z-Up)
+         *
+         *
+         * For the PDR, in order to find the step direction,
+         *  we are looking for the rotation between the device frame and the navigation frame.
+         * Attitude is the rotation from the device frame to the earth local frame.
+         * Misalignment is the rotation from the navigation frame to the earth local frame
+         */
+        const deviceAttitude = this.attitudeEvent.data;
+
+        /**
+         * For optimisation, as we define misalignment to identity, we do not process the quat mulitply formula.
+         */
+        // const deviceInNavFrame = Quaternion.multiply(deviceAttitude.quaternion, this.misalignment);
+        // const deviceDirection = new Attitude(deviceInNavFrame).heading;
+        const deviceDirection = deviceAttitude.heading;
+
+        /**
+         * A bad accuracy from PDR is due to three things:
+         * - Attitude accuracy
+         * - Misalignement (device heading != walking direction)
+         * - Step detection false positives / false negatives
+         * Following formula only use attitude accuracy with cone formula
+         */
+        const deviceDirectionAccuracy = deviceAttitude.accuracy + this.misalignmentError;
+        const accuracy = (stepSize / 2) * Math.sin(deviceDirectionAccuracy / 2);
+
+        /**
+         * Relative position is defined in ENU frame
+         */
+        const position = new GeoRelativePosition(
+            stepSize * Math.sin(deviceDirection),
+            stepSize * Math.cos(deviceDirection),
+            0,
+            timestamp,
+            accuracy
+        );
+
+        this.notify(this.createEvent(
+            EventType.GeoRelativePosition,
+            position,
+            timestamp,
+            [stepEvent, this.attitudeEvent]
+        ));
+    }
+
+}
+
+export default PdrProvider;

package/src/providers/steps/StepDetectionLadetto.js

@@ -0,0 +1,67 @@
+
+// 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 = 1;
+
+
+class StepDetectionLadetto {
+
+    lastVerticalAcc = 0;
+    maxAcceleration = 0;
+    lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+
+    compute(timestamp, linearAcc) {
+
+        let stepDetected = false;
+
+        const verticalAcc = linearAcc[2];
+        const timeInterval = timestamp - this.lastStepTimestamp;
+
+        const upfront = verticalAcc > this.lastVerticalAcc;
+
+        if (upfront) {
+            if (verticalAcc > this.maxAcceleration) {
+                this.maxAcceleration = verticalAcc;
+            }
+        } else if (this.maxAcceleration > VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
+            && timeInterval > MIN_TIME_BETWEEN_STEPS) {
+            this.maxAcceleration = 0;
+
+            const diffTime = timestamp - this.lastStepTimestamp;
+            this.frequency = Math.min(Math.max((1 / diffTime), MIN_FRENQUENCY), MAX_FRENQUENCY);
+
+            stepDetected = true;
+            this.lastStepTimestamp = timestamp;
+        } else {
+            this.maxAcceleration = 0;
+        }
+
+        this.lastVerticalAcc = verticalAcc;
+
+        return stepDetected;
+    }
+
+    get lastStepSize() {
+
+        if (!this.frequency) {
+            return 0;
+        }
+
+        const kParamA = 0.45;
+        const kParamB = 0.2;
+        return kParamA + kParamB * this.frequency;
+    }
+
+    get speed() {
+        return this.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
+    }
+
+}
+
+export default StepDetectionLadetto;

package/src/providers/steps/StepDetectionMinMaxPeaks.js

@@ -0,0 +1,80 @@
+
+// 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 = 1.5;
+const VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -1;
+
+
+class StepDetectionMinMaxPeaks {
+
+    constructor() {
+        this.slidingWindow = [];
+
+        this.lastStepTimestamp = -MIN_TIME_BETWEEN_STEPS;
+    }
+
+
+    compute(timestamp, linearAcc) {
+
+        if (this.lastStepTimestamp && this.lastStepTimestamp + MIN_TIME_BETWEEN_STEPS > timestamp) {
+            return false;
+        }
+
+        let maxValue = Number.MIN_SAFE_INTEGER;
+        let minValue = Number.MAX_SAFE_INTEGER;
+
+        const windowTime = WINDOW_TIME;
+        this.slidingWindow.forEach(function(item, index, object) {
+            if (item.timestamp < timestamp - windowTime) {
+                object.splice(index, 1);
+            } else {
+                maxValue = Math.max(item.verticalAcc, maxValue);
+                minValue = Math.min(item.verticalAcc, minValue);
+            }
+        });
+        this.slidingWindow.push({
+            timestamp: timestamp,
+            verticalAcc: linearAcc[2]
+        });
+
+
+        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.lastStepTimestamp ? this.lastStepSize * this.frequency : 0;
+    }
+
+}
+
+export default StepDetectionMinMaxPeaks;

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/providers/steps/StepDetectionProvider.js

@@ -0,0 +1,100 @@
+import { Constants as GeoConstants } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+import Availability from '../../events/Availability';
+import EventType from '../../events/EventType';
+import Provider from '../Provider';
+import StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2';
+import {
+    Accelerometer, Attitude, Gyroscope
+} from '../../Providers';
+
+class StepDetectionProvider extends Provider {
+
+    constructor() {
+        super();
+        this.stepDetector = new StepDetectionMinMaxPeaks2();
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Availability.merge(
+            Accelerometer.availability,
+            Gyroscope.availability,
+            Attitude.availability
+        );
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.numOfSteps = 0;
+
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            this.notifyError,
+            this.name);
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.angularRateEvent = events[0]),
+            this.notifyError,
+            this.name);
+
+        this.attitudeProviderId = Attitude.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            this.notifyError,
+            this.name);
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+        Attitude.removeEventListener(this.attitudeProviderId);
+    }
+
+    onAccelerometerEvent(accelerationEvent) {
+
+        if (!this.attitudeEvent || !this.angularRateEvent) {
+            return;
+        }
+
+        const { timestamp } = accelerationEvent;
+        const acceleration = accelerationEvent.data;
+
+        /**
+         * Step Detection and Step Size Detection
+         */
+        const linearAcc = this.constructor.computeLinearAcceleration(
+            this.attitudeEvent.data.quaternion, acceleration);
+        const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data);
+
+        if (stepDetected) {
+            const size = this.stepDetector.lastStepSize;
+            this.numOfSteps++;
+            this.notify(this.createEvent(
+                EventType.STEP, {
+                    size,
+                    number: this.numOfSteps
+                },
+                timestamp,
+                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
+            ));
+        }
+    }
+
+    // Linear acceleration in ENU
+    static computeLinearAcceleration(quaternion, acc) {
+        const linearAcc = Quaternion.rotate(Quaternion.inverse(quaternion), acc);
+        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
+        return linearAcc;
+    }
+}
+
+export default StepDetectionProvider;

package/src/smoothers/PositionSmoother.js

@@ -0,0 +1,86 @@
+/* eslint-disable max-statements */
+import { UserPosition } from '@wemap/geo';
+
+class PositionSmoother {
+
+
+    // Generated positions by second
+    static DEFAULT_FREQUENCY = 60;
+
+    // flyby (in second)
+    static DEFAULT_FLYBY_TIME = 1;
+
+
+    /**
+     * @param {Function} callback
+     * @param {Number} frequency in Hz
+     */
+    constructor(callback, frequency = this.constructor.DEFAULT_FREQUENCY) {
+        this.callback = callback;
+        this.positionsQueue = [];
+        this.timeoutPositions = null;
+        this.frequency = frequency;
+    }
+
+    /**
+     * @param {UserPosition} newPosition
+     * @param {Number} flybyTime in seconds
+     */
+    feed(newPosition, flybyTime = this.constructor.DEFAULT_FLYBY_TIME) {
+
+        if (!(newPosition instanceof UserPosition)) {
+            throw new TypeError('newPosition is not instance of UserPosition');
+        }
+
+        if (newPosition.time === null) {
+            throw new Error('newPosition does not have time property');
+        }
+
+        let previousPosition;
+        if (this.positionsQueue.length !== 0) {
+            previousPosition = this.positionsQueue[0];
+            this.positionsQueue = [];
+        } else {
+            previousPosition = this.previousPosition;
+        }
+
+        if (previousPosition) {
+
+            const refTimestamp = newPosition.time;
+            const distance = previousPosition.distanceTo(newPosition);
+            const azimuth = previousPosition.bearingTo(newPosition);
+
+            let i = 1;
+            const nSamples = this.frequency * flybyTime + 1;
+
+            while (i < nSamples + 1) {
+                const smoothedPosition = previousPosition.destinationPoint(distance * i / nSamples, azimuth);
+                smoothedPosition.time = refTimestamp + (i - 1) / this.frequency;
+                smoothedPosition.bearing = newPosition.bearing;
+                smoothedPosition.accuracy += (newPosition.accuracy - smoothedPosition.accuracy) * i / nSamples;
+                this.positionsQueue.push(smoothedPosition);
+                i++;
+            }
+
+            if (this.timeoutNotify) {
+                clearTimeout(this.timeoutNotify);
+            }
+        } else {
+            this.positionsQueue.push(newPosition);
+        }
+
+        this.previousPosition = newPosition;
+        this._notifyNext();
+    }
+
+    _notifyNext = () => {
+        this.callback(this.positionsQueue.shift());
+        if (this.positionsQueue.length !== 0) {
+            this.timeoutNotify = setTimeout(this._notifyNext, 1e3 / this.frequency);
+        } else {
+            delete this.timeoutNotify;
+        }
+    }
+}
+
+export default PositionSmoother;

package/src/smoothers/PositionSmoother.spec.js

@@ -0,0 +1,55 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import {
+    Constants as GeoConstants, Coordinates, UserPosition
+} from '@wemap/geo';
+
+import Smoother from './PositionSmoother';
+
+
+const expect = chai.expect;
+chai.use(chaiAlmost(GeoConstants.EPS_MM));
+
+const positions = [
+    [0, 0, 0, 0],
+    [0.2, 4.5E-6, 1.7E-6, 0],
+    [1.3, 3.6E-5, 3.6E-5, 1],
+    [1.7, 4.0E-5, 3.6E-5, 0],
+    [3.5, 4.0E-5, 3.0E-5, 0],
+    [4, 3.4E-5, 9.0E-6, 0]
+];
+
+const createPosition = i =>
+    new UserPosition(positions[i][1], positions[i][2], null, null, positions[i][0]);
+
+const ratio = 1e-1;
+
+const reducePositionTime = () => positions.forEach(pos => (pos[0] *= ratio));
+
+
+describe('validSmoother', () => {
+
+    it('Last position reached', done => {
+
+        reducePositionTime();
+
+        const lastPosition = createPosition(positions.length - 1);
+        const smoother = new Smoother(position => {
+            if (Coordinates.equalsTo(position, lastPosition)) {
+                done();
+            }
+        }, 60 / ratio);
+
+        positions.forEach((pos, index) => {
+            setTimeout(() => smoother.feed(createPosition(index), ratio), pos[0] * 1e3);
+        });
+    });
+
+    it('Errors', () => {
+        const smoother = new Smoother();
+        expect(() => smoother.feed(new Coordinates(0, 0))).throw(TypeError);
+        expect(() => smoother.feed(new UserPosition(0, 0))).throw(Error);
+    });
+
+});

package/webpack/webpack.common.js

@@ -0,0 +1,20 @@
+module.exports = {
+    module: {
+        rules: [
+            {
+                test: /\.jsx?$/,
+                include: [
+                    /src/,
+                    /wemap-(.*)/
+                ],
+                exclude: /(\/mapbox-gl\/|.test.js|.spec.js|.mock.js)/,
+                use: { loader: 'babel-loader' }
+            },
+            {
+                test: /\.css$/,
+                use: ['style-loader', 'css-loader']
+            }
+        ]
+    },
+    resolve: { extensions: ['.js', '.jsx'] }
+};

package/webpack/webpack.dev.js

@@ -0,0 +1,24 @@
+const merge = require('webpack-merge');
+const path = require('path');
+
+const common = require('./webpack.common.js');
+
+const debugFolder = path.join(__dirname, '../debug');
+
+module.exports = merge(common, {
+    mode: 'development',
+    entry: { 'providers-components': './debug/components/index.js' },
+    output: {
+        publicPath: '/js/',
+        filename: '[name].js',
+        path: path.join(debugFolder, 'js'),
+        libraryTarget: 'global'
+    },
+    devServer: {
+        contentBase: debugFolder,
+        inline: true,
+        hot: true,
+        host: '0.0.0.0',
+        port: 9000
+    }
+});

package/webpack/webpack.prod.js

@@ -0,0 +1,15 @@
+const merge = require('webpack-merge');
+const path = require('path');
+
+const common = require('./webpack.common.js');
+const config = require('../config.json');
+
+module.exports = merge(common, {
+    mode: 'production',
+    entry: './index.js',
+    output: {
+        filename: config.distFileName,
+        path: path.join(__dirname, '../', config.distFolder),
+        libraryTarget: 'commonjs2'
+    }
+});