@wemap/positioning 2.4.3 → 2.4.5

package/package.json

@@ -8,10 +8,10 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^0.3.1",
-    "@wemap/logger": "^0.1.5",
+    "@wemap/geo": "^0.3.6",
+    "@wemap/logger": "^0.1.6",
     "@wemap/maths": "^0.2.1",
-    "@wemap/osm": "^0.2.1",
+    "@wemap/osm": "^0.2.8",
     "@wemap/utils": "^0.1.2",
     "geomagnetism": "^0.1.0",
     "lodash.isempty": "^4.4.0",
@@ -80,5 +80,5 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "2.4.3"
+  "version": "2.4.5"
 }

package/src/PositioningHandler.js

@@ -184,22 +184,6 @@ class PositioningHandler {
         provider.setNetwork(network);
     }
 
-
-    /**
-     * @public
-     */
-    getItineraryInfo(id) {
-        const provider = this.providerInstances[id];
-        if (!provider) {
-            throw new Error('Unknown provider');
-        }
-        if (!provider.getItineraryInfo) {
-            Logger.warn('Cannot getItineraryInfo from ' + provider.constructor.name);
-            return null;
-        }
-        return provider.getItineraryInfo();
-    }
-
 }
 
 export default PositioningHandler;

package/src/components/AbsoluteAttitudeComponent.jsx

@@ -1,6 +1,7 @@
 import React from 'react';
 
 import AbsoluteAttitudeProvider from '../providers/attitude/AbsoluteAttitudeProvider';
+import NavigationConfig from './NavigationConfig';
 import Utils from './Utils';
 import EventType from '../events/EventType';
 
@@ -17,7 +18,7 @@ class AbsoluteAttitudeComponent extends React.Component {
         };
 
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(this.onEvent, this.onError);
-        this.absoluteAttitudeProvider.setPosition(Utils.INITIAL_POSITION);
+        this.absoluteAttitudeProvider.setPosition(NavigationConfig.INITIAL_POSITION);
     }
 
     componentDidMount() {

package/src/components/ArCoreAbsoluteComponent.jsx

@@ -4,6 +4,7 @@ import isEmpty from 'lodash.isempty';
 import { deg2rad } from '@wemap/maths';
 
 import EventType from '../events/EventType';
+import NavigationConfig from './NavigationConfig';
 import Utils from './Utils';
 import ArCoreAbsoluteProvider from '../providers/pose/ArCoreAbsoluteProvider';
 import MapComponent from './MapComponent';
@@ -21,8 +22,8 @@ class ArCoreAbsoluteComponent extends React.Component {
             this.onEvent,
             this.onError
         );
-        this.arCoreAbsoluteProvider.setPosition(Utils.INITIAL_POSITION);
-        this.arCoreAbsoluteProvider.setHeading(deg2rad(Utils.INITIAL_HEADING));
+        this.arCoreAbsoluteProvider.setPosition(NavigationConfig.INITIAL_POSITION);
+        this.arCoreAbsoluteProvider.setHeading(deg2rad(NavigationConfig.INITIAL_HEADING));
     }
 
     componentDidMount() {
@@ -72,7 +73,7 @@ class ArCoreAbsoluteComponent extends React.Component {
               <MapComponent
                   ref={map => (this.map = map)}
                   defaultZoom={21}
-                  network={Utils.ITINERARY}
+                  network={NavigationConfig.ITINERARY}
               />
           </div>
       );

package/src/components/GnssWifiPdrComponent.jsx

@@ -1,6 +1,7 @@
 import isEmpty from 'lodash.isempty';
 import React from 'react';
 
+import NavigationConfig from './NavigationConfig';
 import Utils from './Utils';
 import EventType from '../events/EventType';
 import GnssWifiPdrProvider from '../providers/pose/GnssWifiPdrProvider';
@@ -18,7 +19,7 @@ class GnssWifiPdrComponent extends React.Component {
     }
 
     componentDidMount() {
-        this.gnssWifiPdrProvider.enableMapMatching(Utils.ITINERARY);
+        this.gnssWifiPdrProvider.enableMapMatching(NavigationConfig.ITINERARY);
         this.gnssWifiPdrProvider.start();
     }
 
@@ -63,7 +64,7 @@ class GnssWifiPdrComponent extends React.Component {
               {attitudeRender}
               <h3>Map</h3>
               <MapComponent ref={map => (this.map = map)}
-                  network={Utils.ITINERARY} />
+                  network={NavigationConfig.ITINERARY} />
           </div>
       );
   }

