@wemap/positioning 2.7.13 → 14.0.0-0

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -1,219 +0,0 @@
-/* eslint max-statements: ["error", 40]*/
-
-import { WGS84UserPosition } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
-
-import MapMatchingProvider from '../others/MapMatchingProvider';
-import PdrProvider from './pdr/PdrProvider';
-import GnssWifiProvider from '../position/GnssWifiProvider';
-import EventType from '../../events/EventType';
-import AbsoluteAttitudeProvider from '../attitude/AbsoluteAttitudeProvider';
-import Constants from '../Constants';
-
-const GPF_ACCURACY = 25;
-const GPF_DISTANCE = 25;
-
-const MM_GNSS_DIST = 20;
-const MM_GNSS_ANGLE = deg2rad(20);
-
-class GnssWifiPdrProvider extends MapMatchingProvider {
-
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, options);
-
-        this.pdrProvider = new PdrProvider(e => this.onPdrEvent(e), onError, options);
-        this.gnssWifiProvider = new GnssWifiProvider(e => this.onGnssWifiEvent(e), onError, options);
-        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(
-            e => this.onAbsoluteAttitudeEvent(e),
-            onError,
-            options
-        );
-
-        this.gpsLastUpdate = 0;
-        this.isFirstGnssUpdate = true;
-        this.isFirstAttitudeUpdate = true;
-
-        if (this.options.useMapMatching) {
-            this.enableMapMatching();
-        }
-    }
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'GnssWifi';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'GnssWifiPdr';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    static getRequiredProviders() {
-        return [PdrProvider, GnssWifiProvider, AbsoluteAttitudeProvider];
-    }
-
-
-    /**
-     * @override
-     */
-    startInternal() {
-        this.pdrProvider.start();
-        this.gnssWifiProvider.start();
-        this.absoluteAttitudeProvider.start();
-    }
-
-    /**
-     * @override
-     */
-    stop() {
-        this.pdrProvider.stop();
-        this.gnssWifiProvider.stop();
-        this.absoluteAttitudeProvider.stop();
-    }
-
-    /**
-     * @private
-     */
-    onPdrEvent(pdrEvent) {
-        pdrEvent.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                this.position = event.data;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                this.attitude = event.data;
-            }
-        });
-        this.notify(...pdrEvent);
-    }
-
-    /**
-     * @private
-     */
-    onGnssWifiEvent(events) {
-
-        const gnssWifiEvent = events[0];
-        const position = gnssWifiEvent.data;
-
-        // This should be called to update True North / Magnetic North declination
-        this.absoluteAttitudeProvider.setPosition(position);
-
-        if (position.accuracy > GPF_ACCURACY) {
-            return;
-        }
-
-        this.gnssPosition = position.clone();
-        this.gnssPosition.alt = Constants.DEFAULT_ALTITUDE;
-
-        if (!this.position || this.position
-            && this.position.distanceTo(this.gnssPosition) > GPF_DISTANCE) {
-
-            if (!this.mapMatching || !this.attitude) {
-                this.pdrProvider.setPosition(this.gnssPosition);
-            } else {
-
-                this.gnssPosition.bearing = this.attitude.heading;
-                const projection = this.mapMatching.getProjection(this.gnssPosition, true, true);
-
-                if (projection && projection.projection) {
-
-                    // Create a new position from projection and new GNSS position.
-                    this.gnssPosition.lat = projection.projection.lat;
-                    this.gnssPosition.lng = projection.projection.lng;
-
-                    // // If nearest element is an edge, use its orientation to set heading
-                    // if (projection.nearestElement instanceof Edge) {
-                    //     const edgeBearing = projection.nearestElement.bearing;
-                    //     const diff1 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssPosition.bearing), edgeBearing);
-                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssPosition.bearing), edgeBearing + Math.PI);
-                    //     this.pdrProvider.setHeading(diff1 < diff2 ? edgeBearing : edgeBearing + Math.PI);
-                    // }
-
-                    if (this.lastAttitude) {
-                        this.pdrProvider.setHeading(this.lastAttitude.heading);
-                    }
-
-                }
-                this.pdrProvider.setPosition(this.gnssPosition);
-            }
-        }
-
-    }
-
-    onAbsoluteAttitudeEvent(events) {
-
-        const attitude = events[0].data;
-
-        if (this.isFirstAttitudeUpdate) {
-            this.pdrProvider.setHeading(attitude.heading);
-            this.isFirstAttitudeUpdate = false;
-        }
-
-        this.lastAttitude = attitude;
-    }
-
-    /**
-     * MapMatching
-     */
-
-    enableMapMatching(network = null, maxDistance = MM_GNSS_DIST, maxAngleBearing = MM_GNSS_ANGLE) {
-        this.pdrProvider.enableMapMatching(network, maxDistance, maxAngleBearing);
-        super.enableMapMatching(network, maxDistance, maxAngleBearing);
-    }
-
-
-    setNetwork(network) {
-        this.pdrProvider.setNetwork(network);
-        super.setNetwork(network);
-    }
-
-    /**
-     * Itinerary
-     */
-
-    setItinerary(itinerary) {
-
-        const isFirstItinerary = !this.itinerary;
-
-        super.setItinerary(itinerary);
-
-        if (isFirstItinerary && itinerary.length > 0) {
-
-            // When the first itinerary is received, first or second node (depending on MM_GNSS_DIST) is used as a starting point. No map-matching is needed here as router already provide the projection in the itinerary (node2 is node1 projection on OSRM network).
-
-            if (!this.gnssPosition
-                || itinerary.length < 2
-                || !itinerary.points[0].equalsTo(this.gnssPosition)) {
-                console.warn('Itinerary has not been calculated from GnssWifiPdrProvider and these is not recommanded');
-            }
-
-            const startEdge = itinerary.getEdgeAt(MM_GNSS_DIST);
-            if (!startEdge) {
-                return;
-            }
-            const startPoint = WGS84UserPosition.fromWGS84(startEdge.node1.coords);
-            startPoint.alt = Constants.DEFAULT_ALTITUDE;
-            this.pdrProvider.setPosition(startPoint);
-            this.pdrProvider.setStepDetectionLockerOrientation(startEdge.bearing);
-        }
-
-    }
-
-}
-
-export default GnssWifiPdrProvider;

