@wemap/providers 12.10.8 → 12.10.9

package/src/providers/position/relative/GeoRelativePositionFromArCoreProvider.ts

@@ -1,82 +0,0 @@
-import { GeoRelativePosition, RelativePosition } from '@wemap/geo';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import AbsoluteAttitudeProvider from '../../attitude/absolute/AbsoluteAttitudeProvider.js';
-import ArCoreProvider, { ArCoreEvent } from '../../vision/ArCoreProvider.js';
-import { AbsoluteAttitude, RelativeAttitude } from '../../../events/Types.js';
-
-class GeoRelativePositionFromArCoreProvider extends Provider<GeoRelativePosition> {
-
-    absoluteAttitudeProviderId?: number;
-    arCoreProviderId?: number;
-    absoluteAttitudeEvent?: AbsoluteAttitude;
-
-    getName = () => 'GeoRelativePositionFromArCore';
-
-    availability() {
-        return AvailabilityHelper.every([
-            ArCoreProvider.getAvailability(),
-            AbsoluteAttitudeProvider.getAvailability()
-        ]);
-    }
-
-    start() {
-
-        this.arCoreProviderId = ArCoreProvider.addEventListener(
-            this.onArCoreEvents,
-            this.notifyError
-        );
-
-        this.absoluteAttitudeProviderId = AbsoluteAttitudeProvider.addEventListener(
-            event => this.absoluteAttitudeEvent = event,
-            this.notifyError
-        );
-    }
-
-    stop() {
-        ArCoreProvider.removeEventListener(this.arCoreProviderId);
-        AbsoluteAttitudeProvider.removeEventListener(this.absoluteAttitudeProviderId);
-    }
-
-    onArCoreEvents = (event: ArCoreEvent) => {
-        const relativeAttitudeEvent = event.relativeAttitude;
-        const relativePositionEvent = event.relativePosition;
-
-        if (relativeAttitudeEvent && relativePositionEvent && this.absoluteAttitudeEvent) {
-            this.compute(relativePositionEvent, relativeAttitudeEvent, this.absoluteAttitudeEvent);
-        }
-    }
-
-    compute(
-        relativePosition: RelativePosition,
-        relativeAttitude: RelativeAttitude,
-        absoluteAttitude: AbsoluteAttitude
-    ) {
-
-        const rotation = absoluteAttitude.heading - relativeAttitude.heading;
-
-        /**
-         * Here, we transform "relativePosition" which is defined in ArCore frame to a relative "position" defined in ENU frame
-         */
-        const east = Math.cos(rotation) * relativePosition.x - Math.sin(rotation) * relativePosition.z;
-        const north = -Math.sin(rotation) * relativePosition.x - Math.cos(rotation) * relativePosition.z;
-        const up = relativePosition.y;
-
-        /**
-         * Relative position is defined in ENU frame
-         */
-        const position = new GeoRelativePosition(
-            east,
-            north,
-            up,
-            relativePosition.time,
-            0,
-            absoluteAttitude.heading
-        );
-
-        this.notify(position);
-    }
-}
-
-export default new GeoRelativePositionFromArCoreProvider();

package/src/providers/position/relative/GeoRelativePositionProvider.ts

@@ -1,35 +0,0 @@
-import { GeoRelativePosition } from '@wemap/geo';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import GeoRelativePositionFromArCoreProvider from './GeoRelativePositionFromArCoreProvider.js';
-import PdrProvider from './PdrProvider.js';
-
-
-class GeoRelativePositionProvider extends Provider<GeoRelativePosition> {
-
-    providerId?: number;
-    geoRelativeProvider?: Provider<GeoRelativePosition>;
-
-    getName = () => 'GeoRelativePosition';
-
-    availability() {
-        return AvailabilityHelper.some([
-            PdrProvider.getAvailability(),
-            GeoRelativePositionFromArCoreProvider.getAvailability()
-        ]);
-    }
-
-    async start() {
-        const availabilityError = await GeoRelativePositionFromArCoreProvider.getAvailability();
-        this.geoRelativeProvider = availabilityError ? PdrProvider : GeoRelativePositionFromArCoreProvider;
-        this.providerId = this.geoRelativeProvider.addEventListener(this.notify, this.notifyError);
-    }
-
-    stop() {
-        this.geoRelativeProvider?.removeEventListener(this.providerId);
-        delete this.geoRelativeProvider;
-    }
-}
-
-export default new GeoRelativePositionProvider();

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

