@wemap/providers 9.2.0 → 10.0.0-alpha.1

package/index.d.ts

@@ -1,23 +1,82 @@
 import { Calibration } from "@wemap/camera";
-import { Coordinates } from "@wemap/geo";
+import {
+    Attitude, AttitudeJson,
+    UserPosition, UserPositionJson
+} from "@wemap/geo";
 import { Quaternion_t } from "@wemap/maths";
+import { UserAgentWithDetails } from "@wemap/utils";
 
 declare module '@wemap/providers' {
 
+    export type CoarsePoseJson = {
+        attitude?: AttitudeJson,
+        position?: UserPositionJson,
+    };
+
+    export type CoarsePose = {
+        attitude?: Attitude,
+        position?: UserPosition,
+    };
+
+    export type VpsMetadataJson = {
+        size: [number, number], // [width, height]
+        calibration?: Calibration,
+        time?: number,
+        coarse?: CoarsePoseJson,
+        userAgent?: UserAgentWithDetails
+    }
+
     export class VpsMetadata {
 
         size: { width: number, height: number };
         calibration?: Calibration;
         time?: number;
-        coarse: {
-            attitude?: Quaternion_t,
-            position: Coordinates,
-            positionAccuracy: number
-        }
-
-        toJson(): object;
-        static fromJson(json: object): VpsMetadata;
+        coarse?: CoarsePose;
+        userAgent?: UserAgentWithDetails;
+
+        toJson(): VpsMetadataJson;
+        static fromJson(json: VpsMetadataJson): VpsMetadata;
+    }
+
+    export type VpsRequestJson = VpsMetadataJson & {
+        image: string
+    }
+
+    export class VpsRequest {
+        image: string;
+        metadata: VpsMetadata;
+
+        toJson(): VpsRequestJson;
+        static fromJson(json: VpsRequestJson): VpsRequest
     }
 
+    export type VpsResponseJson = {
+        attitude: AttitudeJson,
+        coordinates: UserPositionJson
+    }
+
+    export class VpsResponse {
+        attitude: Attitude;
+        coordinates: UserPosition;
+
+        toJson(): VpsResponseJson;
+        static fromJson(json: VpsResponseJson): VpsResponse;
+    }
+
+    export class ImageRelocalization {
+
+        static _prepareRequest(
+            imageCanvas: HTMLCanvasElement,
+            calibration?: Calibration,
+            coarsePose?: CoarsePose
+        ): VpsRequest
+
+        static relocalize(
+            endpointUrl: string, imageCanvas: HTMLCanvasElement,
+            calibration?: Calibration, coarsePose?: CoarsePose
+        ): Promise<VpsResponse>;
+
+        static getHeadingFromQuaternion(quaternion: Quaternion_t): number;
+    }
 }
 

package/index.js

@@ -9,7 +9,9 @@ export { default as MapMatchingHandler } from './src/mapmatching/MapMatchingHand
 export { default as PositionSmoother } from './src/smoothers/PositionSmoother.js';
 export { default as AttitudeSmoother } from './src/smoothers/AttitudeSmoother.js';
 
-export { default as VpsMetadata } from './src/providers/vision/VpsMetadata.js';
+export { default as VpsMetadata } from './src/providers/vision/vps/VpsMetadata.js';
+export { default as VpsRequest } from './src/providers/vision/vps/VpsRequest.js';
+export { default as VpsResponse } from './src/providers/vision/vps/VpsResponse.js';
 
 export { default as ProvidersLoggerOld } from './src/events/ProvidersLoggerOld.js';
 
@@ -35,8 +37,6 @@ 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';
@@ -48,8 +48,8 @@ export { default as Ip } from './src/providers/position/absolute/Ip.js';
 export { default as AbsolutePosition } from './src/providers/position/absolute/AbsolutePosition.js';
 
 export { default as ArCore } from './src/providers/vision/ArCore.js';
-export { default as ImageRelocalization } from './src/providers/vision/ImageRelocalization.js';
-export { default as Vps } from './src/providers/vision/Vps.js';
+export { default as ImageRelocalization } from './src/providers/vision/vps/ImageRelocalization.js';
+export { default as Vps } from './src/providers/vision/vps/Vps.js';
 export { default as Barcode } from './src/providers/vision/Barcode.js';
 
 export { default as CameraNative } from './src/providers/others/CameraNative.js';

package/package.json

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

package/src/mapmatching/MapMatchingHandler.js

