@wemap/providers 9.1.1 → 9.2.0

package/index.js

@@ -36,6 +36,7 @@ export { default as Inclination } from './src/providers/inclination/Inclination.
 export { default as StepDetector } from './src/providers/steps/StepDetector.js';
 export { default as StraightLineDetector } from './src/providers/steps/StraightLineDetector.js';
 export { default as StepDetectionMinMaxPeaks2 } from './src/providers/steps/StepDetectionMinMaxPeaks2.js';
+export { default as StepDetectionMinMaxPeaks3 } from './src/providers/steps/StepDetectionMinMaxPeaks3.js';
 
 export { default as Pdr } from './src/providers/position/relative/Pdr.js';
 export { default as GeoRelativePositionFromArCore } from './src/providers/position/relative/GeoRelativePositionFromArCore.js';

package/package.json

@@ -8,14 +8,14 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/camera": "^9.0.8",
-    "@wemap/geo": "^9.1.1",
+    "@wemap/camera": "^9.2.0",
+    "@wemap/geo": "^9.2.0",
     "@wemap/geomagnetism": "^0.1.1",
-    "@wemap/logger": "^9.0.0",
-    "@wemap/map": "^9.1.1",
+    "@wemap/logger": "^9.2.0",
+    "@wemap/map": "^9.2.0",
     "@wemap/maths": "^9.0.0",
-    "@wemap/osm": "^9.1.1",
-    "@wemap/routers": "^9.1.1",
+    "@wemap/osm": "^9.2.0",
+    "@wemap/routers": "^9.2.0",
     "@wemap/utils": "^9.0.0"
   },
   "description": "A package using different geoloc systems",
@@ -42,6 +42,6 @@
     "url": "git+https://github.com/wemap/wemap-modules-js.git"
   },
   "type": "module",
-  "version": "9.1.1",
-  "gitHead": "bf6a54cf4f886ebac773549339ada8f98c0b7f7f"
+  "version": "9.2.0",
+  "gitHead": "9eee407fadd76fc5cbfbeeb13be0d74391ca5d9e"
 }

package/src/providers/steps/StepDetectionMinMaxPeaks3.js

