@wemap/positioning 2.2.0 → 2.3.1

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
@@ -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;