@wemap/positioning 2.1.0 → 2.3.0

package/src.old/providers/GnssPdrLocationSource.js

@@ -1,182 +0,0 @@
-/* eslint max-statements: ["error", 40]*/
-
-import { WGS84UserPosition } from '@wemap/geo';
-
-import LocationSource from './LocationSource';
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import Constants from '../Constants';
-import GnssLocationSource from './GnssLocationSource';
-import PdrLocationSource from './PdrLocationSource';
-import NavigationHandler from '../NavigationHandler';
-
-const GPF_ACCURACY = 25;
-const GPF_DISTANCE = 25;
-
-const MM_GNSS_DIST = 20;
-const MM_GNSS_ANGLE = 20;
-
-class GnssPdrLocationSource extends LocationSource {
-
-    constructor(callback, options) {
-        super(callback);
-
-        // Create a PdrLocationSource. Updates from Pdr will automatically set pose of GnssPdrLocationSource
-        this.pdrLocationSource = new PdrLocationSource(pose => {
-            this.pose = pose;
-            this.notify();
-        }, options);
-
-        // Create a GNSSLocationSource without IMU for attitude
-        this.gnssLocationSource = new GnssLocationSource(e => this.callbackGnss(e), false);
-
-        this.attitudeHandler = new AttitudeHandler();
-
-        this.gpsLastUpdate = 0;
-        this.isFirstGnssUpdate = true;
-        this.isFirstAttitudeUpdate = true;
-    }
-
-    /**
-     * Get provider name
-     * @override
-     */
-    static get providerName() {
-        return Constants.LOCATION_SOURCE_PROVIDERS.GNSS_PDR;
-    }
-
-    start() {
-        super.start();
-
-        return Promise.all([
-            this.pdrLocationSource.start(),
-            this.gnssLocationSource.start(),
-            this.attitudeHandler.startAbsolute(attitude => this.callbackAttitude(attitude))]);
-    }
-
-    stop() {
-        super.stop();
-
-        this.pdrLocationSource.stop();
-        this.gnssLocationSource.stop();
-        this.attitudeHandler.stopAbsolute();
-    }
-
-    setLogger(logger) {
-        super.setLogger(logger);
-        this.pdrLocationSource.setLogger(logger);
-        this.gnssLocationSource.setLogger(logger);
-        this.attitudeHandler.setLogger(logger);
-    }
-
-
-    callbackGnss(pose) {
-
-        // This should be called to update True North / Magnetic North declination
-        this.attitudeHandler.setUserLocationForAbsolute(pose.location);
-
-        if (pose.location.accuracy > GPF_ACCURACY) {
-            return;
-        }
-
-        this.gnssLocation = pose.location.clone();
-        this.gnssLocation.alt = NavigationHandler.DEFAULT_ALTITUDE;
-
-        if (!this.pose.location || this.pose.location
-            && this.pose.location.distanceTo(this.gnssLocation) > GPF_DISTANCE) {
-
-            if (!this.mapMatching || !this.pose.attitude) {
-                this.pdrLocationSource.setLocation(this.gnssLocation);
-            } else {
-
-                this.gnssLocation.bearing = this.pose.attitude.headingDegrees;
-                const projection = this.mapMatching.getProjection(this.gnssLocation);
-
-                if (projection && projection.projection) {
-
-                    // Create a new location from projection and new GNSS location.
-                    const projectedLocation = WGS84UserPosition.fromWGS84(projection.projection, this.gnssLocation);
-                    this.pdrLocationSource.setLocation(projectedLocation);
-
-                    // // If nearest element is an edge, use its orientation to set heading
-                    // if (projection.nearestElement instanceof Edge) {
-                    //     const edgeBearing = projection.nearestElement.bearing;
-                    //     const diff1 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing);
-                    //     const diff2 = MathUtils.diffAngle(MathUtils.deg2rad(this.gnssLocation.bearing), edgeBearing + Math.PI);
-                    //     this.pdrLocationSource.setHeading(diff1 < diff2 ? edgeBearing : edgeBearing + Math.PI);
-                    // }
-
-                    if (this.lastAttitude) {
-                        this.pdrLocationSource.setHeading(this.lastAttitude.heading);
-                    }
-
-                } else {
-                    this.pdrLocationSource.setLocation(this.gnssLocation);
-                }
-            }
-        }
-
-    }
-
-    callbackAttitude(attitude) {
-
-        if (this.isFirstAttitudeUpdate) {
-            this.pdrLocationSource.setHeading(attitude.heading);
-            this.isFirstAttitudeUpdate = false;
-        }
-
-        this.lastAttitude = attitude;
-    }
-
-
-    /**
-     * MapMatching
-     */
-
-    enableMapMatching(network, maxDistance = MM_GNSS_DIST, maxAngleBearing = MM_GNSS_ANGLE) {
-        this.pdrLocationSource.enableMapMatching(network, maxDistance, maxAngleBearing);
-        super.enableMapMatching(network, maxDistance, maxAngleBearing);
-    }
-
-
-    setNetwork(network) {
-        this.pdrLocationSource.setNetwork(network);
-        super.setNetwork(network);
-    }
-
-    /**
-     * Itinerary
-     */
-
-    setItinerary(itinerary) {
-
-        const isFirstItinerary = !this.itinerary;
-
-        super.setItinerary(itinerary);
-
-        if (isFirstItinerary && itinerary.length > 0) {
-
-            // When the first itinerary is received, first or second node (depending on MM_GNSS_DIST) is used as a starting point. No map-matching is needed here as router already provide the projection in the itinerary (node2 is node1 projection on OSRM network).
-
-            if (!this.gnssLocation
-                || itinerary.length < 2
-                || !itinerary.points[0].equalsTo(this.gnssLocation)) {
-                console.warn('Itinerary has not been calculated from GnssPdrLocationSource and these is not recommanded');
-            }
-
-            let startEdge;
-            if (itinerary.firstEdge.getLength() <= MM_GNSS_DIST) {
-                startEdge = itinerary.firstEdge;
-            } else {
-                startEdge = itinerary.secondEdge;
-            }
-            const startPoint = WGS84UserPosition.fromWGS84(startEdge.node1);
-            startPoint.alt = NavigationHandler.DEFAULT_ALTITUDE;
-            this.pdrLocationSource.setLocation(startPoint);
-            this.pdrLocationSource.setStepDetectionLockerOrientation(startEdge.getBearing());
-        }
-
-    }
-
-}
-
-export default GnssPdrLocationSource;

