@wemap/positioning 2.0.0 → 2.2.0

package/src.old/NavigationHandler.js

@@ -1,244 +0,0 @@
-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.old/Pose.js

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

package/src.old/attitude/AttitudeHandler.js

@@ -1,342 +0,0 @@
-import geomagnetism from 'geomagnetism';
-
-import { Attitude } from '@wemap/geo';
-import {
-    deg2rad, Quaternion
-} from '@wemap/maths';
-
-import EkfAttitude from './EkfAttitude';
-import SensorsCompatibility from '../sensors/SensorsCompatibility';
-
-
-const RelativeMethod = {
-    AUTOMATIC: 0,
-    BROWSER: 1,
-    INTERNAL_EKF: 2
-};
-
-const AbsoluteMethod = {
-    AUTOMATIC: 0,
-    BROWSER: 1,
-    INTERNAL_EKF: 2,
-    INTERNAL_CUSTOM: 3
-};
-
-
-class AttitudeHandler {
-
-    isRelativeStarted = false;
-
-    constructor() {
-        this.sensorsCompatibility = new SensorsCompatibility();
-        this.relativeOffsetQuaternion = [1, 0, 0, 0];
-        this.ekfAttitude = new EkfAttitude();
-    }
-
-    static get RelativeMethod() {
-        return RelativeMethod;
-    }
-
-    static get AbsoluteMethod() {
-        return AbsoluteMethod;
-    }
-
-    setLogger(logger) {
-        this.sensorsCompatibility.setLogger(logger);
-    }
-
-    startRelative(callback, method = RelativeMethod.INTERNAL_EKF) {
-
-        if (method === RelativeMethod.AUTOMATIC) {
-            throw new Error('Do not use automatic method for the moment');
-        }
-
-        let promise;
-
-        this.relativeMethodAnswer = false;
-
-        const fn = (quaternion, timestamp) => {
-            if (quaternion) {
-                callback(new Attitude(quaternion), timestamp);
-            }
-        };
-
-        this.relativeMethod = method;
-
-        if (method === RelativeMethod.AUTOMATIC) {
-
-            promise = new Promise((resolve, reject) => {
-                // Try internal EKF first
-                this.startRelative(callback, RelativeMethod.INTERNAL_EKF)
-                    .then(resolve)
-                    .catch(() => {
-                        this.stopRelative();
-                        // If EKF did not work, try Browser method
-                        this.startRelative(callback, RelativeMethod.BROWSER)
-                            .then(resolve)
-                            .catch(() => {
-                                this.stopRelative();
-                                reject();
-                            });
-                    });
-            });
-
-        } else if (method === RelativeMethod.BROWSER) {
-
-            promise = this.sensorsCompatibility.startRelativeOrientation((quaternion, timestamp) => {
-                quaternion = Quaternion.multiply(this.relativeOffsetQuaternion, quaternion);
-                fn(quaternion, timestamp);
-            });
-
-        } else if (method === RelativeMethod.INTERNAL_EKF) {
-
-            let lastTimestamp = 0;
-            promise = this.sensorsCompatibility.startImu(accGyrEvent => {
-                const timestamp = accGyrEvent.timestamp;
-                const acc = accGyrEvent.acc;
-                const gyr = accGyrEvent.gyr;
-
-                // Handle timestamps and dt
-                if (lastTimestamp === 0) {
-                    lastTimestamp = timestamp;
-                    return;
-                }
-                const diffTime = timestamp - lastTimestamp;
-                lastTimestamp = timestamp;
-                const quaternion = this.ekfAttitude.update(diffTime, acc, gyr);
-                fn(quaternion, timestamp);
-            }, {
-                accelerometer: true,
-                gyroscope: true
-            });
-        } else {
-            return Promise.reject();
-        }
-
-        this.isRelativeStarted = true;
-
-        return promise;
-    }
-
-
-    stopRelative() {
-        this.isRelativeStarted = false;
-
-        if (this.relativeMethod === RelativeMethod.BROWSER) {
-            this.sensorsCompatibility.stopRelativeOrientation();
-        } else if (this.relativeMethod === RelativeMethod.INTERNAL_EKF) {
-            this.sensorsCompatibility.stopImu();
-        }
-        this.relativeMethod = null;
-    }
-
-
-    /**
-     *
-     * Set yaw offset, this value will be used as the filter does not use magnetometer
-     * @param {Number} heading heading offset in radians and clockwise
-     */
-    setRelativeHeading(heading) {
-
-        // Minus before "heading" is here because ENU attitude is counter-clockwise whereas WGS84 heading is clockwise.
-        heading = -heading;
-
-        // Offset from window orientation
-        heading += deg2rad(window.orientation || 0);
-
-        // // We don't know the method used, so we set both
-        this.relativeOffsetQuaternion = Quaternion.fromAxisAngle([0, 0, 1], heading);
-
-        // We don't know the method used, so we set both
-        this.ekfAttitude.setOrientationYaw(heading);
-
-        if (this.relativeMethod === RelativeMethod.BROWSER && this.relativeMethodAnswer) {
-            this.stopRelative();
-            return this.startRelative(this.relativeCallback, RelativeMethod.BROWSER);
-        }
-
-        return Promise.resolve();
-    }
-
-
-    startAbsolute(callback, method = AbsoluteMethod.BROWSER) {
-
-        if (method === AbsoluteMethod.AUTOMATIC) {
-            throw new Error('Do not use automatic method for the moment');
-        }
-
-        let promise;
-
-        this.absoluteMethodAnswer = false;
-
-        const fn = (quaternion, timestamp, externalData) => {
-            if (!quaternion || !this.declinationQuaternion) {
-                return;
-            }
-            const trueQuaternion = Quaternion.multiply(this.declinationQuaternion, quaternion);
-            callback(new Attitude(trueQuaternion), timestamp, externalData);
-        };
-
-        this.absoluteMethod = method;
-
-        if (method === AbsoluteMethod.AUTOMATIC) {
-
-            promise = new Promise((resolve, reject) => {
-
-                // Try internal EKF first
-                this.startAbsolute(callback, AbsoluteMethod.INTERNAL_EKF).catch(() => {
-                    this.stopAbsolute();
-
-                    // If EKF did not work, try internal custom method
-                    this.startAbsolute(callback, AbsoluteMethod.INTERNAL_CUSTOM).catch(() => {
-                        this.stopAbsolute();
-
-                        // If internal custom did not work, try Browser method
-                        this.startAbsolute(callback, AbsoluteMethod.BROWSER).catch(() => {
-
-                            this.stopAbsolute();
-                            reject();
-
-                        }).then(resolve);
-
-                    }).then(resolve);
-
-                }).then(resolve);
-            });
-
-        } else if (method === AbsoluteMethod.INTERNAL_CUSTOM) {
-
-            let lastAttitude;
-            let isFirst = true;
-
-            promise = new Promise((resolve, reject) => {
-
-                const startRelativeFn = (heading) => {
-                    this.stopAbsolute();
-
-                    // Mandatory, otherwise this.absoluteMethod is null and cannot be stopped
-                    this.absoluteMethod = AbsoluteMethod.INTERNAL_CUSTOM;
-
-                    this.startRelative(callback)
-                        .then(resolve)
-                        .catch(() => {
-                            this.stopRelative();
-                            reject();
-                        });
-                    this.setRelativeHeading(heading);
-                };
-
-                const customCallback = (attitude, timestamp, externalData) => {
-                    lastAttitude = attitude;
-
-                    if (isFirst) {
-                        this.timeoutAbsoluteFirstMillis = setTimeout(() => {
-                            startRelativeFn(externalData && externalData.webkitCompassHeading
-                                ? deg2rad(externalData.webkitCompassHeading)
-                                : lastAttitude.heading);
-                        }, 300);
-
-                        isFirst = false;
-                    }
-
-                };
-
-                this.startAbsolute(customCallback, AbsoluteMethod.BROWSER)
-                    .catch(() => {
-                        this.stopAbsolute();
-                        reject();
-                    });
-            });
-
-        } else if (method === AbsoluteMethod.BROWSER) {
-            promise = this.sensorsCompatibility.startAbsoluteOrientation((quaternion, timestamp, externalData) => {
-                fn(quaternion, timestamp, externalData);
-            });
-
-        } else if (method === AbsoluteMethod.INTERNAL_EKF) {
-            let lastTimestamp = 0;
-            promise = this.sensorsCompatibility.startImu(accGyrMagEvent => {
-                const timestamp = accGyrMagEvent.timestamp;
-                const acc = accGyrMagEvent.acc;
-                const gyr = accGyrMagEvent.gyr;
-                const mag = accGyrMagEvent.mag;
-
-                // Handle timestamps and dt
-                if (lastTimestamp === 0) {
-                    lastTimestamp = timestamp;
-                    return;
-                }
-                const diffTime = timestamp - lastTimestamp;
-                lastTimestamp = timestamp;
-                const quaternion = this.ekfAttitude.update(diffTime, acc, gyr, mag);
-                fn(quaternion, timestamp);
-            });
-        } else {
-            promise = Promise.reject();
-        }
-
-        return promise;
-    }
-
-    stopAbsolute() {
-        if (this.absoluteMethod === AbsoluteMethod.BROWSER) {
-            this.sensorsCompatibility.stopAbsoluteOrientation();
-        } else if (this.absoluteMethod === AbsoluteMethod.INTERNAL_EKF) {
-            this.sensorsCompatibility.stopImu();
-        } else if (this.absoluteMethod === AbsoluteMethod.INTERNAL_CUSTOM) {
-            this.stopRelative();
-        }
-        if (this.timeoutAbsoluteFirstMillis) {
-            clearTimeout(this.timeoutAbsoluteFirstMillis);
-            this.timeoutAbsoluteFirstMillis = null;
-        }
-        this.absoluteMethod = null;
-    }
-
-    // This method should be theoretically called every time the user moves.
-    // But in reality declination does not change as much.
-    setUserLocationForAbsolute(userLocation) {
-        const wmmResult = geomagnetism.model().point([userLocation.lat, userLocation.lng]);
-        // Declination is given in NED frame and our code use ENU, that is why we have: "-decl"
-        this.declinationQuaternion = Quaternion.fromAxisAngle([0, 0, 1], - deg2rad(wmmResult.decl));
-    }
-
-    startMonitoringInclination(callback) {
-
-        this.sensorsCompatibilityInclination = new SensorsCompatibility();
-
-        return this.sensorsCompatibility.startImu(({ acc }) => {
-
-            const screenOrientation = window.orientation || 0;
-
-            const sizeAcc = Math.sqrt(acc[0] * acc[0] + acc[1] * acc[1] + acc[2] * acc[2]);
-            const accNormalized = [acc[0] / sizeAcc, acc[1] / sizeAcc, acc[2] / sizeAcc];
-
-            const q = [accNormalized[2] + 1, accNormalized[1], -accNormalized[0], 0];
-            const qSize = Math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2]);
-            const qNormalized = [q[0] / qSize, q[1] / qSize, q[2] / qSize, 0];
-
-            let inclination;
-            if (screenOrientation === 0) {
-                inclination = Math.asin(2 * qNormalized[1] * qNormalized[0]);
-            } else if (screenOrientation === 90) {
-                inclination = -Math.asin(2 * qNormalized[2] * qNormalized[0]);
-            } else if (screenOrientation === -90) {
-                inclination = Math.asin(2 * qNormalized[2] * qNormalized[0]);
-            } else if (screenOrientation === 180) {
-                inclination = -Math.asin(2 * qNormalized[1] * qNormalized[0]);
-            }
-
-            callback(inclination);
-
-        }, { accelerometer: true });
-    }
-
-    stopMonitoringInclination() {
-        if (this.sensorsCompatibilityInclination) {
-            this.sensorsCompatibilityInclination.stopImu();
-        }
-    }
-}
-
-export default AttitudeHandler;