package/src/providers/pose/PoseProvider.js

@@ -1,71 +0,0 @@
-import Provider from '../Provider';
-import EventType from '../../events/EventType';
-
-import GnssWifiProvider from '../position/GnssWifiProvider';
-import AbsoluteAttitudeProvider from '../attitude/AbsoluteAttitudeProvider';
-
-/**
- * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
- * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
- */
-class PoseProvider extends Provider {
-
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, options);
-
-        this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(onEvent, onError);
-        this.gnssWifiProvider = new GnssWifiProvider((events) => {
-            this.absoluteAttitudeProvider.setPosition(events[0].data);
-            onEvent(events);
-        }, onError);
-    }
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'Pose';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'Pose provider';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
-    }
-
-    /**
-     * Return the list of required providers
-     */
-    static getRequiredProviders() {
-        return [AbsoluteAttitudeProvider, GnssWifiProvider];
-    }
-
-    /**
-     * @override
-     */
-    startInternal() {
-        this.absoluteAttitudeProvider.start();
-        this.gnssWifiProvider.start();
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        this.absoluteAttitudeProvider.stop();
-        this.gnssWifiProvider.stop();
-    }
-}
-
-export default PoseProvider;

package/src/providers/pose/pdr/PdrProvider.js

@@ -1,364 +0,0 @@
-/* eslint-disable max-statements */
-import noop from 'lodash.noop';
-
-import {
-    Constants as GeoConstants, WGS84, WGS84UserPosition
-} from '@wemap/geo';
-
-import { Itinerary } from '@wemap/graph';
-import {
-    deg2rad, Quaternion
-} from '@wemap/maths';
-
-import StepDetection from './steps/StepDetection';
-import HeadingUnlocker from './helpers/HeadingUnlocker';
-import ThugDetector from './helpers/ThugDetector';
-import Smoother from './helpers/Smoother';
-import RelativeAttitudeProvider from '../../attitude/RelativeAttitudeProvider';
-import ImuProvider from '../../others/ImuProvider';
-import EventType from '../../../events/EventType';
-import MapMatchingProvider from '../../others/MapMatchingProvider';
-import { TimeUtils } from '@wemap/utils';
-
-
-const MM_PDR_ANGLE = deg2rad(20);
-const MM_PDR_DIST = 15;
-const MM_CONV_SPEED = 0.7;
-
-const LO_SEGMENT_SIZE = 1.5;
-
-const DEFAULT_OPTIONS = {
-    stepdetectionlocker: true,
-    smoother: true,
-    onThugEvent: noop
-};
-
-class PdrProvider extends MapMatchingProvider {
-
-    // pdrPosition can be different from this.position
-    // pdrPosition is raw position calculated by PdrProvider where
-    //     this.position is smoothed position.
-    pdrPosition = null;
-
-    static MM_PDR_ANGLE = MM_PDR_ANGLE;
-    static MM_PDR_DIST = MM_PDR_DIST;
-
-    /**
-    * @override
-    */
-    constructor(onEvent, onError, options) {
-        super(onEvent, onError, Object.assign({}, DEFAULT_OPTIONS, options));
-
-        // Input data providers
-        this.relativeAttitudeProvider = new RelativeAttitudeProvider(
-            e => this.onRelativeAttitudeEvent(e),
-            onError,
-            this.options
-        );
-        this.imuProvider = new ImuProvider(
-            e => this.onImuEvent(e),
-            onError,
-            Object.assign({}, this.options,
-                { require: [EventType.Acceleration, EventType.AngularRate] }
-            )
-        );
-
-        // Helpers for PDR
-        this.stepDetection = new StepDetection();
-        this.stepDetectionLocker = new HeadingUnlocker();
-        this.smoother = new Smoother();
-        this.thugDetector = new ThugDetector();
-
-        if (this.options.useMapMatching) {
-            this.enableMapMatching();
-        }
-    }
-
-    /**
-     * @override
-     */
-    static get name() {
-        return 'PDR';
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'PDR';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    static getRequiredProviders() {
-        return [ImuProvider, RelativeAttitudeProvider];
-    }
-
-
-    /**
-     * @override
-     */
-    startInternal() {
-        this.imuProvider.start();
-        this.relativeAttitudeProvider.start();
-    }
-
-    /**
-     * @override
-     */
-    stopInternal() {
-        this.imuProvider.stop();
-        this.relativeAttitudeProvider.stop();
-    }
-
-    /**
-     * Get provider name
-     * @override
-     */
-    get nameWithOptions() {
-        let name = this.name;
-        name += ' (locker: ';
-        name += this.options.stepdetectionlocker ? 'Y' : 'N';
-        name += ', ';
-        name += 'smoo: ';
-        name += this.options.smoother ? 'Y' : 'N';
-        name += ', ';
-        name += 'mm: ';
-        name += this.options.useMapMatching ? 'Y' : 'N';
-        name += ')';
-        return name;
-    }
-
-    setHeading(heading) {
-        this.relativeAttitudeProvider.setOffset(heading);
-    }
-
-    setPosition(position) {
-        if (position instanceof WGS84) {
-            this.pdrPosition = WGS84UserPosition.fromWGS84(position);
-            if (window && window.performance) {
-                this.pdrPosition.time = TimeUtils.preciseTime / 1e3;
-            }
-        } else {
-            this.pdrPosition = position;
-        }
-
-        if (this.options.smoother) {
-            this.smoother.generateNextPositions(this.pdrPosition, true);
-            // this.smoother.pullPosition(position.time) should never return null
-            this.position = this.smoother.pullPosition(this.pdrPosition.time);
-        } else {
-            this.position = this.pdrPosition.clone();
-        }
-
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
-    }
-
-    /**
-     * @override
-     */
-    onRelativeAttitudeEvent = events => {
-        const attitudeEvent = events[0];
-        this.attitude = attitudeEvent.data;
-
-        const newEvent = attitudeEvent.clone();
-        newEvent.dataType = EventType.AbsoluteAttitude;
-        this.notify(newEvent);
-    }
-
-    /**
-     * @private
-     */
-    onImuEvent = imuEvent => {
-
-        if (!this.attitude) {
-            // We should wait attitude for stepDetectionLocker and linear acceleration
-            return;
-        }
-
-        if (!this.pdrPosition) {
-            // We should wait at least an input position for PDR
-            return;
-        }
-
-        if (this.options.stepdetectionlocker
-            && this.stepDetectionLocker.locked
-            && this.stepDetectionLocker.feedHeading(this.attitude.heading)) {
-            // Step detection is locked by stepDetectionLocker
-            return;
-        }
-
-
-        let timestamp, acceleration, angularRate;
-        imuEvent.forEach(event => {
-            if (event.dataType === EventType.Acceleration) {
-                acceleration = event.data;
-                timestamp = event.timestamp;
-            } else if (event.dataType === EventType.AngularRate) {
-                angularRate = event.data;
-            }
-        });
-
-        const heading = this.attitude.heading;
-
-        if (this.onThugEvent && this.thugDetector.compute(timestamp, acceleration)) {
-            this.onThugEvent();
-        }
-
-        /**
-         * Step Detection and Step Size Detection
-         */
-        const linearAcc = PdrProvider.computeLinearAcceleration(
-            this.attitude.quaternion, acceleration);
-        const stepDetected = this.stepDetection.compute(timestamp, linearAcc, angularRate);
-
-        if (stepDetected) {
-
-            this.pdrPosition = this.calculateNewPosition(this.pdrPosition, timestamp,
-                heading, this.stepDetection.lastStepSize);
-
-            /**
-            * Update current_position
-            */
-            if (this.options.smoother) {
-                this.smoother.generateNextPositions(this.pdrPosition);
-                const newPosition = this.smoother.pullPosition(timestamp);
-                // At this time, newPosition can be null if a new step has been detected
-                //  and smoother has not been completely consumed.
-                if (newPosition) {
-                    this.position = newPosition;
-                }
-            } else {
-                this.position = this.pdrPosition;
-            }
-
-        } else if (this.options.smoother) {
-            // If no step is detected, we pull last known position from smoother until now (timestamp).
-            const smoothedPosition = this.smoother.pullPosition(timestamp);
-            if (!smoothedPosition) {
-                return;
-            }
-            this.position = smoothedPosition;
-        } else {
-            return;
-        }
-
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
-    }
-
-    calculateNewPosition(previousPosition, timestamp, heading, stepSize) {
-
-        /**
-         * Compute new_position
-         */
-        const newPositionWithoutMM = previousPosition.clone();
-        newPositionWithoutMM.move(stepSize, heading);
-        newPositionWithoutMM.bearing = heading;
-        newPositionWithoutMM.time = timestamp;
-
-        if (!this.mapMatching) {
-            return newPositionWithoutMM;
-        }
-
-        /**
-         * Try map-matching
-         */
-        const projection = this.mapMatching.getProjection(newPositionWithoutMM, true, true);
-        if (!projection || !projection.projection) {
-            return newPositionWithoutMM;
-        }
-
-        const projectedPosition = newPositionWithoutMM;
-        projectedPosition.level = projection.projection.level;
-
-        if (projection.distanceFromNearestElement < stepSize) {
-            projectedPosition.lat = projection.projection.lat;
-            projectedPosition.lng = projection.projection.lng;
-            return projectedPosition;
-        }
-
-        /**
-         * Adapt map-matching to not stick corridor directly
-         * /!\ This smoothed position is different from the one of Smoother
-         */
-        const smoothedPosition = projectedPosition;
-        smoothedPosition.lat = previousPosition.lat;
-        smoothedPosition.lng = previousPosition.lng;
-
-        const smoothedDistance = projection.distanceFromNearestElement * MM_CONV_SPEED;
-        const smoothedBearing = previousPosition.bearingTo(projection.projection);
-        smoothedPosition.move(smoothedDistance, smoothedBearing);
-
-        return smoothedPosition;
-    }
-
-
-    /**
-     * MapMatching
-     */
-
-    enableMapMatching(network, maxDistance, maxAngleBearing) {
-        super.enableMapMatching(network, maxDistance || MM_PDR_DIST, maxAngleBearing || MM_PDR_ANGLE);
-    }
-
-
-    /**
-     * Itinerary and PDR Locker
-     */
-
-    setItinerary(itinerary) {
-        super.setItinerary(itinerary);
-
-        if (this.options.stepdetectionlocker) {
-            this.stepDetectionLocker.setWaitingOrientation(
-                PdrProvider.retrieveWaitingOrientationFromItinerary(itinerary)
-            );
-        }
-    }
-
-    static retrieveWaitingOrientationFromItinerary(itinerary) {
-
-        if (!itinerary) {
-            throw new Error('Empty itinerary');
-        }
-
-        if (!(itinerary instanceof Itinerary)) {
-            throw new TypeError(itinerary + ' is not an instance of itinerary');
-        }
-
-        if (itinerary.length < 1) {
-            throw new Error('Empty itinerary');
-        }
-
-        const edgeAt = itinerary.getEdgeAt(LO_SEGMENT_SIZE);
-        if (edgeAt) {
-            return edgeAt.bearing;
-        }
-
-        if (itinerary.length < 2) {
-            throw new Error('Itinerary is too short');
-        }
-        return itinerary.secondEdge.bearing;
-    }
-
-    setStepDetectionLockerOrientation(orientation) {
-        this.stepDetectionLocker.setWaitingOrientation(orientation);
-    }
-
-    // Linear acceleration in ENU
-    static computeLinearAcceleration(quaternion, acc) {
-        const linearAcc = Quaternion.rotate(Quaternion.inverse(quaternion), acc);
-        linearAcc[2] -= GeoConstants.EARTH_GRAVITY;
-        return linearAcc;
-    }
-}
-
-export default PdrProvider;

package/src/providers/pose/pdr/helpers/HeadingUnlocker.js

@@ -1,41 +0,0 @@
-import isnumber from 'lodash.isnumber';
-
-import { diffAngle } from '@wemap/maths';
-
-const LO_ANGLE = 15 * Math.PI / 180;
-
-/**
- * HeadingUnlocker is designed to block Pdr Step Detection until user is aiming in the right direction
- */
-class HeadingUnlocker {
-
-    constructor() {
-        // HeadingUnlocker status, by default it is unlocked
-        this.locked = false;
-    }
-
-    setWaitingOrientation(waitingOrientation) {
-        this.waitingOrientation = waitingOrientation;
-        this.locked = true;
-    }
-
-    feedHeading(heading) {
-
-        if (!isnumber(this.waitingOrientation)) {
-            throw new Error('HeadingUnlocker has not been initialized by setWaitingOrientation');
-        }
-
-        if (!this.locked) {
-            throw new Error('HeadingUnlocker is already unlocked');
-        }
-
-        if (Math.abs(diffAngle(heading, this.waitingOrientation)) < LO_ANGLE) {
-            this.locked = false;
-        }
-
-        return this.locked;
-    }
-
-}
-
-export default HeadingUnlocker;