@wemap/positioning 2.1.0 → 2.2.0

package/src.old/components/Logger.jsx

@@ -1,113 +0,0 @@
-import React from 'react';
-
-import NavigationHandler from '../NavigationHandler';
-import SensorsLogger from '../sensors/SensorsLogger';
-import SensorsLoggerUtils from '../sensors/SensorsLoggerUtils';
-
-// import ArCamera from 'ar/DebugArCamera';
-
-class Logger extends React.Component {
-
-    constructor(props, context) {
-        super(props, context);
-
-        this.navigationHandler = new NavigationHandler();
-
-        // Create a SensorsLogger instance
-        this.sensorsLogger = new SensorsLogger();
-
-        this.state = {
-            logsNumber: 0,
-            videoSize: 0,
-            isStarted: false
-        };
-    }
-
-    start() {
-
-        this.setState({ isStarted: true });
-        this.navigationHandler.startAbsolute([]).then(() => {
-            this.messagesInterval = setInterval(() => {
-                this.setState({
-                    logsNumber: this.sensorsLogger.dataset.length,
-                    videoSize: this.sensorsLogger.getVideoSize()
-                });
-            }, 1000);
-        }).catch(() => console.log('Nothing to log'));
-
-        /**
-         * Send the SensorsLogger to NavigationHandler and Camera View
-         */
-
-        this.navigationHandler.startLogger(this.sensorsLogger);
-
-        // ArCamera is a custom Camera view which can handle the SensorsLogger
-        // this.arCamera.startLogger(this.sensorsLogger);
-    }
-
-    stop() {
-        this.setState({ isStarted: false });
-
-        if (this.messagesInterval) {
-            clearInterval(this.messagesInterval);
-        }
-
-        this.navigationHandler.stop();
-
-        /**
-         * Stop SensorsLogger
-         */
-        this.navigationHandler.stopLogger();
-        // this.arCamera.stopLogger();
-
-    }
-
-    download() {
-        SensorsLoggerUtils.download(this.sensorsLogger);
-    }
-
-    render() {
-        const logsNumber = this.state.logsNumber;
-        const videoSize = this.state.videoSize;
-
-        let startStopButton;
-        if (this.state.isStarted) {
-            startStopButton = <button onClick={() => this.stop()}>Stop</button>;
-        } else {
-            startStopButton = <button onClick={() => this.start()}>Start</button>;
-        }
-
-        let downloadButton;
-        if (!this.state.isStarted && this.state.logsNumber > 0) {
-            downloadButton = <button onClick={() => this.download()}>Download</button>;
-        }
-
-        return (
-            <div>
-                <p>{startStopButton} {downloadButton ? downloadButton : ''}</p>
-                <p>Logs: {logsNumber}</p>
-                <p>Video size: {videoSize}</p>
-
-                <div style={{
-                    position: 'absolute',
-                    width: '200px',
-                    height: '100px',
-                    left: 0,
-                    right: 0,
-                    margin: 'auto'
-                }}>
-                    {
-
-                    /* <ArCamera ref={(arCamera) => {
-                        this.arCamera = arCamera;
-                    }} /> */
-                    }
-                </div>
-            </div>
-        );
-
-    }
-}
-
-export default Logger;
-

package/src.old/components/NavigationDebugApp.jsx

