@wemap/positioning 1.2.0

package/src/sensors/SensorsCompatibility.spec.js

@@ -0,0 +1,270 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import chaiAsPromised from 'chai-as-promised';
+import 'jsdom-global/register';
+
+import SensorsCompatibility from './SensorsCompatibility';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+chai.use(chaiAsPromised);
+
+const IOS_USER_AGENT = 'iPad';
+const ANDROID_USER_AGENT = 'Android';
+const FIREFOX_USER_AGENT = 'Firefox';
+const OPERA_USER_AGENT = 'Opera';
+const UNKNOWN_USER_AGENT = 'foobar';
+
+const defaultMotionSensors = {
+    accelerometer: true,
+    gyroscope: true,
+    magnetometer: true
+};
+
+const defaultDeviceMotionSensors = {
+    accelerometer: true,
+    gyroscope: true,
+    magnetometer: false
+};
+
+const timestamps = [
+    0, 0.02, 0.04, 0.06, 0.08
+];
+
+const accData = [
+    [-0.034561157, 3.81073, 8.860977],
+    [-0.030700684, 3.814499, 8.818954],
+    [-0.018234253, 3.8023376, 8.85762],
+    [-0.020080566, 3.8205414, 8.8676605],
+    [-0.054519653, 3.8456726, 8.810287]
+];
+
+const gyrData = [
+    [0.0047454834, 0.0028076172, 0.0022888184],
+    [0.005218506, 0.0020446777, 0.0012207031],
+    [0.0044555664, 0.0023040771, 4.4250488E-4],
+    [0.0044555664, 0.0027618408, 0.0011444092],
+    [0.0040893555, 0.0020446777, 0.0025787354]
+];
+
+
+function fakeUserAgent(userAgent) {
+    navigator.__defineGetter__('userAgent', () => userAgent);
+}
+
+const commonDeviceMotion = (userAgent = ANDROID_USER_AGENT,
+    _simulatedSensors = defaultDeviceMotionSensors,
+    _expectedSensors = defaultDeviceMotionSensors) => {
+
+    const simulatedSensors = !_simulatedSensors ? defaultMotionSensors : _simulatedSensors;
+    const expectedSensors = !_expectedSensors ? defaultMotionSensors : _expectedSensors;
+
+    return new Promise((resolve, reject) => {
+        const result = [];
+
+        fakeUserAgent(userAgent);
+        document.hasFocus = () => true;
+        const sc = new SensorsCompatibility();
+
+        let eventsReceived = 0;
+        sc.startImu((e) => {
+            result.push(e);
+
+            eventsReceived++;
+            if (eventsReceived === accData.length) {
+                resolve(result);
+            }
+        }, expectedSensors).catch(e => {
+            reject(e);
+        });
+
+        if (!simulatedSensors.accelerometer && !simulatedSensors.gyroscope) {
+            return;
+        }
+
+        for (let i = 0; i < timestamps.length; i++) {
+
+            const event = new CustomEvent('devicemotion');
+
+            Object.defineProperty(event, 'timeStamp', { get: () => timestamps[i] });
+
+            if (simulatedSensors.accelerometer) {
+                const acc = accData[i];
+                event.accelerationIncludingGravity = {
+                    x: acc[0],
+                    y: acc[1],
+                    z: acc[2]
+                };
+            }
+
+            if (simulatedSensors.gyroscope) {
+                const gyr = gyrData[i];
+                event.rotationRate = {
+                    alpha: gyr[0],
+                    beta: gyr[1],
+                    gamma: gyr[2]
+                };
+            }
+            window.dispatchEvent(event);
+        }
+    });
+};
+
+
+describe('devicemotion', () => {
+
+    it('[Android] Acc - Gyr', (done) => {
+        commonDeviceMotion(ANDROID_USER_AGENT).then((receivedDataset) => {
+            for (let i = 0; i < receivedDataset.length; i++) {
+                const e = receivedDataset[i];
+
+                const expectedGyr = gyrData[i].map(x => x * Math.PI / 180);
+                const expectedAcc = accData[i];
+                const expectedTimestamp = timestamps[i] / 1e3;
+
+                expect(e.timestamp).almost(expectedTimestamp);
+                expect(e.acc).deep.almost(expectedAcc);
+                expect(e.gyr).deep.almost(expectedGyr);
+            }
+            done();
+        }).catch(e => done(e));
+    });
+
+    it('[iOS] Acc - Gyr', (done) => {
+        commonDeviceMotion(IOS_USER_AGENT).then((receivedDataset) => {
+            for (let i = 0; i < receivedDataset.length; i++) {
+                const e = receivedDataset[i];
+
+                const expectedGyr = gyrData[i].map(x => x * Math.PI / 180);
+                const expectedAcc = accData[i].map(x => -x);
+                const expectedTimestamp = timestamps[i] / 1e3;
+
+                expect(e.timestamp).almost(expectedTimestamp);
+                expect(e.acc).deep.almost(expectedAcc);
+                expect(e.gyr).deep.almost(expectedGyr);
+            }
+            done();
+        }).catch(e => done(e));
+    });
+
+    it('[Firefox] Acc - Gyr', (done) => {
+        commonDeviceMotion(FIREFOX_USER_AGENT).then((receivedDataset) => {
+            for (let i = 0; i < receivedDataset.length; i++) {
+                const e = receivedDataset[i];
+
+                const expectedGyr = gyrData[i].map(x => x * Math.PI / 180);
+                const expectedAcc = accData[i];
+                const expectedTimestamp = timestamps[i] / 1e3;
+
+                expect(e.timestamp).almost(expectedTimestamp);
+                expect(e.acc).deep.almost(expectedAcc);
+                expect(e.gyr).deep.almost(expectedGyr);
+            }
+            done();
+        }).catch(e => done(e));
+    });
+
+    it('[Opera] Acc - Gyr', (done) => {
+        commonDeviceMotion(OPERA_USER_AGENT).then((receivedDataset) => {
+            for (let i = 0; i < receivedDataset.length; i++) {
+                const e = receivedDataset[i];
+
+                const expectedGyr = gyrData[i].map(x => x * Math.PI / 180);
+                const expectedAcc = accData[i];
+                const expectedTimestamp = timestamps[i] / 1e3;
+
+                expect(e.timestamp).almost(expectedTimestamp);
+                expect(e.acc).deep.almost(expectedAcc);
+                expect(e.gyr).deep.almost(expectedGyr);
+            }
+            done();
+        }).catch(e => done(e));
+    });
+
+
+    it('[Unknown] Acc - Gyr', (done) => {
+        commonDeviceMotion(UNKNOWN_USER_AGENT).then((receivedDataset) => {
+            for (let i = 0; i < receivedDataset.length; i++) {
+                const e = receivedDataset[i];
+
+                const expectedGyr = gyrData[i].map(x => x * Math.PI / 180);
+                const expectedAcc = accData[i];
+                const expectedTimestamp = timestamps[i] / 1e3;
+
+                expect(e.timestamp).almost(expectedTimestamp);
+                expect(e.acc).deep.almost(expectedAcc);
+                expect(e.gyr).deep.almost(expectedGyr);
+            }
+            done();
+        }).catch(e => done(e));
+    });
+
+
+    it('[Unknown] Missing gyr', (done) => {
+
+        const globalTimeout = setTimeout(() => done(), 20);
+
+        commonDeviceMotion(UNKNOWN_USER_AGENT,
+            {
+                accelerometer: true,
+                gyroscope: false
+            }, {
+                accelerometer: true,
+                gyroscope: true
+            })
+            .then(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not success'));
+            })
+            .catch(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not reject'));
+            });
+    });
+
+
+    it('[Unknown] Missing acc', (done) => {
+
+        const globalTimeout = setTimeout(() => done(), 20);
+
+        commonDeviceMotion(UNKNOWN_USER_AGENT,
+            {
+                accelerometer: true,
+                gyroscope: false
+            }, {
+                accelerometer: true,
+                gyroscope: true
+            })
+            .then(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not success'));
+            })
+            .catch(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not reject'));
+            });
+    });
+
+
+    it('[Unknown] No sensor', (done) => {
+
+        const globalTimeout = setTimeout(() => done(), 20);
+
+        commonDeviceMotion(UNKNOWN_USER_AGENT,
+            {
+                accelerometer: false,
+                gyroscope: false
+            }, {
+                accelerometer: true,
+                gyroscope: true
+            })
+            .then(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not success'));
+            })
+            .catch(() => {
+                clearTimeout(globalTimeout);
+                done(Error('Should not reject'));
+            });
+    });
+});

