@wemap/positioning 2.1.0 → 2.3.0

package/src/providers/pose/PoseProvider.js

@@ -19,7 +19,7 @@ class PoseProvider extends Provider {
 
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(onEvent, e => this.onAbsoluteAttitudeError(e));
         this.gnssWifiProvider = new GnssWifiProvider((events) => {
-            this.absoluteAttitudeProvider.setLocation(events[0].data);
+            this.absoluteAttitudeProvider.setPosition(events[0].data);
             onEvent(events);
         }, e => this.onGnssWifiError(e));
     }

package/src/providers/pose/pdr/PdrProvider.js

@@ -32,10 +32,10 @@ const DEFAULT_OPTIONS = {
 
 class PdrProvider extends MapMatchingProvider {
 
-    // pdrLocation can be different from this.location
-    // pdrLocation is raw location calculated by PdrProvider where
-    //     this.location is smoothed location.
-    pdrLocation = null;
+    // pdrPosition can be different from this.position
+    // pdrPosition is raw position calculated by PdrProvider where
+    //     this.position is smoothed position.
+    pdrPosition = null;
 
     /**
     * @override
@@ -61,7 +61,7 @@ class PdrProvider extends MapMatchingProvider {
         this.smoother = new Smoother();
         this.thugDetector = new ThugDetector();
 
-        if (options.useMapMatching) {
+        if (this.options.useMapMatching) {
             this.enableMapMatching();
         }
     }
@@ -127,18 +127,18 @@ class PdrProvider extends MapMatchingProvider {
         this.relativeAttitudeProvider.setOffset(heading);
     }
 
-    setLocation(location) {
-        this.pdrLocation = location;
+    setPosition(position) {
+        this.pdrPosition = position;
 
         if (this.options.smoother) {
-            this.smoother.generateNextLocations(location, true);
-            // this.smoother.pullLocation(location.time) should never return null
-            this.location = this.smoother.pullLocation(location.time);
+            this.smoother.generateNextPositions(position, true);
+            // this.smoother.pullPosition(position.time) should never return null
+            this.position = this.smoother.pullPosition(position.time);
         } else {
-            this.location = location.clone();
+            this.position = position.clone();
         }
 
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.location));
+        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
     }
 
     /**
@@ -163,8 +163,8 @@ class PdrProvider extends MapMatchingProvider {
             return;
         }
 
-        if (!this.pdrLocation) {
-            // We should wait at least an input location for PDR
+        if (!this.pdrPosition) {
+            // We should wait at least an input position for PDR
             return;
         }
 
@@ -201,36 +201,36 @@ class PdrProvider extends MapMatchingProvider {
 
         if (stepDetected) {
 
-            this.pdrLocation = this.calculateNewLocation(this.pdrLocation, timestamp,
+            this.pdrPosition = this.calculateNewPosition(this.pdrPosition, timestamp,
                 heading, this.stepDetection.lastStepSize);
 
             /**
             * Update current_position
             */
             if (this.options.smoother) {
-                this.smoother.generateNextLocations(this.pdrLocation);
-                const newLocation = this.smoother.pullLocation(timestamp);
-                // At this time, newLocation can be null if a new step has been detected
+                this.smoother.generateNextPositions(this.pdrPosition);
+                const newPosition = this.smoother.pullPosition(timestamp);
+                // At this time, newPosition can be null if a new step has been detected
                 //  and smoother has not been completely consumed.
-                if (newLocation) {
-                    this.location = newLocation;
+                if (newPosition) {
+                    this.position = newPosition;
                 }
             } else {
-                this.location = this.pdrLocation;
+                this.position = this.pdrPosition;
             }
 
         } else if (this.options.smoother) {
-            // If no step is detected, we pull last known location from smoother until now (timestamp).
-            const smoothedLocation = this.smoother.pullLocation(timestamp);
-            if (!smoothedLocation) {
+            // If no step is detected, we pull last known position from smoother until now (timestamp).
+            const smoothedPosition = this.smoother.pullPosition(timestamp);
+            if (!smoothedPosition) {
                 return;
             }
-            this.location = smoothedLocation;
+            this.position = smoothedPosition;
         } else {
             return;
         }
 
-        this.notify(this.createEvent(EventType.AbsolutePosition, this.location));
+        this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
     }
 
     onProviderError(errors) {
@@ -254,39 +254,39 @@ class PdrProvider extends MapMatchingProvider {
         );
     }
 
-    calculateNewLocation(previousLocation, timestamp, heading, stepSize) {
+    calculateNewPosition(previousPosition, timestamp, heading, stepSize) {
 
         /**
          * Compute new_position
          */
-        const newLocationWithoutMM = previousLocation.clone();
-        newLocationWithoutMM.move(stepSize, heading);
-        newLocationWithoutMM.bearing = rad2deg(heading);
-        newLocationWithoutMM.time = timestamp;
+        const newPositionWithoutMM = previousPosition.clone();
+        newPositionWithoutMM.move(stepSize, heading);
+        newPositionWithoutMM.bearing = rad2deg(heading);
+        newPositionWithoutMM.time = timestamp;
 
         if (!this.mapMatching) {
-            return newLocationWithoutMM;
+            return newPositionWithoutMM;
         }
 
-        const projection = this.mapMatching.getProjection(newLocationWithoutMM);
+        const projection = this.mapMatching.getProjection(newPositionWithoutMM);
 
         if (!projection || !projection.projection) {
-            return newLocationWithoutMM;
+            return newPositionWithoutMM;
         }
 
         if (projection.distanceFromNearestElement < stepSize) {
-            return WGS84UserPosition.fromWGS84(projection.projection, newLocationWithoutMM);
+            return WGS84UserPosition.fromWGS84(projection.projection, newPositionWithoutMM);
         }
 
         /**
          * Update new_position
          */
         const smoothedDistance = projection.distanceFromNearestElement * MM_CONV_SPEED;
-        const smoothedBearing = previousLocation.bearingTo(projection.projection);
-        const smoothedLocation = previousLocation.clone();
-        smoothedLocation.move(smoothedDistance, smoothedBearing);
+        const smoothedBearing = previousPosition.bearingTo(projection.projection);
+        const smoothedPosition = previousPosition.clone();
+        smoothedPosition.move(smoothedDistance, smoothedBearing);
 
-        return WGS84UserPosition.fromWGS84(smoothedLocation, newLocationWithoutMM);
+        return WGS84UserPosition.fromWGS84(smoothedPosition, newPositionWithoutMM);
     }
 
 

package/src/providers/pose/pdr/helpers/Smoother.js

@@ -1,7 +1,7 @@
 /* eslint max-statements: ["error", 27]*/
 import { WGS84UserPosition } from '@wemap/geo';
 
-// Generated locations by second
+// Generated positions by second
 const GEN_FREQUENCY = 60;
 
 // Min and max time for flyby (in second)
@@ -11,40 +11,40 @@ const MAX_FLYBY_TIME = 1;
 class Smoother {
 
     constructor() {
-        this.locationsQueue = [];
+        this.positionsQueue = [];
     }
 
     /**
-     * Calculate smoothed positions for the next milliseconds given a new location
+     * Calculate smoothed positions for the next milliseconds given a new position
      */
-    generateNextLocations(_newLocation, flyby = false) {
+    generateNextPositions(_newPosition, flyby = false) {
 
-        if (!(_newLocation instanceof WGS84UserPosition)) {
-            throw new TypeError('newLocation is not instance of WGS84UserPosition');
+        if (!(_newPosition instanceof WGS84UserPosition)) {
+            throw new TypeError('newPosition is not instance of WGS84UserPosition');
         }
 
-        const newLocation = _newLocation.clone();
-        if (!newLocation.hasOwnProperty('time')) {
-            throw new Error('newLocation does not have time property');
+        const newPosition = _newPosition.clone();
+        if (!newPosition.hasOwnProperty('time')) {
+            throw new Error('newPosition does not have time property');
         }
 
-        if (!this.previousLocation) {
-            this.previousLocation = newLocation;
-            this.locationsQueue.push(this.previousLocation);
+        if (!this.previousPosition) {
+            this.previousPosition = newPosition;
+            this.positionsQueue.push(this.previousPosition);
             return;
         }
 
-        const distance = this.previousLocation.distanceTo(newLocation);
-        const azimuth = this.previousLocation.bearingTo(newLocation);
+        const distance = this.previousPosition.distanceTo(newPosition);
+        const azimuth = this.previousPosition.bearingTo(newPosition);
 
-        let refTimestamp = newLocation.time;
+        let refTimestamp = newPosition.time;
 
-        const queueLength = this.locationsQueue.length;
+        const queueLength = this.positionsQueue.length;
         if (queueLength) {
-            refTimestamp = Math.max(refTimestamp, this.locationsQueue[queueLength - 1].time);
+            refTimestamp = Math.max(refTimestamp, this.positionsQueue[queueLength - 1].time);
         }
 
-        let diffTime = newLocation.time - this.previousLocation.time;
+        let diffTime = newPosition.time - this.previousPosition.time;
 
         if (flyby) {
             diffTime = MAX_FLYBY_TIME;
@@ -55,34 +55,34 @@ class Smoother {
         let i = 1;
         while (i < nSamples + 1) {
             i = Math.min(i, nSamples);
-            const smoothedLocation = this.previousLocation.destinationPoint(distance * i / nSamples, azimuth);
-            smoothedLocation.time = refTimestamp + (i - 1) / GEN_FREQUENCY;
-            this.locationsQueue.push(smoothedLocation);
+            const smoothedPosition = this.previousPosition.destinationPoint(distance * i / nSamples, azimuth);
+            smoothedPosition.time = refTimestamp + (i - 1) / GEN_FREQUENCY;
+            this.positionsQueue.push(smoothedPosition);
             i++;
         }
 
-        this.previousLocation = newLocation;
+        this.previousPosition = newPosition;
     }
 
     /**
-     * Pull locations until timestamp and return the last one.
-     * @param {*} timestamp location returned is the last before this timestamp
-     * @returns last known location before timestamp, undefined otherwise
+     * Pull positions until timestamp and return the last one.
+     * @param {*} timestamp position returned is the last before this timestamp
+     * @returns last known position before timestamp, undefined otherwise
      */
-    pullLocation(timestamp) {
+    pullPosition(timestamp) {
 
         if ((typeof timestamp === 'undefined' || !timestamp)
-            && this.locationsQueue.length > 0) {
-            const output = this.locationsQueue[this.locationsQueue.length - 1];
-            this.locationsQueue = [];
+            && this.positionsQueue.length > 0) {
+            const output = this.positionsQueue[this.positionsQueue.length - 1];
+            this.positionsQueue = [];
             return output;
         }
 
-        let location;
-        while (this.locationsQueue.length && this.locationsQueue[0].time <= timestamp) {
-            location = this.locationsQueue.shift();
+        let position;
+        while (this.positionsQueue.length && this.positionsQueue[0].time <= timestamp) {
+            position = this.positionsQueue.shift();
         }
-        return location;
+        return position;
     }
 
 }

package/src/providers/pose/pdr/helpers/Smoother.spec.js

@@ -388,10 +388,10 @@ describe('validSmoother', () => {
         for (let i = 0; i < positions.length; i++) {
             const pos = new WGS84UserPosition(positions[i][1], positions[i][2]);
             pos.time = positions[i][0];
-            smoother.generateNextLocations(pos, positions[i][3]);
+            smoother.generateNextPositions(pos, positions[i][3]);
         }
 
-        const predicted = smoother.locationsQueue;
+        const predicted = smoother.positionsQueue;
         expect(predicted.length).to.equal(expectations.length);
 
         for (let i = 0; i < predicted.length; i++) {
@@ -401,8 +401,8 @@ describe('validSmoother', () => {
             expect(timeDiff).to.almost.equal(0);
         }
 
-        const locationAt10 = smoother.pullLocation(10);
-        expect(locationAt10.distanceTo(new WGS84(3.7669421260460435E-5, 2.5766995044818355E-5))).to.almost.equal(0);
+        const positionAt10 = smoother.pullPosition(10);
+        expect(positionAt10.distanceTo(new WGS84(3.7669421260460435E-5, 2.5766995044818355E-5))).to.almost.equal(0);
     });
 });
 
@@ -413,12 +413,12 @@ describe('smoother return same value if unique', () => {
         const smoother = new Smoother();
 
         const pos = new WGS84UserPosition(positions[0][1], positions[0][2]);
-        smoother.generateNextLocations(pos);
-        const posExpected = smoother.pullLocation();
+        smoother.generateNextPositions(pos);
+        const posExpected = smoother.pullPosition();
 
         expect(posExpected).to.be.an.instanceof(WGS84UserPosition);
         expect(posExpected.distanceTo(pos)).to.almost.equal(0);
-        expect(smoother.locationsQueue).to.be.an('array').that.is.empty;
+        expect(smoother.positionsQueue).to.be.an('array').that.is.empty;
     });
 });
 

package/src/providers/position/GnssWifiProvider.js

@@ -78,8 +78,8 @@ class GnssWifiProvider extends Provider {
     /**
      * @private
      */
-    onNewPosition = position => {
-        const { coords } = position;
+    onNewPosition = geolocation => {
+        const { coords } = geolocation;
         if (!coords) {
             return;
         }
@@ -89,9 +89,9 @@ class GnssWifiProvider extends Provider {
             bearing = deg2rad(coords.heading);
         }
 
-        const timestamp = DateUtils.unixTimestampToPerformanceNow(position.timestamp) / 1e3;
+        const timestamp = DateUtils.unixTimestampToPerformanceNow(geolocation.timestamp) / 1e3;
 
-        const location = new WGS84UserPosition(
+        const position = new WGS84UserPosition(
             coords.latitude,
             coords.longitude,
             coords.altitude,
@@ -101,7 +101,7 @@ class GnssWifiProvider extends Provider {
             GnssWifiProvider.name);
 
         this.notify(this.createEvent(
-            EventType.AbsolutePosition, location, timestamp
+            EventType.AbsolutePosition, position, timestamp
         ));
 
     };

package/src/providers/position/IpProvider.js

@@ -10,7 +10,7 @@ import IpResolveServerError from '../../errors/IpResolveServerError';
  *  by Wifi Fingerprinting algorithms or by GNSS. That is why the name is
  *  "GnssWifi".
  */
-class GnssWifiProvider extends Provider {
+class IpProvider extends Provider {
 
     /**
     * @override
@@ -72,4 +72,4 @@ class GnssWifiProvider extends Provider {
 
 }
 
-export default GnssWifiProvider;
+export default IpProvider;

package/webpack/webpack.common.js

@@ -12,7 +12,7 @@ module.exports = {
             },
             {
                 test: /\.css$/,
-                use: { loader: 'css-loader' }
+                use: ['style-loader', 'css-loader']
             }
         ]
     },

package/src.old/Constants.js

@@ -1,11 +0,0 @@
-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.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;