package/src/components/NavigationConfig.js

@@ -0,0 +1,94 @@
+import React from 'react'; // eslint-disable-line no-unused-vars
+
+import {
+    Itinerary, WGS84UserPosition, Level
+} from '@wemap/geo';
+import { deg2rad } from '@wemap/maths';
+
+const datasets = {};
+
+// Wemap Office
+const wemapOffice = {
+    initialPosition: new WGS84UserPosition(43.6091955, 3.8841255),
+    initialHeading: deg2rad(191.9)
+};
+wemapOffice.itinerary = Itinerary.fromOrderedPointsArray(
+    [
+        [wemapOffice.initialPosition.lat, wemapOffice.initialPosition.lng],
+        [43.6091883, 3.8841242],
+        [43.6091709, 3.8842382],
+        [43.6091288, 3.884226],
+        [43.6091461, 3.884112]
+    ],
+    [wemapOffice.initialPosition.lat, wemapOffice.initialPosition.lng],
+    [43.6091461, 3.884112],
+    false
+);
+
+// Wemap Office Multi-level
+const wemapOfficeMulti = {
+    initialPosition: new WGS84UserPosition(43.6091965, 3.8841285, null, new Level(2)),
+    initialHeading: deg2rad(191.9)
+};
+wemapOfficeMulti.itinerary = Itinerary.fromOrderedPointsArray(
+    [
+        [43.6091888, 3.8841263, new Level(2)],
+        [43.6091749, 3.8842173, new Level(2)],
+        [43.6092935, 3.8842518, new Level(2)],
+        [43.6093022, 3.8842702, new Level(2)],
+        [43.6093123, 3.8842731, new Level(2)],
+        [43.6093234, 3.8842009, new Level(2)],
+        [43.6093629, 3.8842127, new Level(1, 2)],
+        [43.6093597, 3.8842336, new Level(1, 2)],
+        [43.6093202, 3.8842218, new Level(1)],
+        [43.6093123, 3.8842731, new Level(1)],
+        [43.6092681, 3.8842604, new Level(1)]
+    ],
+    [wemapOfficeMulti.initialPosition.lat, wemapOffice.initialPosition.lng, wemapOfficeMulti.initialPosition.level],
+    [43.6092602, 3.8842669, new Level(1)],
+    false
+);
+
+// Gare de Lyon RER A
+const gareDeLyonRerA = {
+    initialPosition: new WGS84UserPosition(48.8442365, 2.3728267, null, new Level(-2)),
+    initialHeading: deg2rad(41.6)
+};
+gareDeLyonRerA.itinerary = Itinerary.fromOrderedPointsArray(
+    [
+        [48.8442368, 2.3728274, new Level(-2)],
+        [48.8442378, 2.3728257, new Level(-2)],
+        [48.8443732, 2.3726023, new Level(-1)],
+        [48.8443864, 2.3726195, new Level(-1)],
+        [48.8444032, 2.3726407, new Level(-1)]
+    ],
+    [gareDeLyonRerA.initialPosition.lat, gareDeLyonRerA.initialPosition.lng, gareDeLyonRerA.initialPosition.level],
+    [48.8444315, 2.3726809, new Level(-1)],
+    false
+);
+
+
+datasets['wemap-office'] = wemapOffice;
+datasets['wemap-office-multi'] = wemapOfficeMulti;
+datasets['gare-de-lyon-rer-a'] = gareDeLyonRerA;
+
+class NavigationConfig {
+
+    static INITIAL_POSITION = wemapOffice.initialPosition;
+    static INITIAL_HEADING = wemapOffice.initialHeading;
+    static ITINERARY = wemapOffice.itinerary;
+
+    static load(datasetName) {
+
+        const dataset = datasets[datasetName];
+        if (!dataset) {
+            throw new Error('Unknown ' + datasetName);
+        }
+
+        this.INITIAL_POSITION = dataset.initialPosition;
+        this.INITIAL_HEADING = dataset.initialHeading;
+        this.ITINERARY = dataset.itinerary;
+    }
+}
+
+export default NavigationConfig;