@@ -1,6 +1,6 @@
 /* eslint-disable max-statements */
 import {
-    AbsoluteHeading, GraphEdge, Level, MapMatching, Network, GraphProjection, UserPosition
+    AbsoluteHeading, GraphEdge, MapMatching, Network, GraphProjection, UserPosition
 } from '@wemap/geo';
 import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
 import { Itinerary } from '@wemap/routers';
@@ -35,55 +35,28 @@ class MapMatchingHandler extends Provider {
     static DEFAULT_USE_ITINERARY_START_AS_POSITION = false;
 
     /** @type {boolean} */
-    static DEFAULT_USE_ORIENTATION_MATCHING = true;
+    static ORIENTATION_MATCHING = true;
 
     /** @type {number} in meters */
-    static DEFAULT_MM_HUGE_JUMP_DISTANCE = 3;
-
-    /** @type {number} in meters */
-    static DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE = 2;
+    static MM_HUGE_JUMP_DISTANCE = 3;
 
     /** @type {number} */
-    static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
+    static MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
 
     /** @type {number} */
-    static DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
+    static MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
 
     /** @type {number} */
-    static DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE = 3;
+    static LAST_PROJECTIONS_WINDOW_SIZE = 3;
 
     /** @type {number} */
-    static DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
+    static LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3);
 
     /** @type {MapMatching} */
     _mapMatching;
 
     /** @type {number} */
-    _mapMatchingMinDistance = MapMatchingHandler.DEFAULT_MM_MIN_DIST;
-
-    /** @type {boolean} */
-    _useItineraryStartAsPosition = MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION;
-
-    /** @type {boolean} */
-    _useOrientationMatching = MapMatchingHandler.DEFAULT_USE_ORIENTATION_MATCHING;
-
-    /** @type {number} */
-    _hugeJumpDistance = MapMatchingHandler.DEFAULT_MM_HUGE_JUMP_DISTANCE;
-
-    /** @type {number} */
-    _disableMMCloseToATurnDistance = MapMatchingHandler.DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE;
-
-    /** @type {number} */
-    _minStepsBetweenOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING;
-
-    /** @type {number} */
-    _minStepsForOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING;
-
-    /** @type {number} */
-    _lastProjectionsWindowSize = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE;
-
-    /** @type {number} */
-    _lastProjectionsEdgeAngleThreshold = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD;
+    _mapMatchingMinDistance;
 
     /** @type {boolean} */
     _internalProvidersStarted = false;
