@wemap/positioning 2.2.0 → 2.3.0

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;