@@ -1,106 +0,0 @@
-import React from 'react';
-import parse from 'url-parse';
-import {
-    AppBar, Tabs, Tab
-} from '@material-ui/core';
-import {
-    Link, Route, HashRouter, Switch
-} from 'react-router-dom';
-
-import Imu from './Imu';
-import Others from './Others';
-import RelativeAttitude from './RelativeAttitude';
-import AbsoluteAttitude from './AbsoluteAttitude';
-import LocationSource from './LocationSource';
-import Logger from './Logger';
-
-
-class NavigationDebugApp extends React.Component {
-
-    state = { value: 0 };
-
-    handleChange = (event, value) => {
-        this.setState({ value });
-    };
-
-    componentDidMount() {
-        let hash = parse(window.location.href).hash;
-        if (hash) {
-            hash = hash.substring(1);
-            switch (hash) {
-            case 'imu':
-                this.setState({ value: 0 });
-                break;
-            case 'relative-attitude':
-                this.setState({ value: 1 });
-                break;
-            case 'absolute-attitude':
-                this.setState({ value: 2 });
-                break;
-            case 'location-source':
-                this.setState({ value: 3 });
-                break;
-            case 'others':
-                this.setState({ value: 4 });
-                break;
-            case 'logger':
-                this.setState({ value: 5 });
-                break;
-            }
-        }
-    }
-
-    render() {
-
-        return (
-            <HashRouter hashType='noslash'>
-                <div>
-                    <AppBar position="static">
-                        <Tabs value={this.state.value}
-                            variant="scrollable"
-                            scrollButtons="auto"
-                            onChange={this.handleChange}>
-                            <Tab label="IMU"
-                                to="/imu"
-                                component={Link} />
-                            <Tab label="Relative Attitude"
-                                to="/relative-attitude"
-                                component={Link} />
-                            <Tab label="Absolute Attitude"
-                                to="/absolute-attitude"
-                                component={Link} />
-                            <Tab label="Location Source"
-                                to="/location-source"
-                                component={Link} />
-                            <Tab label="Others"
-                                to="/others"
-                                component={Link} />
-                            <Tab label="Logger"
-                                to="/logger"
-                                component={Link} />
-                        </Tabs>
-                    </AppBar>
-
-                    <Switch>
-                        <Route path="/imu"
-                            component={Imu} />
-                        <Route path="/relative-attitude"
-                            component={RelativeAttitude} />
-                        <Route path="/absolute-attitude"
-                            component={AbsoluteAttitude} />
-                        <Route path="/location-source"
-                            component={LocationSource} />
-                        <Route path="/others"
-                            component={Others} />
-                        <Route path="/logger"
-                            component={Logger} />
-                        <Route path="/"
-                            component={Imu} />
-                    </Switch>
-                </div>
-            </HashRouter>
-        );
-    }
-}
-
-export default NavigationDebugApp;

package/src.old/components/Others.jsx

@@ -1,121 +0,0 @@
-import React from 'react';
-
-import { Constants as GeoConstants } from '@wemap/geo';
-import {
-    Quaternion, Vector3, rad2deg
-} from '@wemap/maths';
-
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import SensorsCompatibility from '../sensors/SensorsCompatibility';
-import StepDetectionLadetto from '../providers/steps/StepDetectionLadetto';
-import StepDetectionMinMaxPeaks from '../providers/steps/StepDetectionMinMaxPeaks';
-import StepDetectionMinMaxPeaks2 from '../providers/steps/StepDetectionMinMaxPeaks2';
-
-class Others extends React.Component {
-
-    constructor(props, context) {
-        super(props, context);
-
-        this.attitudeHandlerInclination = new AttitudeHandler();
-        this.brAccGyr = new SensorsCompatibility();
-        this.attitudeHandler = new AttitudeHandler();
-        this.ladettoStepDetector = new StepDetectionLadetto();
-        this.minMaxStepDetector = new StepDetectionMinMaxPeaks();
-        this.minMaxStepDetector2 = new StepDetectionMinMaxPeaks2();
-
-        this.AccRef = [0, 0, GeoConstants.EARTH_GRAVITY];
-
-        this.state = {
-            inclination: null,
-            stepCounterLadetto: 0,
-            stepCounterMinMax: 0,
-            stepCounterMinMax2: 0,
-            displayMode: null,
-            mag: null
-        };
-    }
-
-    componentDidMount() {
-        this.attitudeHandlerInclination.startMonitoringInclination(inclination => {
-            this.setState({ inclination: inclination });
-        }).catch(() => this.setState({ inclination: -1 }));
-
-        Promise.all([
-            this.attitudeHandler.startRelative(
-                attitude => {
-                    this.attitude = attitude;
-                },
-                AttitudeHandler.RelativeMethod.INTERNAL_EKF),
-            this.attitudeHandler.setRelativeHeading(0),
-            this.brAccGyr.startImu(imu => {
-
-                if (!this.attitude) {
-                    return;
-                }
-
-                let linearAcc = Quaternion.rotate(Quaternion.inverse(this.attitude.quaternion), imu.acc);
-                linearAcc = Vector3.subtract(linearAcc, this.AccRef);
-
-                const stepDetectedLadetto = this.ladettoStepDetector.compute(imu.timestamp, linearAcc);
-                if (stepDetectedLadetto) {
-                    this.setState(({ stepCounterLadetto }) => ({ stepCounterLadetto: stepCounterLadetto + 1 }));
-                }
-                const stepDetectedMinMax = this.minMaxStepDetector.compute(imu.timestamp, linearAcc);
-                if (stepDetectedMinMax) {
-                    this.setState(({ stepCounterMinMax }) => ({ stepCounterMinMax: stepCounterMinMax + 1 }));
-                }
-                const stepDetectedMinMax2 = this.minMaxStepDetector2.compute(imu.timestamp, linearAcc, imu.gyr);
-                if (stepDetectedMinMax2) {
-                    this.setState(({ stepCounterMinMax2 }) => ({ stepCounterMinMax2: stepCounterMinMax2 + 1 }));
-                }
-
-            }, {
-                accelerometer: true,
-                gyroscope: true
-            }, 60)
-        ]).catch(() => this.setState({ stepCounter: -1 }));
-
-    }
-
-    componentWillUnmount() {
-        this.attitudeHandlerInclination.stopMonitoringInclination();
-
-        this.attitudeHandler.stopRelative();
-        this.brAccGyr.stopImu();
-    }
-
-    render() {
-
-        let inclinationString = 'Inclination: ';
-        const inclination = this.state.inclination;
-        if (!inclination) {
-            inclinationString += 'Waiting';
-        } else if (inclination === -1) {
-            inclinationString += 'Not available';
-        } else {
-            inclinationString += rad2deg(inclination).toFixed(2);
-        }
-
-        let stepCounterLadetto = 'StepCounter Ladetto: ';
-        stepCounterLadetto += this.state.stepCounterLadetto;
-
-
-        let stepCounterMinMax = 'StepCounter MinMax: ';
-        stepCounterMinMax += this.state.stepCounterMinMax;
-
-
-        let stepCounterMinMax2 = 'StepCounter MinMax2: ';
-        stepCounterMinMax2 += this.state.stepCounterMinMax2;
-
-
-        return (<p>
-            {inclinationString}<br />
-            {stepCounterLadetto}<br />
-            {stepCounterMinMax}<br />
-            {stepCounterMinMax2}
-        </p>);
-
-    }
-}
-
-export default Others;