@@ -113,6 +86,8 @@ class MapMatchingHandler extends Provider {
         this._mapMatching = new MapMatching();
         this._mapMatching.maxDistance = MapMatchingHandler.DEFAULT_MM_MAX_DIST;
         this._mapMatching.maxAngleBearing = MapMatchingHandler.DEFAULT_MM_MAX_ANGLE;
+        this._mapMatchingMinDistance = MapMatchingHandler.DEFAULT_MM_MIN_DIST;
+        this._useItineraryStartAsPosition = MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION;
     }
 
     /**
@@ -304,7 +279,7 @@ class MapMatchingHandler extends Provider {
 
         // newPosition must not be used after this line
 
-        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > this._hugeJumpDistance;
+        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
 
         // In case of a huge jump, be sure the user is in a straight line
         if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
@@ -346,11 +321,11 @@ class MapMatchingHandler extends Provider {
         if (projection) {
             this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
             this._lastProjections.push(projection);
-            if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+            if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
                 this._lastProjections.shift();
             }
 
-            const thisWillBeAHugeJump = projection.distanceFromNearestElement > this._hugeJumpDistance;
+            const thisWillBeAHugeJump = projection.distanceFromNearestElement > MapMatchingHandler.MM_HUGE_JUMP_DISTANCE;
 
             // In case of a huge jump, be sure the user is in a straight line
             if (thisWillBeAHugeJump && !StraightLineDetector.isStraight()) {
@@ -370,13 +345,6 @@ class MapMatchingHandler extends Provider {
                 return true;
             }
 
-            // Detector to avoid map-matching close to network turns
-            if (this._disableMMCloseToATurnDistance > 0
-                && this._hasTurnInCircle(projection.projection, this._disableMMCloseToATurnDistance)) {
-                AbsolutePosition.notify(positionEvent);
-                return true;
-            }
-
             AbsolutePosition.notify(this.createEvent(
                 EventType.AbsolutePosition,
                 projection.projection,
@@ -408,7 +376,7 @@ class MapMatchingHandler extends Provider {
                 }
 
                 this._lastProjections.push(projectionWithAbs);
-                if (this._lastProjections.length > this._lastProjectionsWindowSize) {
+                if (this._lastProjections.length > MapMatchingHandler.LAST_PROJECTIONS_WINDOW_SIZE) {
                     this._lastProjections.shift();
                 }
 
@@ -473,57 +441,22 @@ class MapMatchingHandler extends Provider {
         return !this._lastProjections.some(projection =>
             !(projection.nearestElement instanceof GraphEdge)
             || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
-                > this._lastProjectionsEdgeAngleThreshold)
+                > MapMatchingHandler.LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD)
         );
     }
 
-    /**
-     * @param {GraphNode} node
-     * @returns {boolean}
-     */
-    _nodeHasTurn(node) {
-        const { edges } = node;
-        for (let i = 0; i < edges.length; i++) {
-            for (let j = i + 1; j < edges.length; j++) {
-                const angle = diffAngleLines(edges[i].bearing, edges[j].bearing);
-                if (angle > MapMatchingHandler.DEFAULT_MM_MAX_ANGLE) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @param {Coordinates} center
-     * @param {number} radius
-     * @returns {boolean}
-     */
-    _hasTurnInCircle(center, radius) {
-        /** @type {Network} */
-        const network = this._mapMatching.network;
-        if (!network) {
-            return false;
-        }
-
-        return network.nodes.filter(node =>
-            node.coords.distanceTo(center) <= radius
-            && Level.intersect(node.coords.level, center.level)
-        ).some(this._nodeHasTurn);
-    }
-
     /**
      * @param {Projection} projection
      */
     tryOrientationMatching(projection) {
 
-        if (!this._useOrientationMatching) {
+        if (!MapMatchingHandler.ORIENTATION_MATCHING) {
             return;
         }
 
         if (this.state !== ProviderState.STARTED
-            || this._countStepsFromLastMatching < this._minStepsBetweenOrientationMatching
-            || StraightLineDetector.numStepsDetectedFromLastTurn < this._minStepsForOrientationMatching) {
+            || this._countStepsFromLastMatching < MapMatchingHandler.MIN_STEPS_BETWEEN_ORIENTATION_MATCHING
+            || StraightLineDetector.numStepsDetectedFromLastTurn < MapMatchingHandler.MIN_STEPS_FOR_ORIENTATION_MATCHING) {
             return;
         }
 
@@ -591,70 +524,6 @@ class MapMatchingHandler extends Provider {
     set useItineraryStartAsPosition(useItineraryStartAsPosition) {
         this._useItineraryStartAsPosition = useItineraryStartAsPosition;
     }
-
-    get useOrientationMatching() {
-        return this._useOrientationMatching;
-    }
-
-    set useOrientationMatching(useOrientationMatching) {
-        this._useOrientationMatching = useOrientationMatching;
-    }
-
-    get hugeJumpDistance() {
-        return this._hugeJumpDistance;
-    }
-
-    set hugeJumpDistance(hugeJumpDistance) {
-        this._hugeJumpDistance = hugeJumpDistance;
-    }
-
-    get disableMMCloseToATurnDistance() {
-        return this._disableMMCloseToATurnDistance;
-    }
-
-    set disableMMCloseToATurnDistance(disableMMCloseToATurnDistance) {
-        this._disableMMCloseToATurnDistance = disableMMCloseToATurnDistance;
-    }
-
-    get useOrientationMatching() {
-        return this._useOrientationMatching;
-    }
-
-    set useOrientationMatching(useOrientationMatching) {
-        this._useOrientationMatching = useOrientationMatching;
-    }
-
-    get minStepsBetweenOrientationMatching() {
-        return this._minStepsBetweenOrientationMatching;
-    }
-
-    set minStepsBetweenOrientationMatching(minStepsBetweenOrientationMatching) {
-        this._minStepsBetweenOrientationMatching = minStepsBetweenOrientationMatching;
-    }
-
-    get minStepsForOrientationMatching() {
-        return this._minStepsForOrientationMatching;
-    }
-
-    set minStepsForOrientationMatching(minStepsForOrientationMatching) {
-        this._minStepsForOrientationMatching = minStepsForOrientationMatching;
-    }
-
-    get lastProjectionsWindowSize() {
-        return this._lastProjectionsWindowSize;
-    }
-
-    set lastProjectionsWindowSize(lastProjectionsWindowSize) {
-        this._lastProjectionsWindowSize = lastProjectionsWindowSize;
-    }
-
-    get lastProjectionsEdgeAngleThreshold() {
-        return this._lastProjectionsEdgeAngleThreshold;
-    }
-
-    set lastProjectionsEdgeAngleThreshold(lastProjectionsEdgeAngleThreshold) {
-        this._lastProjectionsEdgeAngleThreshold = lastProjectionsEdgeAngleThreshold;
-    }
 }
 
 export default new MapMatchingHandler();

package/src/providers/position/absolute/AbsolutePosition.js

@@ -1,4 +1,4 @@
-import { UserPosition, GeoRelativePosition, Level } from '@wemap/geo';
+import { UserPosition, GeoRelativePosition } from '@wemap/geo';
 import { PromiseUtils, TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -9,7 +9,7 @@ import GnssWifi from './GnssWifi.js';
 import { default as GeoRelativePositionProvider } from '../relative/GeoRelativePosition.js';
 import ProvidersOptions from '../../../ProvidersOptions.js';
 import ProviderState from '../../ProviderState.js';
-import Vps from '../../vision/Vps.js';
+import Vps from '../../vision/vps/Vps.js';
 import PoleStar from './PoleStar.js';
 
 class AbsolutePosition extends Provider {
@@ -20,9 +20,6 @@ class AbsolutePosition extends Provider {
     /** @type {boolean} */
     static USE_MM_FOR_FEED = true;
 
-    /** @type {boolean} */
-    useAllAbsolutePositions = false;
-
     /** @type {number?} */
     _gnssWifiProviderId;
 
@@ -53,18 +50,10 @@ class AbsolutePosition extends Provider {
      * @override
      */
     get _availability() {
-
-        const providersToCheck = [
+        return PromiseUtils.any([
             GeoRelativePositionProvider.availability,
             GnssWifi.availability
-        ];
-        if (ProvidersOptions.hasPoleStar) {
-            providersToCheck.push(PoleStar.availability);
-        }
-        if (ProvidersOptions.hasVps) {
-            providersToCheck.push(Vps.availability);
-        }
-        return PromiseUtils.any(providersToCheck);
+        ]);
     }
 
 
@@ -157,54 +146,6 @@ class AbsolutePosition extends Provider {
         MapMatchingHandler.removeEventListener(this._mapMatchingHandlerId);
     }
 
-    /**
-     * @param {ProviderEvent<UserPosition>} newPositionEvent
-     * @param {boolean} canContainLevel
-     * @returns {boolean}
-     */
-    _shouldTakeIntoAccountNewAbsolutePosition(newPositionEvent, canContainLevel = true) {
-
-        const newPosition = newPositionEvent.data;
-        const lastPosition = this.lastEvent ? this.lastEvent.data : null;
-
-        // 1. Verifiy if it is the first known absolute position
-        if (!lastPosition) {
-            return true;
-        }
-
-        // 2. Is the new position accuracy is better enough than the last position accuracy
-        const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
-        if (isBetterEnough) {
-            return true;
-        }
-
-        // 3.a. Is the new position is far from the new one (regarding accuracy)
-        // This condition return true if the two positions accuracy circles does not intersect.
-        // This is important if the person put the current page in the background during a while. But,
-        //  could be dangerous if two providers do not provide close positions (ping-pong effect). This
-        //  is why the 3.b. condition has been added.
-        // TODO: add a routine to augment the current position accuracy when the page is in background
-        const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
-
-        // 3.b. Added on 16/06/22
-        // The goal of this condition is to avoid continuous jumps between positions from two providers
-        // (i.e. GnssWifi and PoleStar)
-        const isFarEnoughAndAccuracyIsBetter = isFarEnough && newPosition.accuracy <= lastPosition.accuracy;
-
-        if (isBetterEnough && isFarEnoughAndAccuracyIsBetter) {
-            return true;
-        }
-
-        // 4. Added on 23/06/22
-        // The goal of this condition is to take into account levels change when map-matching is not enabled / set
-        const isChangingLevel = canContainLevel && !Level.equals(newPosition.level, lastPosition.level);
-        if (isChangingLevel) {
-            return true;
-        }
-
-        return false;
-    }
-
     /**
      * @param {ProviderEvent<UserPosition>} positionEvent
      * @param {boolean} canContainLevel
@@ -212,15 +153,22 @@ class AbsolutePosition extends Provider {
      */
     _onAbsolutePosition(positionEvent, canContainLevel = true) {
 
-        if (!this._shouldTakeIntoAccountNewAbsolutePosition(positionEvent, canContainLevel)
-            && !this.useAllAbsolutePositions) {
-            return false;
-        }
-
         const newPosition = positionEvent.data.clone();
         const lastPosition = this.lastEvent ? this.lastEvent.data : null;
 
         if (lastPosition) {
+
+            // Is the new position accuracy is better enough than the last position accuracy
+            const isBetterEnough = newPosition.accuracy * AbsolutePosition.ACCURACY_RELOC_RATIO <= lastPosition.accuracy;
+
+            // Is the new position is far from the new one (regarding accuracy)
+            // This is important if the person put the current page in the background during a while
+            const isFarEnough = lastPosition.distanceTo(newPosition) > lastPosition.accuracy + newPosition.accuracy;
+
+            if (!isBetterEnough && !isFarEnough) {
+                return false;
+            }
+
             if (!canContainLevel) {
                 newPosition.level = lastPosition.level;
             }

package/src/providers/position/absolute/PoleStar.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-bitwise */
 
 import { UserPosition } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
 import { TimeUtils } from '@wemap/utils';
 
 import Provider from '../../Provider.js';
@@ -98,7 +97,7 @@ class PoleStar extends Provider {
                     json.alt / 5,
                     timestamp,
                     json.accuracy,
-                    deg2rad(json.bearing),
+                    json.bearing,
                     this.pname);
 
                 this.notify(this.createEvent(

package/src/providers/steps/StepDetector.js

@@ -6,30 +6,14 @@ 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 {
 
-    /** @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.algorithm = this._algorithm;
+        this.stepDetector = new StepDetectionMinMaxPeaks2();
     }
 
     /**
@@ -100,7 +84,7 @@ class StepDetector extends Provider {
         const stepDetected = this.stepDetector.compute(timestamp, linearAcc, this.angularRateEvent.data.values);
 
         if (stepDetected) {
-            const size = this.stepDetector.lastStepSize * this._stepSizeMultiplier;
+            const size = this.stepDetector.lastStepSize;
             this.numOfSteps++;
             this.notify(this.createEvent(
                 EventType.Step, {
@@ -118,34 +102,6 @@ class StepDetector extends Provider {
         linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
         return linearAcc;
     }
-
-    set stepSizeMultiplier(stepSizeMultiplier) {
-        this._stepSizeMultiplier = stepSizeMultiplier;
-    }
-
-    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/StraightLineDetector.js

@@ -6,7 +6,7 @@ import EventType from '../../events/EventType.js';
 class StraightLineDetector extends Provider {
 
     /** @type {number} */
-    static DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
+    static STEPS_CONSIDERED_FOR_STRAIGHT_LINE = 2;
 
     /** @type {number?} */
     _turnDetectorProviderId = null;
@@ -17,9 +17,6 @@ class StraightLineDetector extends Provider {
     /** @type {number} */
     _countSteps = 0;
 
-    /** @type {number} */
-    _stepsConsideredForStraightLine = StraightLineDetector.DEFAULT_STEPS_CONSIDERED_FOR_STRAIGHT_LINE;
-
     /**
     * @override
     */
@@ -44,7 +41,7 @@ class StraightLineDetector extends Provider {
     }
 
     _onTurn = (event) => {
-        if (this._countSteps >= this._stepsConsideredForStraightLine) {
+        if (this._countSteps >= StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
 
             const fromEvents = [event];
             if (StepDetector.lastEvent !== null) {
@@ -60,7 +57,7 @@ class StraightLineDetector extends Provider {
     _onStep = (event) => {
         this._countSteps++;
 
-        if (this._countSteps === this._stepsConsideredForStraightLine) {
+        if (this._countSteps === StraightLineDetector.STEPS_CONSIDERED_FOR_STRAIGHT_LINE) {
 
             const fromEvents = [event];
             if (TurnDectector.lastEvent !== null) {
@@ -82,14 +79,6 @@ class StraightLineDetector extends Provider {
     get numStepsDetectedFromLastTurn() {
         return this._countSteps;
     }
-
-    get stepsConsideredForStraightLine() {
-        return this._stepsConsideredForStraightLine;
-    }
-
-    set stepsConsideredForStraightLine(stepsConsideredForStraightLine) {
-        this._stepsConsideredForStraightLine = stepsConsideredForStraightLine;
-    }
 }
 
 export default new StraightLineDetector();