@wemap/positioning 1.2.0

package/scripts/release-github.js

@@ -0,0 +1,216 @@
+const dotenv = require('dotenv');
+const fs = require('fs');
+const git = require('simple-git/promise')('.').silent(true);
+const path = require('path');
+const npm = require('npm');
+const requestp = require('request-promise');
+
+const config = require('../config.json');
+
+/**
+ * Check GITHUB_TOKEN in .env file
+ */
+const result = dotenv.config();
+if (result.error) {
+    console.error('.env does not exist. '
+        + 'You have to create a .env file at the root directory');
+    return;
+}
+const ENV = result.parsed;
+if (!ENV.GITHUB_TOKEN) {
+    console.error('GITHUB_TOKEN does not exist in .env file. '
+        + 'More info here: https://github.com/settings/tokens');
+    return;
+}
+
+/**
+ * Github Url and Headers
+ */
+
+const GITHUB_API_URL = 'https://api.github.com';
+const GITHUB_UPLOAD_URL = 'https://uploads.github.com';
+
+const HEADERS = {
+    'Authorization': 'token ' + ENV.GITHUB_TOKEN,
+    'User-Agent': 'NodeJS/Release-' + config.githubRepoName
+};
+
+function checkGithubToken() {
+
+    const uri = GITHUB_API_URL;
+    const headers = HEADERS;
+
+    return requestp({
+        method: 'GET',
+        uri,
+        headers,
+        json: true
+    }).catch(e => {
+        return Promise.reject(e.message);
+    });
+}
+
+function createRelease(version) {
+
+    const uri = GITHUB_API_URL + '/repos/' + config.githubRepoOwner + '/'
+        + config.githubRepoName + '/releases';
+    const headers = Object.assign({ 'Content-Type': 'application/json' }, HEADERS);
+    const inputData = {
+        'tag_name': version,
+        'target_commitish': 'master',
+        'name': version
+    };
+
+    return requestp({
+        method: 'POST',
+        uri,
+        headers,
+        body: inputData,
+        json: true
+    }).catch(e => {
+        return Promise.reject(e.message);
+    });
+}
+
+
+function uploadFile(releaseId, fileName, filePath) {
+
+    const stats = fs.statSync(filePath);
+    const fileSizeInBytes = stats.size;
+
+    const uri = GITHUB_UPLOAD_URL + '/repos/' + config.githubRepoOwner + '/'
+        + config.githubRepoName + '/releases/' + releaseId
+        + '/assets?name=' + fileName;
+
+    const headers = Object.assign({
+        'Content-Type': 'application/javascript',
+        'Content-length': fileSizeInBytes
+    }, HEADERS);
+
+    return requestp({
+        method: 'POST',
+        uri,
+        headers,
+        body: fs.createReadStream(filePath)
+    }).catch(e => {
+        return e.message;
+    });
+}
+
+function revertNpmVersion() {
+    return git.reset(['--hard', 'HEAD^1'])
+        .then(() => git.tag(['-d', 'v1.1.0']))
+        .catch(err => console.error(err));
+}
+
+const npmLoaderPromise = new Promise((resolve, reject) => {
+    npm.load(err => {
+        if (err) {
+            reject(err);
+        } else {
+            resolve();
+        }
+    });
+});
+
+
+function main() {
+
+    const versionsList = ['minor', 'major', 'patch'];
+
+    let isVersionCreated = false;
+    const isPushed = false;
+
+    Promise.resolve()
+        // Check github token as soon as possible to avoid to revert a push
+        .then(checkGithubToken)
+
+        // Check if current branch name corresponds to "releaseBranch"
+        .then(async () => {
+            const res = await git.raw(['rev-parse', '--abbrev-ref', 'HEAD']);
+            if (res.trim() !== config.releaseBranch) {
+                return Promise.reject('You are not on the ' + config.releaseBranch + ' branch');
+            }
+            return Promise.resolve();
+        })
+
+        // Check if git repo is clean before running npm version
+        .then(async () => {
+            const res = await git.raw(['status', '--porcelain']);
+            if (res) {
+                return Promise.reject('Your git working directory not clean');
+            }
+            return Promise.resolve();
+        })
+
+        // Update npm version with npm version argv[2]
+        .then(async () => {
+            const args = process.argv;
+            if (args.length < 3) {
+                throw new Error('version argument is missing');
+            }
+            if (!versionsList.includes(args[2])) {
+                throw new Error('version argument is unknown, it should be: ' + versionsList.join(','));
+            }
+
+            await npmLoaderPromise;
+            return new Promise((resolve, reject) => {
+                npm.commands.version([args[2]], err => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        isVersionCreated = true;
+                        resolve();
+                    }
+                });
+            });
+        })
+
+        // Build the project in production mode
+        .then(async () => {
+            await npmLoaderPromise;
+            return new Promise((resolve, reject) => {
+                npm.commands.run(['build'], err => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve();
+                    }
+                });
+            });
+        })
+
+        // Push release to origin
+        .then(() => git.push('origin', config.releaseBranch, ['--tags']))
+
+        // Get tag name
+        .then(async () => {
+            const res = await git.raw(['describe']);
+            // TODO this condition can be improved
+            if (!res || res[0] !== 'v') {
+                return Promise.reject('Could not find tag name');
+            }
+            return Promise.resolve(res.trim());
+        })
+
+        // Create the release
+        .then((tagName) => createRelease(tagName))
+
+        // Upload file
+        .then(response => {
+            const filePath = path.join(config.distFolder, config.distFileName);
+            uploadFile(response.id, config.distFileName, filePath);
+        })
+
+        .then(() => {
+            console.log('Release finished with success');
+        })
+        .catch(e => {
+            if (isVersionCreated && !isPushed) {
+                revertNpmVersion();
+            }
+            console.error('error', e);
+        });
+}
+
+main();

