@wemap/providers 12.10.8 → 12.10.9

package/src/mapmatching/MapMatchingHandler.spec.ts

@@ -1,142 +0,0 @@
-import chai from 'chai';
-import { Coordinates } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
-import { Graph, Itinerary, Vertex } from '@wemap/routers';
-
-import MMH from './MapMatchingHandler.js';
-
-const { expect } = chai;
-
-describe('MapMatchingHandler', () => {
-
-    const p0 = new Coordinates(0, 0, null, 0);
-    const p1 = p0.destinationPoint(5, 0);
-    const p2 = p1.destinationPoint(5, Math.PI / 2);
-    const p3 = p1.destinationPoint(10, 0);
-    const p4 = p0.destinationPoint(2, deg2rad(10));
-
-    const pos1 = p0.clone();
-    const pos2 = pos1.destinationPoint(3, 0);
-    const pos3 = pos2.destinationPoint(10, 0);
-
-
-    it('_hasTurnInCircle - itinerary', () => {
-
-        expect(MMH._hasTurnInCircle(pos1, Number.MAX_VALUE)).is.false;
-
-        // p4 -> p1 -> p2 is a turn
-        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p2], p0, p2);
-        let graph = MMH.graph as Graph;
-
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p0)!)).is.false;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p1)!)).is.true;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p2)!)).is.false;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p4)!)).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
-
-        // Straight line
-        MMH.itinerary = Itinerary.fromOrderedCoordinates([p0, p4, p1, p3], p0, p3);
-        graph = MMH.graph as Graph;
-
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p1) as Vertex)).is.false;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p4) as Vertex)).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.false;
-
-    });
-
-
-    it('_hasTurnInCircle - network', () => {
-
-        // p1 has turns
-        const graph = Graph.fromCoordinatesSegments([[p0, p4, p1], [p1, p2], [p3, p1]]);
-        MMH.graph = graph;
-
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p1) as Vertex)).is.true;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p4) as Vertex)).is.false;
-
-        expect(MMH._hasTurnInCircle(pos1, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos1, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos3, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos3, 10)).is.true;
-
-    });
-
-    const p10 = new Coordinates(0, 0, null, 1);
-    const p11 = p10.destinationPoint(5, 0);
-    const p12 = p11.destinationPoint(5, Math.PI / 2);
-    const p13 = p11.destinationPoint(10, 0);
-
-    const pos12 = p10.clone().destinationPoint(3, 0);
-    const pos012 = new Coordinates(0, 0, null, [0, 1]).destinationPoint(3, 0);
-
-    it('_hasTurnInCircle - multi-levels', () => {
-
-        // level 1 is a straight line
-        let graph = Graph.fromCoordinatesSegments([
-            [p0, p4, p1], [p1, p2], [p3, p1],
-            [p10, p11, p13]
-        ]);
-        MMH.graph = graph;
-
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p1) as Vertex)).is.true;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p11) as Vertex)).is.false;
-
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
-
-        // Changing level
-        // straight line
-        graph = Graph.fromCoordinatesSegments([
-            [p0, p4, p11], [p11, p13]
-        ]);
-        MMH.graph = graph;
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p4) as Vertex)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, Number.MAX_VALUE)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, Number.MAX_VALUE)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, Number.MAX_VALUE)).is.false;
-
-        // Changing level
-        // turn in p11
-        graph = Graph.fromCoordinatesSegments([
-            [p0, p4, p11], [p11, p12], [p11, p13]
-        ]);
-        MMH.graph = graph;
-
-        expect(MMH._nodeHasTurn(graph.getVertexByCoords(p11) as Vertex)).is.true;
-        expect(MMH._hasTurnInCircle(pos2, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 3)).is.false;
-        expect(MMH._hasTurnInCircle(pos2, 10)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos12, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos12, 10)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 1)).is.false;
-        expect(MMH._hasTurnInCircle(pos012, 3)).is.true;
-        expect(MMH._hasTurnInCircle(pos012, 10)).is.true;
-
-    });
-
-});

package/src/mapmatching/MapMatchingHandler.ts