@@ -0,0 +1,201 @@
+/* eslint-disable max-statements */
+class StepDetectionMinMaxPeaks3 {
+
+    // in seconds
+    static WINDOW_TIME = 0.6;
+
+    // in seconds
+    static MIN_TIME_BETWEEN_STEPS = 0.6;
+
+    // in Hz
+    static MAX_FRENQUENCY = 4;
+    static MIN_FRENQUENCY = 1;
+
+    // in m.s-2
+    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.2;
+    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.1;
+
+
+    constructor() {
+        this.slidingWindow = [];
+
+        this.lastStepTimestamp = -StepDetectionMinMaxPeaks3.MIN_TIME_BETWEEN_STEPS;
+        this.previousVerticalAcc = 0;
+        this.previousHorizontalAcc = 0;
+        this.influence = 0.05;
+    }
+
+
+    compute(timestamp, linearAcc) {
+
+        const verticalAcc = this.influence * linearAcc[2] + (1 - this.influence) * this.previousVerticalAcc;
+        this.previousVerticalAcc = verticalAcc;
+
+        // let horizontalAcc = Math.sqrt(linearAcc[0] ** 2 + linearAcc[1] ** 2);
+        // horizontalAcc = this.influence * horizontalAcc + (1 - this.influence) * this.previousHorizontalAcc;
+        // this.previousHorizontalAcc = horizontalAcc;
+
+        // const angularRateNorm = Math.sqrt(angularRate[0] ** 2 + angularRate[1] ** 2 + angularRate[2] ** 2);
+        // horizontalAcc = this.influence * horizontalAcc + (1 - this.influence) * this.previousHorizontalAcc;
+        // this.previousangularRateNorm = angularRateNorm;
+
+        // Update sliding window
+        this.slidingWindow = this.slidingWindow.filter(item =>
+            item.timestamp >= timestamp - StepDetectionMinMaxPeaks3.WINDOW_TIME
+        );
+        this.slidingWindow.push({ timestamp, verticalAcc });
+        // , horizontalAcc });
+
+        // this.horizontalAccStd = this.stddev(this.slidingWindow.map(el => el.horizontalAcc));
+        // this.verticalAccStd = this.stddev(this.slidingWindow.map(el => el.verticalAcc));
+
+
+        const isTooEarlyForANewStep = this.lastStepTimestamp
+            && this.lastStepTimestamp + StepDetectionMinMaxPeaks3.MIN_TIME_BETWEEN_STEPS > timestamp;
+        if (isTooEarlyForANewStep) {
+            return false;
+        }
+
+        // Looking for max peak
+        let maxValue = Number.MIN_VALUE;
+        let maxValueIdx = -1;
+        let foundMaxPeakHigherThanThreshold = false;
+        this.slidingWindow.forEach(function(item, idx) {
+            if (item.verticalAcc > maxValue
+                && item.verticalAcc >= StepDetectionMinMaxPeaks3.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD) {
+                maxValue = item.verticalAcc;
+                maxValueIdx = idx;
+                foundMaxPeakHigherThanThreshold = true;
+            }
+        });
+        if (!foundMaxPeakHigherThanThreshold) {
+            return false;
+        }
+
+        // Looking for a value lower than a threshold before the max peak
+        let hasLowNegativeValueBeforeMaxPeak = false;
+        let minValueBeforeMaxPeak = Number.MAX_VALUE;
+        for (let i = 0; i < maxValueIdx; i++) {
+            const curValue = this.slidingWindow[i].verticalAcc;
+            minValueBeforeMaxPeak = Math.min(minValueBeforeMaxPeak, curValue);
+            if (curValue < StepDetectionMinMaxPeaks3.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
+                hasLowNegativeValueBeforeMaxPeak = true;
+                break;
+            }
+        }
+        if (!hasLowNegativeValueBeforeMaxPeak) {
+            return false;
+        }
+
+        // looking for another minimum after max peak
+        const diffMinMax = maxValue - minValueBeforeMaxPeak;
+        const targetValue = maxValue - 0.5 * diffMinMax;
+        let targetValueFoundAfterMaxPeak = false;
+        for (let i = maxValueIdx + 1; i < this.slidingWindow.length; i++) {
+            if (this.slidingWindow[i].verticalAcc <= targetValue) {
+                targetValueFoundAfterMaxPeak = true;
+                break;
+            }
+        }
+        if (!targetValueFoundAfterMaxPeak) {
+            return false;
+        }
+
+        // // looking for another local minimum / maximum after 100ms
+        // let localMinimumFound = false;
+        // let localMaximumFound = false;
+        // let localMaxiumValue = Number.MIN_SAFE_INTEGER;
+        // let localMinimumVal = null;
+        // const maxPeakTimestamp = this.slidingWindow[maxValueIdx].timestamp;
+        // for (let i = maxValueIdx + 1; i < this.slidingWindow.length; i++) {
+        //     const curVal = this.slidingWindow[i];
+        //     const prevVal = this.slidingWindow[i - 1];
+
+        //     if (curVal.timestamp > maxPeakTimestamp + 0.4) {
+        //         break;
+        //     }
+
+        //     if (!localMinimumFound) {
+        //         // if (curVal.timestamp < maxPeakTimestamp + 0.05) {
+        //         //     // too early
+        //         //     continue;
+        //         // }
+
+        //         if (curVal.verticalAcc > prevVal.verticalAcc) {
+        //             localMinimumFound = true;
+        //             localMinimumVal = prevVal;
+        //         }
+        //         continue;
+        //     }
+
+        //     if (!localMaximumFound) {
+
+        //         // if (curVal.timestamp < localMinimumVal.timestamp + 0.05) {
+        //         //     // too early
+        //         //     continue;
+        //         // }
+
+        //         if (curVal.verticalAcc < prevVal.verticalAcc) {
+        //             localMaximumFound = true;
+        //             localMaxiumValue = prevVal.verticalAcc;
+        //             break;
+        //         }
+        //     }
+        // }
+        // const localMinMaxFoundAfterPeak = localMinimumFound && localMaximumFound;
+        // // && localMaxiumValue / maxValue < 0.8;
+        // // if (!localMinMaxFoundAfterPeak) {
+        // //     return false;
+        // // }
+
+
+        // const highRotationDetected = angularRateNorm > 0.75;
+        // // if (highRotationDetected) {
+        // //     return false;
+        // // }
+
+        const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
+        this.frequency = Math.min(Math.max((1 / timeInterval), StepDetectionMinMaxPeaks3.MIN_FRENQUENCY), StepDetectionMinMaxPeaks3.MAX_FRENQUENCY);
+
+        this.lastStepTimestamp = timestamp;
+        return true;
+
+    }
+
+    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];
+        }
+        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] - theMean) ** 2;
+        }
+
+        return Math.sqrt(standardDeviation / data.length);
+    }
+}
+
+export default StepDetectionMinMaxPeaks3;