package/src.old/components/RelativeAttitude.jsx

@@ -1,104 +0,0 @@
-import React from 'react';
-
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import Utils from './Utils';
-
-class RelativeAttitude extends React.Component {
-
-    constructor(props, context) {
-        super(props, context);
-
-        this.attitudeHandlerBrowser = new AttitudeHandler();
-        this.attitudeHandlerEkf = new AttitudeHandler();
-        // this.attitudeHandlerAutomatic = new AttitudeHandler();
-
-        this.state = {
-            attitudeBrowser: null,
-            attitudeEkf: null,
-            // attitudeAuto: null,
-            deviceorientation: null
-        };
-    }
-
-
-    componentDidMount() {
-        const browserPromise = Promise.all([
-            this.attitudeHandlerBrowser.startRelative(
-                attitude => this.setState({ attitudeBrowser: attitude }),
-                AttitudeHandler.RelativeMethod.BROWSER),
-            this.attitudeHandlerBrowser.setRelativeHeading(0)]);
-        browserPromise.catch(() =>
-            this.setState({ attitudeBrowser: -1 })
-        );
-
-        const ekfPromise = Promise.all([
-            this.attitudeHandlerEkf.startRelative(
-                attitude => this.setState({ attitudeEkf: attitude }),
-                AttitudeHandler.RelativeMethod.INTERNAL_EKF),
-            this.attitudeHandlerEkf.setRelativeHeading(0)]);
-        ekfPromise.catch(() =>
-            this.setState({ attitudeEkf: -1 })
-        );
-
-        // const autoPromise = Promise.all([
-        //     this.attitudeHandlerAutomatic.startRelative(
-        //         attitude => this.setState({ attitudeAuto: attitude }),
-        //         AttitudeHandler.RelativeMethod.AUTOMATIC),
-        //     this.attitudeHandlerAutomatic.setRelativeHeading(0)]);
-        // autoPromise.catch(() =>
-        //     this.setState({ attitudeAuto: -1 })
-        // );
-
-        this.onDeviceOrientationEventListener = (e) => this.setState({ deviceorientation: e });
-        window.addEventListener('deviceorientation', this.onDeviceOrientationEventListener, true);
-
-    }
-
-    componentWillUnmount() {
-        this.attitudeHandlerBrowser.stopRelative();
-        this.attitudeHandlerEkf.stopRelative();
-        // this.attitudeHandlerAutomatic.stopRelative();
-        window.removeEventListener('deviceorientation', this.onDeviceOrientationEventListener, true);
-    }
-
-    render() {
-
-        let rawRender = <p>Waiting</p>;
-
-        if (this.state.deviceorientation) {
-            const alpha = this.state.deviceorientation.alpha;
-            const beta = this.state.deviceorientation.beta;
-            const gamma = this.state.deviceorientation.gamma;
-
-            if (alpha && beta && gamma) {
-                rawRender = <p>alpha: {alpha.toFixed(2)}, <br />
-                    beta: {beta.toFixed(2)}, <br />
-                    gamma: {gamma.toFixed(2)}</p>;
-            }
-
-        }
-
-        const browserRender = Utils.renderAttitude(this.state.attitudeBrowser);
-        const ekfRender = Utils.renderAttitude(this.state.attitudeEkf);
-        // const autoRender = Utils.renderAttitude(this.state.attitudeAuto);
-
-        return (
-            <div>
-                <h3>Raw:</h3>
-                {rawRender}
-                <h3>From browser:</h3>
-                {browserRender}
-                <h3>From Ekf:</h3>
-                {ekfRender}
-                {
-
-                    /* <h3>From Automatic:</h3>
-                    {autoRender} */
-                }
-            </div>
-        );
-    }
-}
-
-export default RelativeAttitude;
-