package/src/Constants.js

@@ -0,0 +1,11 @@
+const Constants = {
+    LOCATION_SOURCE_PROVIDERS: {
+        IP: 'IP',
+        GNSS: 'GNSS/WIFI',
+        PDR: 'PDR',
+        GNSS_PDR: 'GNSS/WIFI-PDR',
+        FIXED_LOCATION: 'FIXED_LOCATION'
+    }
+};
+
+export default Constants;

package/src/NavigationHandler.js

@@ -0,0 +1,244 @@
+import noop from 'lodash.noop';
+
+import { WGS84UserPosition, Itinerary } from '@wemap/geo';
+
+import LocationSource from './providers/LocationSource';
+import IPLocationSource from './providers/IPLocationSource';
+import GnssLocationSource from './providers/GnssLocationSource';
+import PdrLocationSource from './providers/PdrLocationSource';
+import GnssPdrLocationSource from './providers/GnssPdrLocationSource';
+import FixedLocationImuLocationSource from './providers/FixedLocationImuLocationSource';
+import SensorsLogger from './sensors/SensorsLogger';
+
+const DEFAULT_ALTITUDE = 1.6;
+
+/**
+ * @private
+ */
+class NavigationHandler {
+
+    /**
+     * Constructor of NavigationHandler
+     * @param {Function} callbackOnStart callback when navigation starts
+     * @param {Function} callbackOnStop callback when navigation stops
+     * @param {Function} callbackOnNewPose callback on new pose
+     * @public
+     */
+    constructor(callbackOnStart, callbackOnStop, callbackOnNewPose) {
+        this.callback = this.callback.bind(this);
+
+        this.callbackOnStart = callbackOnStart || noop;
+        this.callbackOnStop = callbackOnStop || noop;
+        this.callbackOnNewPose = callbackOnNewPose || noop;
+    }
+
+
+    /**
+     * Starts navigation from an initial position an initial heading
+     * @param {*} initialPosition initial position {lat: xx, lng: xx}
+     * @param {Number} initialHeading initial heading in radians and clockwise: north: 0, east = PI/2
+     * @param {Array} path an optional itinerary (list of 2D points [lng, lat])
+     * @public
+     */
+    startRelative(initialPosition, initialHeading, path = null) {
+
+        const initialPositionWgs84 = new WGS84UserPosition(
+            initialPosition.lat,
+            initialPosition.lng,
+            initialPosition.alt || DEFAULT_ALTITUDE
+        );
+
+        // stop current location source if already started
+        if (this.locationSource) {
+            this.locationSource.stop();
+        }
+
+        this.locationSource = new PdrLocationSource(this.callback, {
+            'stepdetectionlocker': true,
+            'smoother': true
+        });
+        this.locationSource.setLogger(this.logger);
+
+        if (path) {
+            const itinerary = Itinerary.fromPoints(path);
+            this.locationSource.enableMapMatching(itinerary);
+            this.locationSource.setItinerary(itinerary);
+        }
+        this.locationSource.setLocation(initialPositionWgs84);
+        this.locationSource.setHeading(initialHeading);
+        const promise = this.locationSource.start();
+
+        this.callbackOnStart();
+        return promise;
+    }
+
+    /**
+     * Starts navigation handler without any knowledge on starting point
+     * @param {Array} path an optional itinerary (list of 2D points [lng, lat])
+     * @public
+     */
+    startAbsolute(path) {
+        // stop if already started
+        if (this.locationSource) {
+            this.locationSource.stop();
+        }
+
+        const itinerary = Itinerary.fromPoints(path);
+        this.locationSource = new GnssPdrLocationSource(this.callback);
+        this.locationSource.enableMapMatching(itinerary);
+        this.locationSource.setItinerary(itinerary);
+        this.locationSource.setLogger(this.logger);
+
+        const promise = this.locationSource.start();
+        this.callbackOnStart();
+        return promise;
+    }
+
+    locateme(
+        options = {
+            ip: true,
+            browser: true,
+            attitude: true
+        }
+    ) {
+        const useIPProvider = !options.hasOwnProperty('ip') || options.ip === true;
+        const useBrowserProvider = !options.hasOwnProperty('browser') || options.browser === true;
+        const useImu = !options.hasOwnProperty('attitude') || options.attitude === true;
+
+        return new Promise((resolve, reject) => {
+            const gnss = new GnssLocationSource(pose => {
+                resolve(pose);
+                this.callback(pose);
+            }, useImu);
+
+            const ip = new IPLocationSource(pose => {
+                resolve(pose);
+                this.callback(pose);
+            }, useImu);
+
+            if (
+                this.locationSource
+                && LocationSource.getMostAccurateLocationSource(this.locationSource, gnss) === this.locationSource
+            ) {
+                resolve(this.locationSource.getPose());
+            } else {
+                if (this.locationSource) {
+                    this.locationSource.stop();
+                }
+
+                if (useBrowserProvider) {
+                    this.locationSource = gnss;
+                    gnss.start().catch(e => {
+                        if (useIPProvider) {
+                            this.locationSource = ip;
+                            ip.start();
+                            return;
+                        }
+                        reject(e);
+                    });
+                } else if (useIPProvider) {
+                    this.locationSource = ip;
+                    ip.start();
+                }
+            }
+        });
+    }
+
+
+    /**
+     * Stop relative, absolute or locateme navigation if started
+     * @public
+     */
+    stop() {
+        if (
+            this.locationSource
+        ) {
+            this.locationSource.stop();
+            this.locationSource = null;
+        }
+        this.callbackOnStop();
+    }
+
+
+    /**
+     * @see LocationSource#getProjectionOnNetwork()
+     * @public
+     */
+    getProjectionOnNetwork(location) {
+        return this.locationSource.getProjectionOnNetwork(location);
+    }
+
+    /**
+     * @see LocationSource#getItineraryInfo()
+     * @public
+     */
+    getItineraryInfo(location) {
+        return this.locationSource.getItineraryInfo(location);
+    }
+
+    forceUserLocation(location) {
+        if (
+            this.locationSource
+            && (!(this.locationSource instanceof FixedLocationImuLocationSource) || !location)
+        ) {
+            this.locationSource.stop();
+        }
+
+        if (location) {
+            if (
+                !this.locationSource
+                || !(this.locationSource instanceof FixedLocationImuLocationSource)
+            ) {
+                this.locationSource = new FixedLocationImuLocationSource(this.callback);
+                this.locationSource.start(location);
+            } else {
+                this.locationSource.setLocation(location);
+            }
+        } else {
+            this.locationSource = null;
+        }
+    }
+
+    /**
+     * @private
+     */
+    callback(pose) {
+        this.callbackOnNewPose(pose);
+    }
+
+    /**
+     * Assign a SensorsLogger to LocationSource and start recording.
+     * This logger will be fed with sensors output.
+     * Logger is not working on locateme()
+     * @param {SensorsLogger} logger An instance of SensorsLogger.
+     * @public
+     */
+    startLogger(logger) {
+        if (!(logger instanceof SensorsLogger)) {
+            throw new Error('logger is not an instance of SensorsLogger');
+        }
+
+        this.logger = logger;
+
+        if (this.locationSource) {
+            this.locationSource.setLogger(this.logger);
+        }
+    }
+
+    /**
+    * Stop recording sensors
+     * @public
+    */
+    stopLogger() {
+        this.logger = null;
+        if (this.locationSource) {
+            this.locationSource.setLogger(this.logger);
+        }
+    }
+
+    static get DEFAULT_ALTITUDE() {
+        return DEFAULT_ALTITUDE;
+    }
+}
+
+export default NavigationHandler;