package/src/providers/steps/StepDetector.js

@@ -6,7 +6,10 @@ import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeF
 import Accelerometer from '../imu/Accelerometer.js';
 import Gyroscope from '../imu/Gyroscope.js';
 import Provider from '../Provider.js';
+import StepDetectionLadetto from './StepDetectionLadetto.js';
+import StepDetectionMinMaxPeaks from './StepDetectionMinMaxPeaks.js';
 import StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2.js';
+import StepDetectionMinMaxPeaks3 from './StepDetectionMinMaxPeaks3.js';
 
 
 class StepDetector extends Provider {
@@ -14,11 +17,19 @@ class StepDetector extends Provider {
     /** @type {number} */
     static DEFAULT_STEP_SIZE_MULTIPLIER = 1;
 
+    // ladetto, minMaxPeaks, minMaxPeaks2, minMaxPeaks3
+    static DEFAULT_ALGORITHM = 'minMaxPeaks3';
+
     _stepSizeMultiplier = StepDetector.DEFAULT_STEP_SIZE_MULTIPLIER;
 
+    /** @type {string} */
+    _algorithm = StepDetector.DEFAULT_ALGORITHM;
+
+    _accValues = [];
+
     constructor() {
         super();
-        this.stepDetector = new StepDetectionMinMaxPeaks2();
+        this.algorithm = this._algorithm;
     }
 
     /**
@@ -115,6 +126,26 @@ class StepDetector extends Provider {
     get stepSizeMultiplier() {
         return this._stepSizeMultiplier;
     }
+
+    set algorithm(algorithm) {
+        switch (algorithm) {
+        case 'ladetto':
+            this.stepDetector = new StepDetectionLadetto();
+            break;
+        case 'minMaxPeaks':
+            this.stepDetector = new StepDetectionMinMaxPeaks();
+            break;
+        case 'minMaxPeaks2':
+            this.stepDetector = new StepDetectionMinMaxPeaks2();
+            break;
+        case 'minMaxPeaks3':
+        default:
+            algorithm = 'minMaxPeaks3';
+            this.stepDetector = new StepDetectionMinMaxPeaks3();
+            break;
+        }
+        this._algorithm = algorithm;
+    }
 }
 
 export default new StepDetector();

package/src/providers/steps/StepDetectorLadetto.js

@@ -0,0 +1,108 @@
+import { Constants as GeoConstants } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeFromInertial.js';
+import Accelerometer from '../imu/Accelerometer.js';
+import Gyroscope from '../imu/Gyroscope.js';
+import Provider from '../Provider.js';
+import StepDetectionLadetto from './StepDetectionLadetto.js';
+
+
+class StepDetectorLadetto extends Provider {
+
+    constructor() {
+        super();
+        this.stepDetector = new StepDetectionLadetto();
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'StepDetectorLadetto';
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Promise.all([
+            Accelerometer.availability,
+            Gyroscope.availability,
+            RelativeAttitudeFromInertial.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.numOfSteps = 0;
+
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.angularRateEvent = events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.attitudeProviderId = RelativeAttitudeFromInertial.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+        RelativeAttitudeFromInertial.removeEventListener(this.attitudeProviderId);
+    }
+
+    onAccelerometerEvent(accelerationEvent) {
+
+        if (!this.attitudeEvent || !this.angularRateEvent) {
+            return;
+        }
+
+        const {
+            values: acceleration, timestamp
+        } = 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.values);
+
+        if (stepDetected) {
+            const size = this.stepDetector.lastStepSize;
+            this.numOfSteps++;
+            this.notify(this.createEvent(
+                EventType.Step, {
+                    size,
+                    number: this.numOfSteps
+                },
+                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
+            ));
+        }
+    }
+
+    // Linear acceleration in ENU
+    static computeLinearAcceleration(quaternion, acc) {
+        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
+        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
+        return linearAcc;
+    }
+
+}
+
+export default new StepDetectorLadetto();

package/src/providers/steps/StepDetectorMinMaxPeaks.js

@@ -0,0 +1,108 @@
+import { Constants as GeoConstants } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeFromInertial.js';
+import Accelerometer from '../imu/Accelerometer.js';
+import Gyroscope from '../imu/Gyroscope.js';
+import Provider from '../Provider.js';
+import StepDetectionMinMaxPeaks from './StepDetectionMinMaxPeaks.js';
+
+
+class StepDetectorMinMaxPeaks extends Provider {
+
+    constructor() {
+        super();
+        this.stepDetector = new StepDetectionMinMaxPeaks();
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'StepDetectorMinMaxPeaks';
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Promise.all([
+            Accelerometer.availability,
+            Gyroscope.availability,
+            RelativeAttitudeFromInertial.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.numOfSteps = 0;
+
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.angularRateEvent = events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.attitudeProviderId = RelativeAttitudeFromInertial.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+        RelativeAttitudeFromInertial.removeEventListener(this.attitudeProviderId);
+    }
+
+    onAccelerometerEvent(accelerationEvent) {
+
+        if (!this.attitudeEvent || !this.angularRateEvent) {
+            return;
+        }
+
+        const {
+            values: acceleration, timestamp
+        } = 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.values);
+
+        if (stepDetected) {
+            const size = this.stepDetector.lastStepSize;
+            this.numOfSteps++;
+            this.notify(this.createEvent(
+                EventType.Step, {
+                    size,
+                    number: this.numOfSteps
+                },
+                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
+            ));
+        }
+    }
+
+    // Linear acceleration in ENU
+    static computeLinearAcceleration(quaternion, acc) {
+        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
+        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
+        return linearAcc;
+    }
+
+}
+
+export default new StepDetectorMinMaxPeaks();

package/src/providers/steps/StepDetectorMinMaxPeaks2.js

@@ -0,0 +1,108 @@
+import { Constants as GeoConstants } from '@wemap/geo';
+import { Quaternion } from '@wemap/maths';
+
+import EventType from '../../events/EventType.js';
+import RelativeAttitudeFromInertial from '../attitude/relative/RelativeAttitudeFromInertial.js';
+import Accelerometer from '../imu/Accelerometer.js';
+import Gyroscope from '../imu/Gyroscope.js';
+import Provider from '../Provider.js';
+import StepDetectionMinMaxPeaks2 from './StepDetectionMinMaxPeaks2.js';
+
+
+class StepDetectorMinMaxPeaks2 extends Provider {
+
+    constructor() {
+        super();
+        this.stepDetector = new StepDetectionMinMaxPeaks2();
+    }
+
+    /**
+    * @override
+    */
+    static get pname() {
+        return 'StepDetectorMinMaxPeaks2';
+    }
+
+    /**
+     * @override
+     */
+    get _availability() {
+        return Promise.all([
+            Accelerometer.availability,
+            Gyroscope.availability,
+            RelativeAttitudeFromInertial.availability
+        ]);
+    }
+
+    /**
+     * @override
+     */
+    start() {
+
+        this.numOfSteps = 0;
+
+        this.accelerometerProviderId = Accelerometer.addEventListener(
+            events => this.onAccelerometerEvent(events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.gyroscopeProviderId = Gyroscope.addEventListener(
+            events => (this.angularRateEvent = events[0]),
+            error => this.notifyError(error)
+        );
+
+        this.attitudeProviderId = RelativeAttitudeFromInertial.addEventListener(
+            events => (this.attitudeEvent = events[0]),
+            error => this.notifyError(error)
+        );
+    }
+
+    /**
+     * @override
+     */
+    stop() {
+        Accelerometer.removeEventListener(this.accelerometerProviderId);
+        Gyroscope.removeEventListener(this.gyroscopeProviderId);
+        RelativeAttitudeFromInertial.removeEventListener(this.attitudeProviderId);
+    }
+
+    onAccelerometerEvent(accelerationEvent) {
+
+        if (!this.attitudeEvent || !this.angularRateEvent) {
+            return;
+        }
+
+        const {
+            values: acceleration, timestamp
+        } = 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.values);
+
+        if (stepDetected) {
+            const size = this.stepDetector.lastStepSize;
+            this.numOfSteps++;
+            this.notify(this.createEvent(
+                EventType.Step, {
+                    size,
+                    number: this.numOfSteps
+                },
+                [accelerationEvent, this.angularRateEvent, this.attitudeEvent]
+            ));
+        }
+    }
+
+    // Linear acceleration in ENU
+    static computeLinearAcceleration(quaternion, acc) {
+        const linearAcc = Quaternion.rotateMatlab(Quaternion.inverse(quaternion), acc);
+        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
+        return linearAcc;
+    }
+
+}
+
+export default new StepDetectorMinMaxPeaks2();