@@ -1,107 +0,0 @@
-import { GeoRelativePosition } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
-
-import Provider from '../../Provider.js';
-import AvailabilityHelper from '../../../events/AvailabilityHelper.js';
-import StepProvider from '../../steps/StepProvider.js';
-import AbsoluteAttitudeProvider from '../../attitude/absolute/AbsoluteAttitudeProvider.js';
-import { Step, AbsoluteAttitude } from '../../../events/Types.js';
-
-
-class PdrProvider extends Provider<GeoRelativePosition> {
-
-    private absoluteAttitudeProviderId?: number;
-    private stepDetectionProviderId?: number;
-    private attitudeEvent?: AbsoluteAttitude;
-
-    // https://ieeexplore.ieee.org/document/7346766
-    // private misalignment = [1, 0, 0, 0];
-    private misalignmentError = deg2rad(3);
-
-    getName = () => 'Pdr';
-
-    availability() {
-        return AvailabilityHelper.every([
-            StepProvider.getAvailability(),
-            AbsoluteAttitudeProvider.getAvailability()
-        ]);
-    }
-
-
-    start() {
-
-        this.stepDetectionProviderId = StepProvider.addEventListener(
-            this.onStepEvent,
-            this.notifyError
-        );
-
-        this.absoluteAttitudeProviderId = AbsoluteAttitudeProvider.addEventListener(
-            event => (this.attitudeEvent = event),
-            this.notifyError
-        );
-
-    }
-
-    stop() {
-        StepProvider.removeEventListener(this.stepDetectionProviderId);
-        AbsoluteAttitudeProvider.removeEventListener(this.absoluteAttitudeProviderId);
-    }
-
-    private onStepEvent = (stepEvent: Step) => {
-
-        if (!this.attitudeEvent) {
-            return;
-        }
-
-        const stepSize = stepEvent.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;
-
-        /**
-         * 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);
-        const timestamp = deviceAttitude.time;
-
-        /**
-         * Relative position is defined in ENU frame
-         */
-        const position = new GeoRelativePosition(
-            stepSize * Math.sin(deviceDirection),
-            stepSize * Math.cos(deviceDirection),
-            0,
-            timestamp,
-            accuracy,
-            deviceDirection
-        );
-
-        this.notify(position);
-    }
-}
-
-export default new PdrProvider();

package/src/providers/steps/StepDetectionLadetto.ts