package/src/components/PdrComponent.jsx

@@ -1,6 +1,7 @@
 import isEmpty from 'lodash.isempty';
 import React from 'react';
 
+import NavigationConfig from './NavigationConfig';
 import Utils from './Utils';
 import PdrProvider from '../providers/pose/pdr/PdrProvider';
 import EventType from '../events/EventType';
@@ -12,12 +13,12 @@ class PdrComponent extends React.Component {
         this.state = { position: null };
 
         this.pdrProvider = new PdrProvider(this.onEvent, this.onError);
-        this.pdrProvider.enableMapMatching(Utils.ITINERARY);
+        this.pdrProvider.enableMapMatching(NavigationConfig.ITINERARY);
     }
 
     componentDidMount() {
-        this.pdrProvider.setPosition(Utils.INITIAL_POSITION);
-        this.pdrProvider.setHeading(Utils.INITIAL_HEADING);
+        this.pdrProvider.setPosition(NavigationConfig.INITIAL_POSITION);
+        this.pdrProvider.setHeading(NavigationConfig.INITIAL_HEADING);
         this.pdrProvider.start();
     }
 
@@ -62,7 +63,7 @@ class PdrComponent extends React.Component {
               {attitudeRender}
               <h3>Map</h3>
               <MapComponent ref={map => (this.map = map)}
-                  network={Utils.ITINERARY} />
+                  network={NavigationConfig.ITINERARY} />
           </div>
       );
   }

package/src/components/PositioningPoseComponent.jsx

@@ -3,6 +3,7 @@ import isEmpty from 'lodash.isempty';
 import PropTypes from 'prop-types';
 
 import EventType from '../events/EventType';
+import NavigationConfig from './NavigationConfig';
 import Utils from './Utils';
 import PositioningHandler from '../PositioningHandler';
 import StartStopComponent from './StartStopComponent';