package/src/Pose.js

@@ -0,0 +1,8 @@
+class Pose {
+
+    attitude = null;
+    location = null;
+
+}
+
+export default Pose;

package/src/attitude/Attitude.js

@@ -0,0 +1,65 @@
+import {
+    Rotations, Utils as MathUtils, Quaternion
+} from '@wemap/maths';
+
+const rotxM90 = Quaternion.fromAxisAngle([1, 0, 0], -Math.PI / 2);
+
+class Attitude {
+
+    quaternion = [1, 0, 0, 0];
+    quaternionThreeJsV = null;
+    headingV = null;
+    headingDegreesV = null;
+    eulerAnglesV = null;
+    eulerAnglesDegreesV = null;
+
+    constructor(quaternion) {
+        this.quaternion = quaternion;
+    }
+
+    get eulerAngles() {
+        if (!this.eulerAnglesV) {
+            this.eulerAnglesV = Rotations.quaternionToEulerZXY(this.quaternion);
+        }
+        return this.eulerAnglesV;
+    }
+
+    get eulerAnglesDegrees() {
+        if (!this.eulerAnglesDegreesV) {
+            this.eulerAnglesDegreesV = Rotations.quaternionToEulerZXYDegrees(this.quaternion);
+        }
+        return this.eulerAnglesDegreesV;
+    }
+
+    get heading() {
+        if (!this.headingV) {
+            this.headingV = Rotations.getHeadingFromQuaternion(this.quaternion) + MathUtils.deg2rad(window.orientation || 0);
+        }
+        return this.headingV;
+    }
+
+    get headingDegrees() {
+        if (!this.headingDegreesV) {
+            this.headingDegreesV = MathUtils.rad2deg(Rotations.getHeadingFromQuaternion(this.quaternion)) + (window.orientation || 0);
+        }
+        return this.headingDegreesV;
+    }
+
+    get quaternionThreeJs() {
+        if (!this.quaternionThreeJsV) {
+            this.quaternionThreeJsV = Quaternion.wxyz2xyzw(Quaternion.multiply(rotxM90, this.quaternion));
+        }
+        return this.quaternionThreeJsV;
+    }
+
+    toMessage() {
+        return this.quaternion;
+    }
+
+    static fromMessage(message) {
+        return new Attitude(message);
+    }
+
+}
+
+export default Attitude;