package/src/sensors/SensorsLogger.js

@@ -0,0 +1,94 @@
+
+const DataType = {
+    ACCELEROMETER: 0,
+    GYROSCOPE: 1,
+    DEVICE_ORIENTATION_RELATIVE: 2,
+    DEVICE_ORIENTATION_ABSOLUTE: 3,
+    WATCH_POSITION: 4,
+    USER_INPUT_POSITION: 10,
+    USER_INPUT_HEADING: 11,
+    IP_POSITION: 12
+};
+
+const PRECISION = 1000;
+
+class SensorsLogger {
+
+    constructor() {
+        this.dataset = [];
+        this.videoBlobs = [];
+        this.removeDuplicates = true;
+
+        this.lastDataTimestamp = new Array(DataType.length);
+        for (let i = 0; i < DataType.length; i++) {
+            this.lastDataTimestamp[i] = 0;
+        }
+    }
+
+    static get DataType() {
+        return DataType;
+    }
+
+    disableRemoveDuplicates() {
+        this.removeDuplicates = false;
+    }
+
+    feedWithCurrentTime(dataType, data, compact) {
+        this.feed(dataType, performance.now() / 1e3, data, compact);
+    }
+
+    feed(dataType, timestamp, _data, compact = false) {
+
+        let data;
+
+        const smallTimestamp = Math.round(timestamp * PRECISION) / PRECISION;
+        if (this.removeDuplicates && this.lastDataTimestamp[dataType] === timestamp) {
+            return;
+        }
+
+        if (compact) {
+            const smallData = new Array(_data.length);
+            for (let i = 0; i < _data.length; i++) {
+                smallData[i] = Math.round(_data[i] * PRECISION) / PRECISION;
+            }
+            data = smallData;
+        } else {
+            data = _data;
+        }
+
+        const dataArray = [dataType, smallTimestamp].concat(data);
+        this.dataset.push(dataArray);
+        if (this.removeDuplicates) {
+            this.lastDataTimestamp[dataType] = timestamp;
+        }
+    }
+
+    // TODO: this is not linked to the rest of the code. Check why
+    // videoFeed = event => {
+    //     if (event.data && event.data.size > 0) {
+    //         this.videoBlobs.push(event.data);
+    //     }
+    // }
+
+    getVideoSize() {
+        return this.videoBlobs.length;
+    }
+
+    /**
+    * Pop current logs dataset
+    */
+    pop() {
+        const currentDataset = this.dataset;
+        this.dataset = [];
+        return currentDataset;
+    }
+
+    popVideoBlob() {
+        const currentVideoBlobs = this.videoBlobs;
+        this.videoBlobs = [];
+        return new Blob(currentVideoBlobs, { type: 'video/webm' });
+    }
+
+}
+
+export default SensorsLogger;