@@ -38,10 +39,10 @@ class PositioningPoseComponent extends React.Component {
 
       this.id = output.id;
 
-      this.props.positioningHandler.setItinerary(this.id, Utils.ITINERARY);
-      this.props.positioningHandler.setNetwork(this.id, Utils.ITINERARY);
-      this.props.positioningHandler.setPosition(this.id, Utils.INITIAL_POSITION);
-      this.props.positioningHandler.setHeading(this.id, Utils.INITIAL_HEADING);
+      this.props.positioningHandler.setItinerary(this.id, NavigationConfig.ITINERARY);
+      this.props.positioningHandler.setNetwork(this.id, NavigationConfig.ITINERARY);
+      this.props.positioningHandler.setPosition(this.id, NavigationConfig.INITIAL_POSITION);
+      this.props.positioningHandler.setHeading(this.id, NavigationConfig.INITIAL_HEADING);
   }
 
   stop() {
@@ -85,7 +86,7 @@ class PositioningPoseComponent extends React.Component {
 
       const itineraryRender = Utils.renderItineraryInfo(
           this.state.position && !(this.state.position instanceof Error)
-              ? Utils.ITINERARY.getInfo(this.state.position)
+              ? NavigationConfig.ITINERARY.getInfo(this.state.position)
               : null
       );
 
@@ -103,7 +104,7 @@ class PositioningPoseComponent extends React.Component {
               {attitudeRender}
               <h3>Map</h3>
               <MapComponent ref={map => (this.map = map)}
-                  network={Utils.ITINERARY} />
+                  network={NavigationConfig.ITINERARY} />
               <h3>ItineraryInfo</h3>
               {itineraryRender}
           </div>

package/src/components/Utils.js

@@ -1,8 +1,5 @@
 import React from 'react'; // eslint-disable-line no-unused-vars
 
-import {
-    Itinerary, WGS84UserPosition
-} from '@wemap/geo';
 import { rad2deg } from '@wemap/maths';
 import { OsrmUtils } from '@wemap/osm';
 
@@ -10,21 +7,6 @@ const NOT_AVAILABLE_STR = 'Not available';
 
 class Utils {
 
-    static INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
-    static INITIAL_HEADING = 191.9;
-    static ITINERARY = Itinerary.fromOrderedPointsArray(
-        [
-            [Utils.INITIAL_POSITION.lat, Utils.INITIAL_POSITION.lng],
-            [43.6091883, 3.8841242],
-            [43.6091709, 3.8842382],
-            [43.6091288, 3.884226],
-            [43.6091461, 3.884112]
-        ],
-        [Utils.INITIAL_POSITION.lat, Utils.INITIAL_POSITION.lng],
-        [43.6091461, 3.884112],
-        false
-    );
-
     static renderAttitude(attitude) {
 
         if (!attitude) {
@@ -66,6 +48,7 @@ class Utils {
                 Latitude: {position.lat.toFixed(7)}<br />
                 Longitude: {position.lng.toFixed(7)}<br />
                 Altitude: {position.alt ? position.alt.toFixed(2) : NOT_AVAILABLE_STR}<br />
+                Level: {position.level ? position.level.toString() : NOT_AVAILABLE_STR}<br />
                 Bearing: {position.bearing ? position.bearing.toFixed(2) : NOT_AVAILABLE_STR}<br />
                 Accuracy: {position.accuracy ? position.accuracy.toFixed(2) : NOT_AVAILABLE_STR}<br />
                 Time: {position.time ? position.time.toFixed(2) : NOT_AVAILABLE_STR}<br />

package/src/providers/Provider.js

@@ -53,6 +53,15 @@ class Provider {
         ProvidersLogger.addEvent(this, 'constructor');
     }
 
+    /**
+     * Get the provider display name
+     * @public
+     * @abstract
+     */
+    static get name() {
+        return this.DEFAULT_NAME;
+    }
+
     /**
      * Get the provider name
      * @public

package/src/providers/attitude/AbsoluteAttitudeProvider.js

@@ -38,6 +38,14 @@ import Availability from '../../events/Availability';
  */
 class AbsoluteAttitudeProvider extends Provider {
 
+
+    /**
+     * @override
+     */
+    static get name() {
+        return 'AbsoluteAttitude';
+    }
+
     /**
     * @override
     */

package/src/providers/attitude/RelativeAttitudeProvider.js

@@ -29,6 +29,13 @@ class RelativeAttitudeProvider extends Provider {
 
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'RelativeAttitude';
+    }
+
     /**
     * @override
     */

package/src/providers/others/ImuProvider.js

@@ -61,6 +61,12 @@ class ImuProvider extends Provider {
         this.requiredSensors = options.require;
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'Imu';
+    }
 
     /**
     * @override

package/src/providers/others/InclinationProvider.js

@@ -23,6 +23,13 @@ class InclinationProvider extends Provider {
         );
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'Inclination';
+    }
+
     /**
     * @override
     */

package/src/providers/others/MapMatchingProvider.js

@@ -1,6 +1,6 @@
 import Provider from '../Provider';
 import {
-    Itinerary, MapMatching, Network, WGS84
+    Itinerary, MapMatching, Network
 } from '@wemap/geo';
 
 class MapMatchingProvider extends Provider {
@@ -63,26 +63,6 @@ class MapMatchingProvider extends Provider {
         }
         this.itinerary = itinerary;
     }
-
-    /**
-     * Returns projection and itinerary info of a position on network
-     * @param {WGS84} position if position is null/undefined, projection of this.position is used
-     * @returns An object of the projected position and itinerary info or null.
-     * @public
-     */
-    getItineraryInfo(position) {
-
-        if (!this.itinerary) {
-            throw new Error('No itinerary found');
-        }
-
-        const _position = position || this.position;
-        if (!_position) {
-            return null;
-        }
-
-        return this.itinerary.getInfo(position || this.position);
-    }
 }
 
 export default MapMatchingProvider;

package/src/providers/pose/ArCoreAbsoluteProvider.js

@@ -1,19 +1,22 @@
 /* eslint-disable max-statements */
-import { Attitude } from '@wemap/geo';
+import {
+    Attitude, WGS84UserPosition
+} from '@wemap/geo';
 
-import Provider from '../Provider';
 import EventType from '../../events/EventType';
 import ArCoreProvider from './ArCoreProvider';
 import {
     Quaternion, Vector3
 } from '@wemap/maths';
 import ImuProvider from '../others/ImuProvider';
+import MapMatchingProvider from '../others/MapMatchingProvider';
+import PdrProvider from './pdr/PdrProvider';
 
 /**
  * Pose provider is the provider used by the PositioningHandler. It uses the best fusion
  * of what he can and provides an AbsoluteAttitude and an AbsolutePosition as an output.
  */
-class ArCoreAbsoluteProvider extends Provider {
+class ArCoreAbsoluteProvider extends MapMatchingProvider {
 
     /**
     * @override
@@ -31,6 +34,17 @@ class ArCoreAbsoluteProvider extends Provider {
             onError,
             Object.assign({}, options || {}, { require: [EventType.AngularRate] })
         );
+
+        if (this.options.useMapMatching) {
+            this.enableMapMatching();
+        }
+    }
+
+    /**
+     * @override
+     */
+    static get name() {
+        return 'ArCoreAbsolute';
     }
 
     /**
@@ -123,6 +137,12 @@ class ArCoreAbsoluteProvider extends Provider {
                     const dist = Math.sqrt(diffPos[0] ** 2 + diffPos[2] ** 2);
                     const bearing = Math.atan2(diffPos[0], -diffPos[2]) - this.offsetAngle;
                     this.position = this.position.destinationPoint(dist, bearing, diffPos[1]);
+
+                    if (this.absoluteAttitude) {
+                        this.position.bearing = this.absoluteAttitude.headingDegrees;
+                        this.updateLevel(this.position);
+                    }
+
                     this.notify(this.createEvent(EventType.AbsolutePosition, this.position, event.timestamp));
                 }
 
@@ -151,7 +171,7 @@ class ArCoreAbsoluteProvider extends Provider {
     }
 
     setPosition(position) {
-        this.position = position.clone();
+        this.position = WGS84UserPosition.fromWGS84(position);
         this.position.provider = this.constructor.name;
         this.notify(this.createEvent(EventType.AbsolutePosition, this.position));
     }
@@ -162,6 +182,28 @@ class ArCoreAbsoluteProvider extends Provider {
     static get useCameraNatively() {
         return true;
     }
+
+
+    /**
+     * MapMatching
+     */
+
+    enableMapMatching(network, maxDistance, maxAngleBearing) {
+        super.enableMapMatching(
+            network,
+            maxDistance || PdrProvider.MM_PDR_DIST,
+            maxAngleBearing || PdrProvider.MM_PDR_ANGLE
+        );
+    }
+
+    updateLevel(position) {
+        if (this.mapMatching) {
+            const projection = this.mapMatching.getProjection(position, true);
+            if (projection) {
+                position.level = projection.projection.level;
+            }
+        }
+    }
 }
 
 export default ArCoreAbsoluteProvider;

package/src/providers/pose/ArCoreProvider.js

@@ -12,6 +12,13 @@ import Availability from '../../events/Availability';
  */
 class ArCoreProvider extends Provider {
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'ArCore';
+    } 
+
     /**
     * @override
     */

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -40,6 +40,12 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
         }
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'GnssWifi';
+    }
 
     /**
     * @override
@@ -126,8 +132,8 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
                 if (projection && projection.projection) {
 
                     // Create a new position from projection and new GNSS position.
-                    const projectedPosition = WGS84UserPosition.fromWGS84(projection.projection, this.gnssPosition);
-                    this.pdrProvider.setPosition(projectedPosition);
+                    this.gnssPosition.lat = projection.projection.lat;
+                    this.gnssPosition.lng = projection.projection.lng;
 
                     // // If nearest element is an edge, use its orientation to set heading
                     // if (projection.nearestElement instanceof Edge) {
@@ -141,9 +147,8 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
                         this.pdrProvider.setHeading(this.lastAttitude.heading);
                     }
 
-                } else {
-                    this.pdrProvider.setPosition(this.gnssPosition);
                 }
+                this.pdrProvider.setPosition(this.gnssPosition);
             }
         }
 

package/src/providers/pose/PoseProvider.js

@@ -23,6 +23,13 @@ class PoseProvider extends Provider {
         }, onError);
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'Pose';
+    }
+    
     /**
     * @override
     */

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import noop from 'lodash.noop';
 
 import {
@@ -36,6 +37,9 @@ class PdrProvider extends MapMatchingProvider {
     //     this.position is smoothed position.
     pdrPosition = null;
 
+    static MM_PDR_ANGLE = MM_PDR_ANGLE;
+    static MM_PDR_DIST = MM_PDR_DIST;
+
     /**
     * @override
     */
@@ -67,6 +71,12 @@ class PdrProvider extends MapMatchingProvider {
         }
     }
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'PDR';
+    }
 
     /**
     * @override
@@ -255,25 +265,36 @@ class PdrProvider extends MapMatchingProvider {
             return newPositionWithoutMM;
         }
 
+        /**
+         * Try map-matching
+         */
         const projection = this.mapMatching.getProjection(newPositionWithoutMM, true, true);
-
         if (!projection || !projection.projection) {
             return newPositionWithoutMM;
         }
 
+        const projectedPosition = newPositionWithoutMM;
+        projectedPosition.level = projection.projection.level;
+
         if (projection.distanceFromNearestElement < stepSize) {
-            return WGS84UserPosition.fromWGS84(projection.projection, newPositionWithoutMM);
+            projectedPosition.lat = projection.projection.lat;
+            projectedPosition.lng = projection.projection.lng;
+            return projectedPosition;
         }
 
         /**
-         * Update new_position
+         * Adapt map-matching to not stick corridor directly
+         * /!\ This smoothed position is different from the one of Smoother
          */
+        const smoothedPosition = projectedPosition;
+        smoothedPosition.lat = previousPosition.lat;
+        smoothedPosition.lng = previousPosition.lng;
+
         const smoothedDistance = projection.distanceFromNearestElement * MM_CONV_SPEED;
         const smoothedBearing = previousPosition.bearingTo(projection.projection);
-        const smoothedPosition = previousPosition.clone();
         smoothedPosition.move(smoothedDistance, smoothedBearing);
 
-        return WGS84UserPosition.fromWGS84(smoothedPosition, newPositionWithoutMM);
+        return smoothedPosition;
     }
 
 

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

@@ -1,5 +1,6 @@
-/* eslint max-statements: ["error", 27]*/
+/* eslint-disable max-statements */
 import { WGS84UserPosition } from '@wemap/geo';
+import { rad2deg } from '@wemap/maths';
 
 // Generated positions by second
 const GEN_FREQUENCY = 60;
@@ -17,50 +18,49 @@ class Smoother {
     /**
      * Calculate smoothed positions for the next milliseconds given a new position
      */
-    generateNextPositions(_newPosition, flyby = false) {
+    generateNextPositions(newPosition, flyby = false) {
 
-        if (!(_newPosition instanceof WGS84UserPosition)) {
+        if (!(newPosition instanceof WGS84UserPosition)) {
             throw new TypeError('newPosition is not instance of WGS84UserPosition');
         }
 
-        const newPosition = _newPosition.clone();
         if (!newPosition.hasOwnProperty('time')) {
             throw new Error('newPosition does not have time property');
         }
 
-        if (!this.previousPosition) {
-            this.previousPosition = newPosition;
-            this.positionsQueue.push(this.previousPosition);
-            return;
-        }
+        if (this.previousPosition) {
 
-        const distance = this.previousPosition.distanceTo(newPosition);
-        const azimuth = this.previousPosition.bearingTo(newPosition);
+            const distance = this.previousPosition.distanceTo(newPosition);
+            const azimuth = this.previousPosition.bearingTo(newPosition);
 
-        let refTimestamp = newPosition.time;
+            let refTimestamp = newPosition.time;
 
-        const queueLength = this.positionsQueue.length;
-        if (queueLength) {
-            refTimestamp = Math.max(refTimestamp, this.positionsQueue[queueLength - 1].time);
-        }
+            const queueLength = this.positionsQueue.length;
+            if (queueLength) {
+                refTimestamp = Math.max(refTimestamp, this.positionsQueue[queueLength - 1].time);
+            }
 
-        let diffTime = newPosition.time - this.previousPosition.time;
+            let diffTime = newPosition.time - this.previousPosition.time;
 
-        if (flyby) {
-            diffTime = MAX_FLYBY_TIME;
-        }
+            if (flyby) {
+                diffTime = MAX_FLYBY_TIME;
+            }
 
-        const nSamples = GEN_FREQUENCY * Math.min(Math.max(MIN_FLYBY_TIME, diffTime), MAX_FLYBY_TIME);
+            const nSamples = GEN_FREQUENCY * Math.min(Math.max(MIN_FLYBY_TIME, diffTime), MAX_FLYBY_TIME);
 
-        let i = 1;
-        while (i < nSamples + 1) {
-            i = Math.min(i, nSamples);
-            const smoothedPosition = this.previousPosition.destinationPoint(distance * i / nSamples, azimuth);
-            smoothedPosition.time = refTimestamp + (i - 1) / GEN_FREQUENCY;
-            this.positionsQueue.push(smoothedPosition);
-            i++;
+            let i = 1;
+            while (i < nSamples) {
+                i = Math.min(i, nSamples);
+                const smoothedPosition = this.previousPosition.destinationPoint(distance * i / nSamples, azimuth);
+                smoothedPosition.time = refTimestamp + (i - 1) / GEN_FREQUENCY;
+                smoothedPosition.bearing = rad2deg(azimuth);
+                this.positionsQueue.push(smoothedPosition);
+                i++;
+            }
+            newPosition.bearing = rad2deg(azimuth);
         }
 
+        this.positionsQueue.push(newPosition);
         this.previousPosition = newPosition;
     }
 

package/src/providers/position/GnssWifiProvider.js

@@ -23,6 +23,13 @@ const POSITION_OPTIONS = {
  */
 class GnssWifiProvider extends Provider {
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'GnssWifi';
+    }
+
     /**
     * @override
     */

package/src/providers/position/IpProvider.js

@@ -12,6 +12,13 @@ import IpResolveServerError from '../../errors/IpResolveServerError';
  */
 class IpProvider extends Provider {
 
+    /**
+     * @override
+     */
+    static get name() {
+        return 'IP';
+    }
+
     /**
     * @override
     */