@@ -1,67 +0,0 @@
-import { Vector3_t } from "@wemap/maths";
-
-class StepDetectionLadetto {
-
-    
-    static MIN_TIME_BETWEEN_STEPS = 0.4; // in seconds
-
-    static MAX_FRENQUENCY = 4; // in Hz
-    static MIN_FRENQUENCY = 1; // in Hz
-
-    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1; // in m.s-2
-
-
-    frequency = 0;
-
-    lastVerticalAcc = 0;
-    maxAcceleration = 0;
-    lastStepTimestamp = -StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS;
-
-    compute(timestamp: number, linearAcc: Vector3_t) {
-
-        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 > StepDetectionLadetto.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && timeInterval > StepDetectionLadetto.MIN_TIME_BETWEEN_STEPS) {
-            this.maxAcceleration = 0;
-
-            const diffTime = timestamp - this.lastStepTimestamp;
-            this.frequency = Math.min(Math.max((1 / diffTime), StepDetectionLadetto.MIN_FRENQUENCY), StepDetectionLadetto.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.ts

@@ -1,70 +0,0 @@
-import { Vector3_t } from "@wemap/maths";
-
-
-class StepDetectionMinMaxPeaks {
-
-    static WINDOW_TIME = 0.3; // in seconds
-    static MIN_TIME_BETWEEN_STEPS = 0.4; // in seconds
-    static MAX_FRENQUENCY = 4; // in Hz
-    static MIN_FRENQUENCY = 1; // in Hz
-    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 1.5; // in m.s-2
-    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -1; // in m.s-2
-
-    frequency = 0;
-    lastStepTimestamp = -StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS;
-    slidingWindow: { timestamp: number, verticalAcc: number }[] = [];
-
-    compute(timestamp: number, linearAcc: Vector3_t) {
-
-        if (this.lastStepTimestamp && this.lastStepTimestamp + StepDetectionMinMaxPeaks.MIN_TIME_BETWEEN_STEPS > timestamp) {
-            return false;
-        }
-
-        let maxValue = Number.MIN_SAFE_INTEGER;
-        let minValue = Number.MAX_SAFE_INTEGER;
-
-        const windowTime = StepDetectionMinMaxPeaks.WINDOW_TIME;
-        this.slidingWindow.forEach((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 > StepDetectionMinMaxPeaks.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && minValue < StepDetectionMinMaxPeaks.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
-
-            const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
-            this.frequency = Math.min(Math.max((1 / timeInterval), StepDetectionMinMaxPeaks.MIN_FRENQUENCY), StepDetectionMinMaxPeaks.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.ts

@@ -1,99 +0,0 @@
-import { Vector3_t } from "@wemap/maths";
-
-class StepDetectionMinMaxPeaks2 {
-
-    static WINDOW_TIME = 0.3; // in seconds
-    static MIN_TIME_BETWEEN_STEPS = 0.4; // in seconds
-    static MAX_FRENQUENCY = 4; // in Hz
-    static MIN_FRENQUENCY = 1; // in Hz
-    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.75; // in m.s-2
-    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.3; // in m.s-2
-
-    frequency = 0;
-    influence = 0.2;
-
-    slidingWindow: { timestamp: number, verticalAcc: number }[] = [];
-    lastStepTimestamp = -StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS;
-    previousVerticalAcc = 0;
-
-    compute(timestamp: number, linearAcc: Vector3_t, angularRate: Vector3_t) {
-
-        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 + StepDetectionMinMaxPeaks2.MIN_TIME_BETWEEN_STEPS > timestamp) {
-            return false;
-        }
-
-        let maxValue = Number.MIN_SAFE_INTEGER;
-        let minValue = Number.MAX_SAFE_INTEGER;
-
-        this.slidingWindow.forEach((item, index, object) => {
-            if (item.timestamp < timestamp - StepDetectionMinMaxPeaks2.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 > StepDetectionMinMaxPeaks2.VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD
-            && minValue < StepDetectionMinMaxPeaks2.VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD) {
-
-            const timeInterval = this.lastStepTimestamp ? timestamp - this.lastStepTimestamp : 1;
-            this.frequency = Math.min(Math.max((1 / timeInterval), StepDetectionMinMaxPeaks2.MIN_FRENQUENCY), StepDetectionMinMaxPeaks2.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: { verticalAcc: number }[]) {
-        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: { verticalAcc: number }[]) {
-        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/StepDetectionMinMaxPeaks3.ts

@@ -1,192 +0,0 @@
-import { Vector3_t } from "@wemap/maths";
-
-class StepDetectionMinMaxPeaks3 {
-
-    static WINDOW_TIME = 0.6; // in seconds
-    static MIN_TIME_BETWEEN_STEPS = 0.6; // in seconds
-    static MAX_FRENQUENCY = 4; // in Hz
-    static MIN_FRENQUENCY = 1; // in Hz
-    static VERTICAL_ACC_POSITIVE_PEAK_THRESHOLD = 0.2; // in m.s-2
-    static VERTICAL_ACC_NEGATIVE_PEAK_THRESHOLD = -0.1; // in m.s-2
-
-    frequency = 0;
-    influence = 0.05;
-
-    slidingWindow: { timestamp: number, verticalAcc: number }[] = [];
-    lastStepTimestamp = -StepDetectionMinMaxPeaks3.MIN_TIME_BETWEEN_STEPS;
-    previousVerticalAcc = 0;
-    previousHorizontalAcc = 0;
-
-
-    compute(timestamp: number, linearAcc: Vector3_t) {
-
-        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((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: number[]) {
-        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: number[]) {
-        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;