package/src/sensors/SensorsLoggerUtils.js

@@ -0,0 +1,35 @@
+import JSZip from 'jszip';
+import { saveAs } from 'file-saver';
+
+class SensorsLoggerUtils {
+
+    static download(sensorsLogger) {
+
+        const data = sensorsLogger.pop();
+        const csvData = data.map(row => row.join(',')).join('\r\n');
+
+        const zip = new JSZip();
+        zip.file('data.csv', csvData);
+        zip.file('video.webm', sensorsLogger.popVideoBlob());
+        zip.generateAsync({ type: 'blob' })
+            .then(function(content) {
+                saveAs(content, 'dataset.zip');
+            });
+    }
+
+
+    /**
+     * Return a value equivalent to performance now from a given unix timestamp
+     * @param {Number} timestamp a unix timestamp
+     * @returns timestamp relative to performance.now()
+     */
+    static unixTimestampToPerformanceNow(timestamp) {
+
+        if (!window || !window.performance) {
+            throw new Error('window.performance does not exist');
+        }
+        return window.performance.now() + timestamp - new Date().getTime();
+    }
+}
+
+export default SensorsLoggerUtils;

package/src.new/NavigationHandler.js

@@ -0,0 +1,62 @@
+import noop from 'lodash.noop';
+
+import FakeLocationSource from './providers/FakeLocationSource';
+
+/**
+ * @private
+ */
+class NavigationHandler {
+
+    static State = {
+        STARTING: 0,
+        STARTED: 1,
+        STOPPPED: 2
+    };
+
+    _state = NavigationHandler.State.STOPPPED;
+
+    /**
+     * Constructor of NavigationHandler
+     * @param {Function} _callback callback on new pose
+     * @public
+     */
+    constructor(_callback) {
+        const callback = _callback || noop;
+        this.locationSource = new FakeLocationSource(pose => callback(pose));
+    }
+
+    startIfNecessary() {
+
+        if (this._state === NavigationHandler.State.STARTING
+            || this._state === NavigationHandler.State.STARTED) {
+            const msg = 'Navigation already started';
+            console.log(msg);
+            return Promise.resolve(msg);
+        }
+
+        this._state = NavigationHandler.State.STARTING;
+
+        const promise = this.locationSource.start();
+        promise
+            .then(() => (this._state = NavigationHandler.State.STARTED))
+            .catch(() => (this._state = NavigationHandler.State.STOPPPED));
+
+        return promise;
+    }
+
+    stop() {
+
+        if (this._state === NavigationHandler.State.STOPPPED) {
+            const msg = 'Navigation already stopped';
+            console.log(msg);
+            return Promise.resolve(msg);
+        }
+
+        this.locationSource.stop();
+        this._state = NavigationHandler.State.STOPPPED;
+        return Promise.resolve();
+    }
+
+}
+
+export default NavigationHandler;