package/src.old/providers/IPLocationSource.js

@@ -1,96 +0,0 @@
-import { WGS84UserPosition } from '@wemap/geo';
-
-import LocationSource from './LocationSource';
-import AttitudeHandler from '../attitude/AttitudeHandler';
-import Constants from '../Constants';
-import SensorsLogger from '../sensors/SensorsLogger';
-
-
-class IPLocationSource extends LocationSource {
-
-    constructor(callback, imuEnabled = true) {
-        super(callback);
-
-        if (imuEnabled) {
-            this.attitudeHandler = new AttitudeHandler();
-        }
-    }
-
-    /**
-     * Start the location source algorithm
-     * @override
-     */
-    start() {
-        super.start();
-
-        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.geolocate()
-                .then(location => {
-                    this.pose.location = location;
-                    if (this.attitudeHandler) {
-                        this.attitudeHandler.setUserLocationForAbsolute(location);
-                    }
-                    resolve();
-                    this.notify();
-                })
-                .catch(reject);
-        });
-    }
-
-    /**
-     * Stop the location source algorithm
-     * @override
-     */
-    stop() {
-        super.stop();
-
-        if (this.attitudeHandler) {
-            this.attitudeHandler.stopAbsolute();
-            this.attitudeHandler = null;
-        }
-    }
-
-    geolocate() {
-        return new Promise((resolve, reject) => {
-            fetch('https://ipinfo.io/geo?token=24a7ca2f3b489d')
-                .then((response) => {
-                    if (!response) {
-                        reject();
-                    }
-
-                    const position = new WGS84UserPosition(
-                        parseFloat(response.loc.split(',')[0]),
-                        parseFloat(response.loc.split(',')[1]),
-                        null,
-                        performance.now() / 1e3
-                    );
-
-                    resolve(position);
-
-                    if (this.logger) {
-                        this.logger.feedWithCurrentTime(SensorsLogger.DataType.IP_POSITION, [position.lat, position.lng]);
-                    }
-                });
-        });
-    }
-
-    /**
-     * Get provider name
-     * @override
-     */
-    static get providerName() {
-        return Constants.LOCATION_SOURCE_PROVIDERS.IP;
-    }
-}
-
-export default IPLocationSource;