package/src.old/components/Utils.js

@@ -1,35 +0,0 @@
-import React from 'react'; // eslint-disable-line no-unused-vars
-
-class Utils {
-
-    static renderAttitude(attitude) {
-
-        if (!attitude) {
-            return <p>Waiting</p>;
-        }
-
-        if (attitude === -1) {
-            return <p>Not available</p>;
-        }
-
-        const quaternion = attitude.quaternion;
-
-        const w = quaternion[0].toFixed(3);
-        const x = quaternion[1].toFixed(3);
-        const y = quaternion[2].toFixed(3);
-        const z = quaternion[3].toFixed(3);
-
-        const euler = attitude.eulerAnglesDegrees;
-        const yaw = euler[0].toFixed(2);
-        const pitch = euler[1].toFixed(2);
-        const roll = euler[2].toFixed(2);
-        const heading = attitude.headingDegrees.toFixed(2);
-
-        return <p>Quaternion: [{w}, {x}, {y}, {z}]<br />
-            Eulers: [{yaw}, {pitch}, {roll}]<br />
-            Heading: {heading}</p>;
-    }
-
-}
-
-export default Utils;

package/src.old/components/index.js

@@ -1,13 +0,0 @@
-import NavigationDebugApp from './NavigationDebugApp';
-import React from 'react';
-import ReactDOM from 'react-dom';
-
-const createReactElement = (component, container) => ReactDOM.render(
-    React.createElement(component, {}, null),
-    container
-);
-
-export {
-    NavigationDebugApp,
-    createReactElement
-};

package/src.old/index.js

@@ -1,7 +0,0 @@
-import AttitudeHandler from './attitude/AttitudeHandler';
-import NavigationHandler from './NavigationHandler';
-
-export {
-    AttitudeHandler,
-    NavigationHandler
-};

package/src.old/providers/FixedLocationImuLocationSource.js