package/src.new/index.js

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

package/src.new/providers/FakeLocationSource.js

@@ -0,0 +1,39 @@
+import noop from 'lodash.noop';
+
+/**
+ * @private
+ */
+class FakeLocationSource {
+
+    constructor(callback) {
+        this.callback = callback || noop;
+    }
+
+    start() {
+        this.interval = setInterval(() => {
+            this.callback({
+                location: {
+                    lat: 45,
+                    lng: 5,
+                    alt: 0
+                },
+                attitude: {
+                    quaternion: [1, 0, 0, 0]
+                }
+            });
+        }, 1000);
+
+        return Promise.resolve();
+    }
+
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+        return Promise.resolve();
+    }
+
+}
+
+export default FakeLocationSource;

package/webpack/webpack.common.js

@@ -0,0 +1,20 @@
+module.exports = {
+    module: {
+        rules: [
+            {
+                test: /\.jsx?$/,
+                include: [
+                    /src/,
+                    /wemap-(.*)/
+                ],
+                exclude: /(\/mapbox-gl\/|.test.js|.spec.js|.mock.js)/,
+                use: { loader: 'babel-loader' }
+            },
+            {
+                test: /\.css$/,
+                use: { loader: 'css-loader' }
+            }
+        ]
+    },
+    resolve: { extensions: ['.js', '.jsx'] }
+};

package/webpack/webpack.dev.js

@@ -0,0 +1,24 @@
+const merge = require('webpack-merge');
+const path = require('path');
+
+const common = require('./webpack.common.js');
+
+const debugFolder = path.join(__dirname, '../debug');
+
+module.exports = merge(common, {
+    mode: 'development',
+    entry: { 'navigation-components': './src/components/index.js' },
+    output: {
+        publicPath: '/js/',
+        filename: '[name].js',
+        path: path.join(debugFolder, 'js'),
+        libraryTarget: 'global'
+    },
+    devServer: {
+        contentBase: debugFolder,
+        inline: true,
+        hot: true,
+        host: '0.0.0.0',
+        port: 9000
+    }
+});

package/webpack/webpack.prod.js

@@ -0,0 +1,15 @@
+const merge = require('webpack-merge');
+const path = require('path');
+
+const common = require('./webpack.common.js');
+const config = require('../config.json');
+
+module.exports = merge(common, {
+    mode: 'production',
+    entry: './src/index.js',
+    output: {
+        filename: config.distFileName,
+        path: path.join(__dirname, '../', config.distFolder),
+        libraryTarget: 'commonjs2'
+    }
+});