@@ -1,540 +0,0 @@
-import { AbsoluteHeading, Level, UserPosition, Coordinates } from '@wemap/geo';
-import { deg2rad, diffAngle, diffAngleLines } from '@wemap/maths';
-import { Edge, Graph, GraphProjection, Itinerary, ItineraryInfoManager, Vertex } from '@wemap/routers';
-import { TimeUtils } from '@wemap/utils';
-
-import AbsoluteAttitudeProvider from '../providers/attitude/absolute/AbsoluteAttitudeProvider.js';
-import AbsoluteAttitudeFromBrowser from '../providers/attitude/absolute/AbsoluteAttitudeFromBrowserProvider.js';
-import TurnProvider from '../providers/attitude/TurnProvider.js';
-import Constants from '../providers/Constants.js';
-import AbsolutePositionProvider from '../providers/position/absolute/AbsolutePositionProvider.js';
-import Provider from '../providers/Provider.js';
-import StepProvider from '../providers/steps/StepProvider.js';
-import StraightLineProvider from '../providers/steps/StraightLineProvider.js';
-import ProvidersOptions from '../ProvidersOptions.js';
-import { AbsolutePosition } from '../events/Types.js';
-
-
-type MapMatchingEvent = { graph?: Graph, itinerary?: Itinerary | null };
-class MapMatchingHandler extends Provider<MapMatchingEvent> {
-
-    static DEFAULT_MM_MAX_ANGLE = deg2rad(30); // radians
-    static DEFAULT_MM_MAX_DIST = 30; // meters
-    static DEFAULT_MM_MIN_DIST = 0; // meters
-    static DEFAULT_USE_ITINERARY_START_AS_POSITION = false;
-    static DEFAULT_USE_ORIENTATION_MATCHING = true;
-    static DEFAULT_MM_HUGE_JUMP_DISTANCE = 3; // meters
-    static DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE = 2; // meters
-    static DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING = 3;
-    static DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING = 5;
-    static DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE = 3;
-    static DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD = deg2rad(3); // radians
-
-    _mapMatchingMaxDistance = MapMatchingHandler.DEFAULT_MM_MAX_DIST;
-    _mapMatchingMinDistance = MapMatchingHandler.DEFAULT_MM_MIN_DIST;
-    _mapMatchingMaxAngleBearing = MapMatchingHandler.DEFAULT_MM_MAX_ANGLE;
-    _useItineraryStartAsPosition = MapMatchingHandler.DEFAULT_USE_ITINERARY_START_AS_POSITION;
-    _useOrientationMatching = MapMatchingHandler.DEFAULT_USE_ORIENTATION_MATCHING;
-    _hugeJumpDistance = MapMatchingHandler.DEFAULT_MM_HUGE_JUMP_DISTANCE;
-    _disableMMCloseToATurnDistance = MapMatchingHandler.DEFAULT_DISABLE_MM_CLOSE_TO_A_TURN_DISTANCE;
-    _minStepsBetweenOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_BETWEEN_ORIENTATION_MATCHING;
-    _minStepsForOrientationMatching = MapMatchingHandler.DEFAULT_MIN_STEPS_FOR_ORIENTATION_MATCHING;
-    _lastProjectionsWindowSize = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_WINDOW_SIZE;
-    _lastProjectionsEdgeAngleThreshold = MapMatchingHandler.DEFAULT_LAST_PROJECTIONS_EDGE_ANGLE_THRESHOLD;
-
-    _graph: Graph | null = null;
-    _internalProvidersStarted = false;
-    _straightLineProviderId?: number;
-    _turnProviderId?: number;
-    _stepProviderId?: number;
-    _projectionsWithAbsAndWithoutRelAttitudeInARow: GraphProjection[] = [];
-    _countStepsFromLastMatching = 0;
-    _lastProjections: GraphProjection[] = [];
-
-    _itineraryInfoManager: ItineraryInfoManager | null = null;
-
-
-    getName = () => 'MapMatchingHandler';
-
-    availability = () => Promise.resolve();
-
-    start() {
-        if (this.graph) {
-            this._startInternalProviders();
-        }
-    }
-
-    stop() {
-        this._stopInternalProviders();
-    }
-
-    _manageStartStop = () => {
-        if (this.graph && !this._internalProvidersStarted) {
-            this._startInternalProviders();
-        } else if (!this.graph && this._internalProvidersStarted) {
-            this._stopInternalProviders();
-        }
-    }
-
-    _startInternalProviders() {
-
-        if (this.enabled && this._internalProvidersStarted) {
-            return;
-        }
-
-        this._straightLineProviderId = StraightLineProvider.addEventListener();
-        this._turnProviderId = TurnProvider.addEventListener();
-        this._stepProviderId = StepProvider.addEventListener(() => (this._countStepsFromLastMatching++));
-
-        this._internalProvidersStarted = true;
-    }
-
-    _stopInternalProviders() {
-
-        if (this.enabled && !this._internalProvidersStarted) {
-            return;
-        }
-
-        StraightLineProvider.removeEventListener(this._straightLineProviderId);
-        TurnProvider.removeEventListener(this._turnProviderId);
-        StepProvider.removeEventListener(this._stepProviderId);
-
-        this._internalProvidersStarted = false;
-    }
-
-    get enabled() {
-        return ProvidersOptions.useMapMatching;
-    }
-
-    get graph() {
-        return this._graph;
-    }
-
-    set graph(graph) {
-
-        this._graph = graph;
-        this._itineraryInfoManager = null;
-        this.notify({ ...(graph && { graph }) });
-
-        this._manageStartStop();
-
-        if (this.canUseMapMatching()) {
-            // TODO if necessary
-            // this._notifyPositionFromNetworkInput(network);
-        }
-    }
-
-    set itinerary(itinerary: Itinerary | null) {
-
-        this._graph = itinerary ? itinerary.toGraph() : null;
-        this._itineraryInfoManager = new ItineraryInfoManager(itinerary);
-        this.notify({ ...(itinerary && { itinerary }) });
-
-        this._manageStartStop();
-
-        if (this.canUseMapMatching() && itinerary) {
-            this._notifyPositionFromItineraryInput(itinerary);
-        }
-    }
-
-    canUseMapMatching() {
-        return this.enabled && this.graph;
-    }
-
-
-    private _notifyPositionFromItineraryInput(itinerary: Itinerary) {
-
-        if (!this._useItineraryStartAsPosition || !itinerary.origin) {
-            return;
-        }
-
-        const lastPosition = AbsolutePositionProvider.lastEvent || null;
-
-        // In case of an itinerary, use itinerary start as new position,
-        // but add the distance between lastPosition and itinerary start for the accuracy
-        const newPosition = UserPosition.fromCoordinates(itinerary.origin);
-
-        if (lastPosition) {
-            newPosition.alt = lastPosition.alt;
-            newPosition.time = lastPosition.time;
-            newPosition.accuracy = lastPosition.accuracy! + newPosition.distanceTo(lastPosition);
-            newPosition.bearing = lastPosition.bearing;
-        } else if (itinerary.coords.length >= 2) {
-            newPosition.alt = Constants.DEFAULT_ALTITUDE;
-            newPosition.time = TimeUtils.preciseTime();
-            newPosition.accuracy = 0;
-            newPosition.bearing = itinerary.coords[0].bearingTo(itinerary.coords[1]);
-        } else {
-            return;
-        }
-
-        // if the distance between itinerary.start and itinerary.nodes[0] is less than MM_MAX_DIST,
-        //  projection.coords is itinerary.nodes[0]
-        const projection = this.getProjection(newPosition, true);
-        if (projection) {
-            AbsolutePositionProvider.notify(projection.coords);
-            // Do not notify for attitude projection because bearing has not been used.
-        } else {
-            AbsolutePositionProvider.notify(newPosition);
-        }
-        return;
-    }
-
-    notifyPositionFromFeed(newPositionEvent: AbsolutePosition) {
-
-        const projection = this.getProjection(newPositionEvent, true, false);
-        if (!projection) {
-            AbsolutePositionProvider.notify(newPositionEvent);
-            return;
-        }
-
-        AbsolutePositionProvider.notify(projection.coords);
-    }
-
-
-    /**
-     * @returns if input position is used by the system (true = used, false = discarded)
-     */
-    notifyPositionFromAbsolute(newPosition: AbsolutePosition) {
-
-        let projectionWithBearing = null;
-        if (newPosition.bearing !== null) {
-            projectionWithBearing = this.getProjection(newPosition, true, true);
-        }
-
-        if (!projectionWithBearing) {
-            // Verify if the newPosition is far enough from the network to be used by the system.
-            // const projectionWithoutBearing = this.getProjection(newPosition, true, false);
-            // if (!projectionWithoutBearing) {
-            // In this case, the newPosition is far enough and can be used safely.
-            AbsolutePositionProvider.notify(newPosition);
-            return true;
-            // }
-            // return true;
-        }
-
-        // newPosition must not be used after this line
-
-        const thisWillBeAHugeJump = projectionWithBearing.distanceFromNearestElement > this._hugeJumpDistance;
-
-        // In case of a huge jump, be sure the user is in a straight line
-        if (thisWillBeAHugeJump && !StraightLineProvider.isStraight()) {
-            return false;
-        }
-
-        // Detector to avoid big jumps in the wrong direction
-        if (thisWillBeAHugeJump && this._detectWrongBigJump(projectionWithBearing)) {
-            return false;
-        }
-
-        AbsolutePositionProvider.notify(projectionWithBearing.coords);
-
-        this.tryOrientationMatching(projectionWithBearing);
-        return true;
-    }
-
-
-    /**
-     * @returns if input position is used by the system (true = used, false = discarded)
-     */
-    notifyPositionFromRelative(newPosition: AbsolutePosition) {
-
-        if (TurnProvider.isTurning()) {
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections = [];
-            AbsolutePositionProvider.notify(newPosition);
-            return true;
-        }
-
-        const projection = this.getProjection(newPosition, true, true);
-
-        if (projection) {
-            this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-            this._lastProjections.push(projection);
-            if (this._lastProjections.length > this._lastProjectionsWindowSize) {
-                this._lastProjections.shift();
-            }
-
-            const thisWillBeAHugeJump = projection.distanceFromNearestElement > this._hugeJumpDistance;
-
-            // In case of a huge jump, be sure the user is in a straight line
-            if (thisWillBeAHugeJump && !StraightLineProvider.isStraight()) {
-                AbsolutePositionProvider.notify(newPosition);
-                return true;
-            }
-
-            // Detector to avoid big jumps in the wrong direction
-            if (thisWillBeAHugeJump && this._detectWrongBigJump(projection)) {
-                AbsolutePositionProvider.notify(newPosition);
-                return true;
-            }
-
-            // Do not use projection if the neareast element is not the same direction than previous
-            if (!this._areLastProjectionsInTheSameDirection()) {
-                AbsolutePositionProvider.notify(newPosition);
-                return true;
-            }
-
-            // Detector to avoid map-matching close to network turns
-            if (this._disableMMCloseToATurnDistance > 0
-                && this._hasTurnInCircle(projection.coords, this._disableMMCloseToATurnDistance)) {
-                AbsolutePositionProvider.notify(newPosition);
-                return true;
-            }
-
-            AbsolutePositionProvider.notify(projection.coords);
-            this.tryOrientationMatching(projection);
-
-            return true;
-
-        }
-        // else {
-
-        // Sometimes, the newPosition.bearing diverges due to the Absolute Attitude offset
-        // and the Orientation Matching. So, we created this detector to check if projection
-        // with bearing from "AbsoluteAttitudeFromBrowser" is better than the current bearing.
-        // /!\ This works only if the user is waking in the same direction than the smartphone orientation /!\
-        if (StraightLineProvider.isStraight()) {
-
-            const testedPosition = newPosition.clone();
-            testedPosition.bearing = AbsoluteAttitudeFromBrowser.lastEvent?.heading || null;
-            const projectionWithAbs = this.getProjection(testedPosition, true, true);
-
-            if (projectionWithAbs) {
-
-                this._projectionsWithAbsAndWithoutRelAttitudeInARow.push(projectionWithAbs);
-                if (this._projectionsWithAbsAndWithoutRelAttitudeInARow.length < 3) {
-                    AbsolutePositionProvider.notify(newPosition);
-                    return true;
-                }
-
-                this._lastProjections.push(projectionWithAbs);
-                if (this._lastProjections.length > this._lastProjectionsWindowSize) {
-                    this._lastProjections.shift();
-                }
-
-
-                if (!this._areLastProjectionsInTheSameDirection()) {
-                    AbsolutePositionProvider.notify(newPosition);
-                    return true;
-                }
-
-                AbsolutePositionProvider.notify(projectionWithAbs.coords);
-
-                this.tryOrientationMatching(projectionWithAbs);
-                return true;
-            }
-        }
-
-        this._projectionsWithAbsAndWithoutRelAttitudeInARow = [];
-        this._lastProjections = [];
-
-        // If no projection found with both projection methods, simply use the newPosition.
-        AbsolutePositionProvider.notify(newPosition);
-        return true;
-
-        // }
-
-    }
-
-    _detectWrongBigJump(projection: GraphProjection<UserPosition>) {
-
-        if (this._itineraryInfoManager && AbsolutePositionProvider.lastEvent) {
-            const infoPrevious = this._itineraryInfoManager.getInfo(AbsolutePositionProvider.lastEvent);
-            const infoProjection = this._itineraryInfoManager.getInfo(projection.coords);
-            if (infoPrevious
-                && infoProjection
-                && infoPrevious.traveledDistance > infoProjection.traveledDistance
-                && (infoPrevious.traveledDistance - infoProjection.traveledDistance) > projection.origin.accuracy!
-                && projection.distanceFromNearestElement > projection.origin.accuracy!
-                && projection.origin.distanceTo(AbsolutePositionProvider.lastEvent) < projection.origin.accuracy! + AbsolutePositionProvider.lastEvent.accuracy!) {
-
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    _areLastProjectionsInTheSameDirection() {
-
-        if (this._lastProjections.length === 0) {
-            return false;
-        }
-
-        const firstProjection = this._lastProjections[0];
-        return !this._lastProjections.some(projection =>
-            !(projection.nearestElement instanceof Edge)
-            || !(firstProjection.nearestElement instanceof Edge)
-            || (diffAngleLines(projection.nearestElement.bearing, firstProjection.nearestElement.bearing)
-                > this._lastProjectionsEdgeAngleThreshold)
-        );
-    }
-
-
-    _nodeHasTurn(vertex: Vertex) {
-        // works but slow
-        if (!this._graph) return;
-        const edges = this._graph.edges.filter(e => e.vertex1 === vertex || e.vertex2 === vertex);
-
-        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;
-    }
-
-
-    _hasTurnInCircle(center: Coordinates, radius: number) {
-        const graph = this._graph;
-        if (!graph) {
-            return false;
-        }
-
-        return graph.vertices.filter(vertex =>
-            vertex.coords.distanceTo(center) <= radius
-            && Level.intersect(vertex.coords.level, center.level)
-        ).some(it => this._nodeHasTurn(it));
-    }
-
-    tryOrientationMatching(projection: GraphProjection<UserPosition>) {
-
-        if (!this._useOrientationMatching) {
-            return;
-        }
-
-        if (this.state !== 'started'
-            || this._countStepsFromLastMatching < this._minStepsBetweenOrientationMatching
-            || StraightLineProvider.numStepsDetectedFromLastTurn < this._minStepsForOrientationMatching) {
-            return;
-        }
-
-        const { nearestElement, origin } = projection;
-        if (!(nearestElement instanceof Edge)) {
-            return;
-        }
-
-        let matchingDirection;
-        const matchingDirectionAngle1 = diffAngle(nearestElement.bearing, origin.bearing!);
-        const matchingDirectionAngle2 = diffAngle(nearestElement.bearing + Math.PI, origin.bearing!);
-
-        if (Math.abs(matchingDirectionAngle1) < Math.abs(matchingDirectionAngle2)) {
-            matchingDirection = nearestElement.bearing;
-        } else {
-            matchingDirection = (nearestElement.bearing + Math.PI) % (2 * Math.PI);
-        }
-
-        const matchedHeading = new AbsoluteHeading(
-            matchingDirection,
-            origin.time,
-            0
-            // Math.min(Math.abs(matchingDirectionAngle1), Math.abs(matchingDirectionAngle2))
-        );
-
-        AbsoluteAttitudeProvider._forceHeadingForRelative(matchedHeading);
-
-        this._countStepsFromLastMatching = 0;
-    }
-
-    getProjection(position: UserPosition, useDistance?: boolean, useBearing?: boolean) {
-        const projectionsOptions = {
-            ...(useDistance && { maxDistance: this._mapMatchingMaxDistance }),
-            ...(useBearing && { maxBearingAngle: this._mapMatchingMaxAngleBearing }),
-        }
-        return this._graph?.getProjection(position, projectionsOptions);
-    }
-
-    get maxDistance() {
-        return this._mapMatchingMaxDistance;
-    }
-
-    set maxDistance(maxDistance) {
-        this._mapMatchingMaxDistance = maxDistance;
-    }
-
-    get minDistance() {
-        return this._mapMatchingMinDistance;
-    }
-
-    set minDistance(minDistance) {
-        this._mapMatchingMinDistance = minDistance;
-    }
-
-    get maxAngleBearing() {
-        return this._mapMatchingMaxAngleBearing;
-    }
-
-    set maxAngleBearing(maxAngleBearing) {
-        this._mapMatchingMaxAngleBearing = maxAngleBearing;
-    }
-
-    get useItineraryStartAsPosition() {
-        return this._useItineraryStartAsPosition;
-    }
-
-    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 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/Constants.ts

@@ -1,5 +0,0 @@
-const Constants = {
-    DEFAULT_ALTITUDE: 1.6
-};
-
-export default Constants;