@wemap/positioning 1.2.0

package/src/components/Logger.jsx

@@ -0,0 +1,113 @@
+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/components/NavigationDebugApp.jsx

@@ -0,0 +1,106 @@
+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/components/Others.jsx

@@ -0,0 +1,121 @@
+import React from 'react';
+
+import { Constants as GeoConstants } from '@wemap/geo';
+import {
+    Quaternion, Vector3, Utils as MathUtils
+} 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 += MathUtils.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/components/RelativeAttitude.jsx

@@ -0,0 +1,104 @@
+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/components/Utils.js

@@ -0,0 +1,35 @@
+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/components/index.js

@@ -0,0 +1,13 @@
+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/index.js

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

package/src/providers/FixedLocationImuLocationSource.js

@@ -0,0 +1,66 @@
+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/providers/GnssLocationSource.js

@@ -0,0 +1,118 @@
+import { WGS84UserPosition } from '@wemap/geo';
+import { Utils as MathUtils } 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 = MathUtils.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;