package/src.old/providers/LocationSource.js

@@ -1,290 +0,0 @@
-import {
-    MapMatching, Network, Itinerary, Edge, WGS84
-} from '@wemap/geo';
-
-import Pose from '../Pose';
-import Constants from '../Constants';
-import SensorsLogger from '../sensors/SensorsLogger';
-import ProvidersLogger from './ProvidersLogger';
-
-/**
- * A LocationSource is an independant component which can be instantiate to provide a pose (localisation and orientation)
- * @see PdrLocationSource
- * @see GnssPdrLocationSource
- * @see GnssLocationSource
- * @see IPLocationSource
- */
-class LocationSource {
-
-    /**
-     * Constructor of a LocationSource
-     * This constructor must be called by any implementation of a LocationSource
-     * @param {Function} callback function called when a new location or new orientation is calculated
-     * @protected
-     */
-    constructor(callback) {
-        if (new.target === LocationSource) {
-            throw new TypeError('Cannot instantiate LocationSource directly');
-        }
-        ProvidersLogger.addEvent(this, 'constructor');
-        this.callback = callback;
-        this.pose = new Pose();
-    }
-
-    /**
-     * Start the LocationSource
-     * @public
-     */
-    start() {
-        ProvidersLogger.addEvent(this, 'start');
-    }
-
-    /**
-     * Stop the LocationSource
-     * @public
-     */
-    stop() {
-        ProvidersLogger.addEvent(this, 'stop');
-    }
-
-    /**
-     * Same than providerName but with options
-     * @public
-     */
-    get providerNameWithOptions() {
-        return this.providerName;
-    }
-
-    /**
-     * Set a logger to record raw data
-     * @param {SensorsLogger} logger the sensors logger
-     */
-    setLogger(logger) {
-
-        if (logger && !(logger instanceof SensorsLogger)) {
-            throw new Error('logger is not an instance of SensorsLogger');
-        }
-
-        this.logger = logger;
-    }
-
-    /**
-     * @see providerName
-     * @public
-     */
-    static get providerName() {
-        return null;
-    }
-
-    /**
-     * Explicit name of Location Source
-     * This name is used in "provider" of pose.location
-     * @returns provider name
-     * @public
-     */
-    get providerName() {
-        return this.constructor.providerName;
-    }
-
-    /**
-     * Get current pose
-     * @returns current pose
-     * @public
-     */
-    getPose() {
-        return this.pose;
-    }
-
-    /**
-     * This method must be called to notify callback when pose changed
-     * @protected
-     */
-    notify() {
-        ProvidersLogger.addPushEvent(this);
-
-        if (!this.callback) {
-            return;
-        }
-
-        if (!this.pose.location) {
-            return;
-        }
-
-        this.pose.location.provider = this.providerName;
-        this.callback(this.pose);
-    }
-
-    /**
-     * Get most accurate LocationSource from two LocationSource
-     * @param {LocationSource} ls1 LocationSource 1
-     * @param {LocationSource} ls2 LocationSource 2
-     * @returns The most accuracte LocationSource
-     * @public
-     */
-    static getMostAccurateLocationSource(ls1, ls2) {
-
-        if (!(ls1 instanceof LocationSource)) {
-            throw new TypeError(ls1 + ' is not an instance of LocationSource');
-        }
-
-        if (!(ls2 instanceof LocationSource)) {
-            throw new TypeError(ls2 + ' is not an instance of LocationSource');
-        }
-
-        const accuracyOrder = [];
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.IP] = 0;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.GNSS] = 1;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.GNSS_PDR] = 2;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.PDR] = 3;
-        accuracyOrder[Constants.LOCATION_SOURCE_PROVIDERS.FIXED_LOCATION] = 4;
-
-        return accuracyOrder[ls1.providerName] > accuracyOrder[ls2.providerName] ? ls1 : ls2;
-    }
-
-
-    /**
-     * MapMatching
-     */
-
-    /**
-     * Enable LocationSource mapmatching
-     * @param {*} network a network which will be used for map matching
-     * @param {*} maxDistance max distance between location and network to match. null disables maxDistance (default: null)
-     * @param {*} maxAngleBearing threshold to match a parallel segment for angle between location bearing and segment. null disables this threshold (default: null)
-     * @public
-     */
-    enableMapMatching(network = null, maxDistance = null, maxAngleBearing = null) {
-        this.mapMatching = new MapMatching();
-        this.mapMatching.maxDistance = maxDistance;
-        this.mapMatching.maxAngleBearing = maxAngleBearing;
-
-        if (network) {
-            this.setNetwork(network);
-        }
-    }
-
-    /**
-     * Update the LocationSource network for mapmatching
-     * @param {Network} network a network instance
-     * @public
-     */
-    setNetwork(network) {
-        if (!(network instanceof Network)) {
-            throw new TypeError(network + ' is not an instance of Network');
-        }
-        if (!this.mapMatching) {
-            throw new Error('MapMatching is not enabled');
-        }
-        this.mapMatching.setNetwork(network);
-    }
-
-    /**
-     * Is mapmatching activated?
-     * @returns is mapmatching activated
-     * @public
-     */
-    get hasMapMatching() {
-        return this.mapMatching !== null;
-    }
-
-    /**
-     * Returns projection of a location on network
-     * @param {WGS84} location if location is null, projection of this.pose.location is used
-     * @returns The projected location {WGS84} or null.
-     * @public
-     */
-    getProjectionOnNetwork(location = null) {
-
-        if (!this.mapMatching) {
-            return null;
-        }
-
-        let locationToProject = location;
-        if (!location) {
-            locationToProject = this.pose.location;
-        }
-        if (!locationToProject) {
-            return null;
-        }
-
-        return this.mapMatching.getProjection(locationToProject, false, false);
-    }
-
-
-    /**
-     * Itinerary
-     */
-
-    /**
-     * Update itinerary of Location Source.
-     * Itinerary is different from network, it is not used for mapmatching. It can be used for others tricks like HeadingUnlocker
-     * @param {Itinerary} itinerary a given itinerary
-     * @public
-     */
-    setItinerary(itinerary) {
-        if (!(itinerary instanceof Itinerary)) {
-            throw new TypeError(itinerary + ' is not an instance of Itinerary');
-        }
-        this.itinerary = itinerary;
-    }
-
-
-    /**
-     * Returns projection and itinerary info of a location on network
-     * @param {WGS84} location if location is null, projection of this.pose.location is used
-     * @returns An object of the projected location and itinerary info or null.
-     * @public
-     */
-    getItineraryInfo(location = null) {
-
-        if (!this.itinerary) {
-            throw new Error('No itinerary found');
-        }
-        const projection = this.getProjectionOnNetwork(location);
-        if (!projection) {
-            return null;
-        }
-
-        const totalDistance = this.itinerary.distance;
-        let traveledDistance = 0;
-        const edges = this.itinerary.edges;
-
-        if (projection.nearestElement instanceof WGS84) {
-
-            for (let i = 0; i < edges.length; i++) {
-                const edge = edges[i];
-                if (edge.node1.equalsTo(projection.nearestElement)) {
-                    break;
-                }
-                traveledDistance += edge.getLength();
-            }
-
-
-        } else if (projection.nearestElement instanceof Edge) {
-
-            for (let i = 0; i < edges.length; i++) {
-                const edge = edges[i];
-                if (edge.equalsTo(projection.nearestElement)) {
-                    traveledDistance += edge.node1.distanceTo(projection.projection);
-                    break;
-                }
-                traveledDistance += edge.getLength();
-            }
-
-        } else {
-            throw new Error('No projection found');
-        }
-
-        return {
-            projection: projection,
-            traveledDistance,
-            traveledPercentage: traveledDistance / totalDistance,
-            remainingDistance: totalDistance - traveledDistance,
-            remainingPercentage: 1 - traveledDistance / totalDistance
-        };
-    }
-
-
-}
-
-export default LocationSource;