@wemap/providers 3.1.3 → 3.1.5

package/debug/components/PoseComponent.jsx

@@ -1,169 +0,0 @@
-import React from 'react';
-
-import {
-    PositionSmoother, ProvidersInterface, EventType
-} from '../..';
-
-import Utils from './Utils';
-import MapComponent from './MapComponent';
-import NavigationConfig from './NavigationConfig';
-
-import './Common.css';
-import StartStopComponent from './StartStopComponent';
-
-
-class PoseComponent extends React.Component {
-
-    started = false;
-
-    constructor(props, context) {
-        super(props, context);
-        this.state = {
-            position: null,
-            attitude: null
-        };
-
-        this.smoother = new PositionSmoother(position => {
-            if (this.map && this.started) {
-                this.map.updatePosition(position);
-            }
-        });
-
-        ProvidersInterface.logger = true;
-    }
-
-    componentWillUnmount() {
-        this.onStop();
-    }
-
-    onStart = () => {
-        this.started = true;
-        this.onAttitudeEvent(ProvidersInterface.getLastKnown(EventType.AbsoluteAttitude));
-        this.attitudeProviderId = ProvidersInterface.addEventListener(
-            EventType.AbsoluteAttitude,
-            this.onAttitudeEvent,
-            this.onAttitudeError
-        );
-
-        this.onPositionEvent(ProvidersInterface.getLastKnown(EventType.AbsolutePosition));
-        this.positionProviderId = ProvidersInterface.addEventListener(
-            EventType.AbsolutePosition,
-            this.onPositionEvent,
-            this.onPositionError
-        );
-    }
-
-    onStop = () => {
-        this.started = false;
-        ProvidersInterface.removeEventListener(this.attitudeProviderId);
-        ProvidersInterface.removeEventListener(this.positionProviderId);
-        this.map.updatePosition(null);
-        this.map.updateAttitude(null);
-    }
-
-    onPositionEvent = position => {
-        if (!position) {
-            return;
-        }
-        this.setState({ position });
-        this.smoother.feed(position);
-    };
-
-    onPositionError = error => {
-        this.setState({ position: error });
-    };
-
-    onAttitudeEvent = attitude => {
-        if (!attitude) {
-            return;
-        }
-        this.setState({ attitude });
-        if (this.map && this.started) {
-            this.map.updateAttitude(attitude);
-        }
-    };
-
-    onAttitudeError = error => {
-        this.setState({ attitude: error });
-    };
-
-    handleHeadingButton() {
-        ProvidersInterface.feed(EventType.AbsoluteHeading, NavigationConfig.INITIAL_HEADING);
-    }
-
-    handlePosButton() {
-        ProvidersInterface.feed(EventType.AbsolutePosition, NavigationConfig.INITIAL_POSITION);
-    }
-
-    handleItinerary() {
-        const itinerary = NavigationConfig.ITINERARY;
-        ProvidersInterface.feed(EventType.Network, itinerary);
-        this.setState({ itinerary });
-    }
-
-
-    render() {
-
-        const errored = this.state.attitude instanceof Error
-            && this.state.position instanceof Error;
-
-        return (
-            <div style={{
-                display: 'flex',
-                flexFlow: 'column',
-                height: 'calc(100% - 16px)',
-                padding: '8px'
-            }}>
-
-                <StartStopComponent
-                    onStart={this.onStart}
-                    onStop={this.onStop}
-                    errored={errored}
-                />
-
-                <div style={{ marginTop: '10px' }}>
-                    <input type="button"
-                        onClick={() => this.handlePosButton()}
-                        value="Send Wemap position" />
-                    <input type="button"
-                        style={{ marginLeft: '10px' }}
-                        onClick={() => this.handleHeadingButton()}
-                        value="Send heading" />
-                    <input type="button"
-                        value="Add itinerary"
-                        style={{ marginLeft: '10px' }}
-                        onClick={() => this.handleItinerary()} />
-                </div>
-
-                <div style={{
-                    display: 'flex',
-                    flexFlow: 'row'
-                }}>
-                    <div style={{ width: '50%' }}>
-                        <div className="title">Position</div>
-                        {Utils.renderPositionEvent(this.state.position)}
-                    </div>
-                    <div style={{ width: '50%' }}>
-                        <div className="title">Attitude</div>
-                        {Utils.renderAttitudeEvent(this.state.attitude)}
-                    </div>
-                </div>
-
-                <div className="title">Map</div>
-                <div style={{
-                    flexGrow: 1,
-                    height: '0px',
-                    minHeight: '300px'
-                }}>
-                    <MapComponent
-                        ref={map => (this.map = map)}
-                        network={this.state.itinerary}
-                    />
-                </div>
-            </div >
-
-        );
-    }
-}
-
-export default PoseComponent;

package/debug/components/index.js