@@ -1,66 +0,0 @@
-import LocationSource from './LocationSource';
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import Constants from '../Constants';
-
-
-class FixedLocationImuLocationSource extends LocationSource {
-
-    constructor(callback) {
-        super(callback);
-        this.attitudeHandler = new AttitudeHandler();
-    }
-
-    /**
-     * Start the location source algorithm
-     * @override
-     */
-    start(fixedLocation) {
-        super.start();
-
-        return new Promise((resolve, reject) => {
-            this.pose.location = fixedLocation;
-            if (fixedLocation && this.attitudeHandler) {
-                this.attitudeHandler.setUserLocationForAbsolute(fixedLocation);
-                this.attitudeHandler.startAbsolute(
-                    attitude => {
-                        this.pose.attitude = attitude;
-                        this.notify();
-                    })
-                    .catch(reject);
-            }
-            resolve();
-            this.notify();
-        });
-    }
-
-    /**
-     * Stop the location source algorithm
-     * @override
-     */
-    stop() {
-        super.stop();
-
-        if (this.attitudeHandler) {
-            this.attitudeHandler.stopAbsolute();
-            this.attitudeHandler = null;
-        }
-    }
-
-    setLocation(location) {
-        this.pose.location = location;
-        if (this.attitudeHandler) {
-            this.attitudeHandler.setUserLocationForAbsolute(location);
-        }
-        this.notify();
-    }
-
-    /**
-     * Get provider name
-     * @override
-     */
-    static get providerName() {
-        return Constants.LOCATION_SOURCE_PROVIDERS.FIXED_LOCATION;
-    }
-}
-
-export default FixedLocationImuLocationSource;

package/src.old/providers/GnssLocationSource.js

@@ -1,118 +0,0 @@
-import { WGS84UserPosition } from '@wemap/geo';
-import { deg2rad } from '@wemap/maths';
-
-import LocationSource from './LocationSource';
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import Constants from '../Constants';
-import SensorsLogger from '../sensors/SensorsLogger';
-import SensorsLoggerUtils from '../sensors/SensorsLoggerUtils';
-
-
-const GNSS_OPTIONS = {
-    enableHighAccuracy: false,
-    timeout: Infinity,
-    maximumAge: 0
-};
-
-class GnssLocationSource extends LocationSource {
-
-    geoLocationId = -1;
-
-    constructor(callback, imuEnabled = true) {
-        super(callback);
-        this.initialized = false;
-        if (imuEnabled) {
-            this.attitudeHandler = new AttitudeHandler();
-        }
-    }
-
-    /**
-     * Start the location source algorithm
-     * @override
-     */
-    start() {
-        super.start();
-
-        if (!navigator || !navigator.geolocation) {
-            return Promise.reject();
-        }
-
-        if (this.attitudeHandler) {
-            this.attitudeHandler.startAbsolute(
-                attitude => {
-                    this.pose.attitude = attitude;
-                    this.notify();
-                })
-                // Attitude is optionnal here, do not throw an error if it not works.
-                .catch(() => { });
-        }
-
-        return new Promise((resolve, reject) => {
-            this.geoLocationId = navigator.geolocation.watchPosition(
-                position => {
-
-                    const coords = position.coords;
-                    if (!coords) {
-                        return;
-                    }
-
-                    let bearing;
-                    if (coords.heading) {
-                        bearing = deg2rad(coords.heading);
-                    }
-
-                    const timestamp = SensorsLoggerUtils.unixTimestampToPerformanceNow(position.timestamp) / 1e3;
-
-                    this.pose.location = new WGS84UserPosition(
-                        coords.latitude,
-                        coords.longitude,
-                        coords.altitude,
-                        timestamp,
-                        coords.accuracy,
-                        bearing,
-                        this.providerName);
-
-                    if (!this.initialized) {
-                        if (this.attitudeHandler) {
-                            this.attitudeHandler.setUserLocationForAbsolute(this.pose.location);
-                        }
-                        resolve();
-                        this.initialized = true;
-                    }
-
-                    this.notify();
-
-                    if (this.logger) {
-                        const data = [coords.latitude, coords.longitude, coords.altitude, coords.accuracy, coords.heading];
-                        this.logger.feed(SensorsLogger.DataType.WATCH_POSITION, timestamp, data);
-                    }
-                },
-                reject,
-                GNSS_OPTIONS);
-        });
-    }
-
-    /**
-     * Stop the location source algorithm
-     * @override
-     */
-    stop() {
-        super.stop();
-
-        navigator.geolocation.clearWatch(this.geoLocationId);
-        if (this.attitudeHandler) {
-            this.attitudeHandler.stopAbsolute();
-            this.attitudeHandler = null;
-        }
-    }
-
-    /**
-     * Get provider name
-     * @override
-     */
-    static get providerName() {
-        return Constants.LOCATION_SOURCE_PROVIDERS.GNSS;
-    }
-}
-
-export default GnssLocationSource;