@@ -1,28 +0,0 @@
-import React from 'react';
-import ReactDOM from 'react-dom';
-
-import AbsoluteAttitudeComponent from './AbsoluteAttitudeComponent';
-import AbsolutePositionComponent from './AbsolutePositionComponent';
-import GnssWifiComponent from './GnssWifiComponent';
-import ImuComponent from './ImuComponent';
-import InclinationComponent from './InclinationComponent';
-import PoseComponent from './PoseComponent';
-import RelativeAttitudeComponent from './RelativeAttitudeComponent';
-import StepDetectionComponent from './StepDetectionComponent';
-
-const createReactElement = (component, container) => ReactDOM.render(
-    React.createElement(component, {}, null),
-    container
-);
-
-export {
-    AbsoluteAttitudeComponent,
-    AbsolutePositionComponent,
-    ImuComponent,
-    InclinationComponent,
-    GnssWifiComponent,
-    PoseComponent,
-    RelativeAttitudeComponent,
-    StepDetectionComponent,
-    createReactElement
-};

package/src/events/Availability.js

@@ -1,44 +0,0 @@
-class Availability {
-
-    isSupported = false;
-    reason = null;
-
-    static no(reason) {
-        const availability = new Availability();
-        availability.reason = reason;
-        availability.isSupported = false;
-        return availability;
-    }
-
-    static yes() {
-        const availability = new Availability();
-        availability.isSupported = true;
-        return availability;
-    }
-
-    static merge(...availabilities) {
-        for (let i = 0; i < availabilities.length; i++) {
-            const availability = availabilities[i];
-            if (!availability.isSupported) {
-                return availability;
-            }
-        }
-        return Availability.yes();
-    }
-
-    static union(...availabilities) {
-        if (availabilities.length === 0) {
-            return Availability.yes();
-        }
-
-        for (let i = 0; i < availabilities.length; i++) {
-            const availability = availabilities[i];
-            if (availability.isSupported) {
-                return availability;
-            }
-        }
-        return availabilities[0];
-    }
-}
-
-export default Availability;

package/src/providers/legacy/AbsolutePdrProvider.js

@@ -1,258 +0,0 @@
-/* eslint-disable max-statements */
-import isNumber from 'lodash.isnumber';
-
-import { UserPosition } from '@wemap/geo';
-import {
-    Itinerary, MapMatching
-} from '@wemap/graph';
-import {
-    deg2rad, Vector3
-} from '@wemap/maths';
-
-import Provider from '../Provider';
-import StepDetectionProvider from '../steps/StepDetectionProvider';
-import HeadingUnlocker from './helpers/HeadingUnlocker';
-import Availability from '../../events/Availability';
-import EventType from '../../events/EventType';
-import AbsoluteAttitudeProvider from '../attitude/absolute/AbsoluteAttitudeProvider';
-import PdrProvider from '../position/relative/PdrProvider';
-import ProviderEvent from '../../events/ProviderEvent';
-
-class AbsolutePdrProvider extends Provider {
-
-    position = null;
-
-    static MM_PDR_ANGLE = deg2rad(20);
-    static MM_PDR_DIST = 15;
-    static MM_CONV_SPEED = 0.7;
-
-    static LO_SEGMENT_SIZE = 1.5;
-
-    /**
-    * @override
-    */
-    constructor() {
-        super();
-
-        this.relativePosition = [0, 0, 0];
-
-        this.mapMatching = new MapMatching();
-        this.mapMatching.maxAngleBearing = this.constructor.MM_PDR_ANGLE;
-        this.mapMatching.maxDistance = this.constructor.MM_PDR_DIST;
-
-        this.stepDetectionLocker = new HeadingUnlocker();
-    }
-
-    /**
-    * @override
-    */
-    static get displayName() {
-        return 'Absolute PDR';
-    }
-
-    /**
-     * @override
-     */
-    static get eventsType() {
-        return [EventType.AbsoluteAttitude, EventType.AbsolutePosition];
-    }
-
-    /**
-     * @override
-     */
-    static get _availability() {
-        return Availability.merge(
-            StepDetectionProvider.availability,
-            AbsoluteAttitudeProvider.availability
-        );
-    }
-
-
-    /**
-     * @override
-     */
-    _start() {
-
-        this.pdrProviderId = this.scheduler.use(PdrProvider,
-            events => this.onPdrEvent(events),
-            error => this.notifyError(error),
-            this.name);
-
-        /**
-         * Position
-         */
-        const lastPosition = this.dataStore.getLast(EventType.AbsolutePosition);
-        if (lastPosition) {
-            this.onPositionChanged(lastPosition);
-        }
-        this.dataStore.addEventListener(EventType.AbsolutePosition, this.onPositionChanged);
-
-        /**
-         * Network
-         */
-        this.mapMatching.network = this.dataStore.getLast(EventType.Network);
-        this.dataStore.addEventListener(EventType.Network, this.onNetworkChanged);
-
-        /**
-         * Itinerary
-         */
-        const lastItinerary = this.dataStore.getLast(EventType.Itinerary);
-        if (lastItinerary) {
-            this.onItineraryChanged(lastItinerary);
-        }
-        this.dataStore.addEventListener(EventType.Itinerary, this.onItineraryChanged);
-    }
-
-    /**
-     * @override
-     */
-    _stop() {
-        this.dataStore.removeEventListener(EventType.AbsolutePosition, this.onPositionChanged);
-        this.dataStore.removeEventListener(EventType.Network, this.onNetworkChanged);
-        this.dataStore.removeEventListener(EventType.Itinerary, this.onItineraryChanged);
-        this.scheduler.release(this.pdrProviderId, this.name);
-    }
-
-    onPositionChanged = position => {
-        this.position = position.clone();
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
-    };
-
-    onNetworkChanged = network => {
-        this.mapMatching.network = network;
-    }
-
-    /**
-     * @override
-     */
-    onPdrEvent = events => {
-
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsoluteAttitude) {
-                this.attitude = event.data;
-                this.notify(event);
-            } else {
-                this.parseRelativePositionEvent(event);
-            }
-        });
-    }
-
-    parseRelativePositionEvent(event) {
-
-        if (this.position && this.attitude
-            && (!this.options.stepdetectionlocker
-                || !this.stepDetectionLocker.locked
-                || !this.stepDetectionLocker.feedHeading(this.attitude.heading))) {
-
-            this.position = this.calculateNewPosition(this.position, event);
-
-            this.notify(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
-
-        } else {
-            // this.pdrPosition has not been initialized
-            // or
-            // Step detection is locked by stepDetectionLocker
-        }
-
-        this.relativePosition = event.data.slice(0);
-    }
-
-    /**
-     * Calculate AbsolutePosition from RelativePosition event
-     * @param {UserPosition} previousPosition
-     * @param {ProviderEvent} event
-     */
-    calculateNewPosition(previousPosition, event) {
-
-        const offsetPosition = Vector3.subtract(event.data, this.relativePosition);
-
-        const dist = Math.sqrt(offsetPosition[0] ** 2 + offsetPosition[2] ** 2);
-        const bearing = Math.atan2(offsetPosition[0], -offsetPosition[2]);
-
-        /**
-         * First, compute new position without map-matching
-         */
-        const newPositionWithoutMM = previousPosition.clone();
-        newPositionWithoutMM.move(dist, bearing, offsetPosition[1]);
-        newPositionWithoutMM.bearing = bearing;
-        newPositionWithoutMM.time = event.timestamp;
-        if (isNumber(newPositionWithoutMM.accuracy) && isNumber(this.attitude.accuracy)) {
-            // 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
-            newPositionWithoutMM.accuracy += (dist / 2) * Math.sin(this.attitude.accuracy / 2);
-        }
-
-        if (!this.options.useMapMatching || !this.mapMatching.network) {
-            /**
-             * If mapMatching is not used or not set, raw position is returned
-             */
-            return newPositionWithoutMM;
-        }
-
-        /**
-         * Secondly, find map-matching projection
-         */
-        const projection = this.mapMatching.getProjection(newPositionWithoutMM, true, true);
-        if (!projection || !projection.projection) {
-            /**
-             * If no projection has been found, returns the position without map-matching
-             */
-            return newPositionWithoutMM;
-        }
-
-        const projectedPosition = newPositionWithoutMM;
-        projectedPosition.level = projection.projection.level;
-
-        if (projection.distanceFromNearestElement < dist) {
-            /**
-             * If projection is not so far from network, projected position is returned
-             */
-            projectedPosition.lat = projection.projection.lat;
-            projectedPosition.lng = projection.projection.lng;
-            return projectedPosition;
-        }
-
-        /**
-         * If projected position is far from network, we do not project calculated position directly.
-         * This allows to 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 * this.constructor.MM_CONV_SPEED;
-        const smoothedBearing = previousPosition.bearingTo(projection.projection);
-        smoothedPosition.move(smoothedDistance, smoothedBearing);
-
-        return smoothedPosition;
-    }
-
-
-    /**
-     * Itinerary and PDR Locker
-     */
-
-    /**
-     * @param {Itinerary} itinerary
-     */
-    onItineraryChanged = itinerary => {
-
-        if (!itinerary || itinerary.edges.length === 0) {
-            this.stepDetectionLocker.unlock();
-        }
-
-        const edgeAt = itinerary.getEdgeAt(this.constructor.LO_SEGMENT_SIZE);
-        if (edgeAt) {
-            this.stepDetectionLocker.lock(edgeAt.bearing);
-        } else {
-            this.stepDetectionLocker.lock(itinerary.edges[0].bearing);
-        }
-        return;
-    }
-}
-
-export default AbsolutePdrProvider;