@wemap/positioning 2.3.11 → 2.4.1

package/package.json

@@ -8,13 +8,12 @@
     "Guillaume Pannetier <guillaume.pannetier@getwemap.com>"
   ],
   "dependencies": {
-    "@wemap/geo": "^0.1.4",
-    "@wemap/logger": "^0.1.4",
-    "@wemap/maths": "^0.1.2",
+    "@wemap/geo": "^0.3.1",
+    "@wemap/logger": "^0.1.5",
+    "@wemap/maths": "^0.2.1",
+    "@wemap/osm": "^0.2.1",
     "@wemap/utils": "^0.1.2",
-    "file-saver": "^2.0.2",
     "geomagnetism": "^0.1.0",
-    "jszip": "^3.2.2",
     "lodash.isempty": "^4.4.0",
     "lodash.isnumber": "^3.0.3",
     "lodash.noop": "^3.0.1"
@@ -81,5 +80,5 @@
     "lint": "eslint --ext .js,.jsx --quiet src",
     "test": "mocha -r esm \"src/**/*.spec.js\""
   },
-  "version": "2.3.11"
+  "version": "2.4.1"
 }

package/src/components/AbsoluteAttitudeComponent.jsx

@@ -1,12 +1,9 @@
 import React from 'react';
 
-import { WGS84 } from '@wemap/geo';
-
 import AbsoluteAttitudeProvider from '../providers/attitude/AbsoluteAttitudeProvider';
 import Utils from './Utils';
 import EventType from '../events/EventType';
 
-const userPosition = new WGS84(43.609275, 3.884236);
 
 class AbsoluteAttitudeComponent extends React.Component {
 
@@ -20,7 +17,7 @@ class AbsoluteAttitudeComponent extends React.Component {
         };
 
         this.absoluteAttitudeProvider = new AbsoluteAttitudeProvider(this.onEvent, this.onError);
-        this.absoluteAttitudeProvider.setPosition(userPosition);
+        this.absoluteAttitudeProvider.setPosition(Utils.INITIAL_POSITION);
     }
 
     componentDidMount() {

package/src/components/ArCoreAbsoluteComponent.jsx

@@ -1,27 +1,15 @@
 import React from 'react';
 import isEmpty from 'lodash.isempty';
 
+import { deg2rad } from '@wemap/maths';
+
 import EventType from '../events/EventType';
 import Utils from './Utils';
 import ArCoreAbsoluteProvider from '../providers/pose/ArCoreAbsoluteProvider';
-import { deg2rad } from '@wemap/maths';
-import {
-    WGS84UserPosition, Itinerary
-} from '@wemap/geo';
 import MapComponent from './MapComponent';
 
-const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
-const INITIAL_HEADING = 191.9;
-const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
-    [43.6091883, 3.8841242],
-    [43.6091709, 3.8842382],
-    [43.6091288, 3.884226],
-    [43.6091461, 3.884112]
-], false);
 
 class ArCoreAbsoluteComponent extends React.Component {
-
     constructor(props, context) {
         super(props, context);
         this.state = {
@@ -29,10 +17,12 @@ class ArCoreAbsoluteComponent extends React.Component {
             attitude: null
         };
 
-        this.arCoreAbsoluteProvider = new ArCoreAbsoluteProvider(this.onEvent, this.onError);
-        this.arCoreAbsoluteProvider.setPosition(INITIAL_POSITION);
-        this.arCoreAbsoluteProvider.setHeading(deg2rad(INITIAL_HEADING));
-
+        this.arCoreAbsoluteProvider = new ArCoreAbsoluteProvider(
+            this.onEvent,
+            this.onError
+        );
+        this.arCoreAbsoluteProvider.setPosition(Utils.INITIAL_POSITION);
+        this.arCoreAbsoluteProvider.setHeading(deg2rad(Utils.INITIAL_HEADING));
     }
 
     componentDidMount() {
@@ -43,51 +33,50 @@ class ArCoreAbsoluteComponent extends React.Component {
         this.arCoreAbsoluteProvider.stop();
     }
 
-    onEvent = events => {
-        const newState = {};
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                newState.position = event.data;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                newState.attitude = event.data;
-            }
-        });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
-
-        if (this.map) {
-            this.map.parseEvents(events);
-        }
-    };
-
-    onError = error => {
-        this.setState({
-            position: error,
-            attitude: error
-        });
-    }
-
-    render() {
-
-        const attitudeRender = Utils.renderAttitude(this.state.attitude);
-        const positionRender = Utils.renderPosition(this.state.position);
-
-        return (
-            <div>
-                <h3>Position</h3>
-                {positionRender}
-                <h3>Attitude</h3>
-                {attitudeRender}
-                <h3>Map</h3>
-                <MapComponent
-                    ref={map => (this.map = map)}
-                    defaultZoom={21}
-                    network={ITINERARY} />
-            </div>
-
-        );
-    }
+  onEvent = events => {
+      const newState = {};
+      events.forEach(event => {
+          if (event.dataType === EventType.AbsolutePosition) {
+              newState.position = event.data;
+          } else if (event.dataType === EventType.AbsoluteAttitude) {
+              newState.attitude = event.data;
+          }
+      });
+      if (!isEmpty(newState)) {
+          this.setState(newState);
+      }
+
+      if (this.map) {
+          this.map.parseEvents(events);
+      }
+  };
+
+  onError = error => {
+      this.setState({
+          position: error,
+          attitude: error
+      });
+  };
+
+  render() {
+      const attitudeRender = Utils.renderAttitude(this.state.attitude);
+      const positionRender = Utils.renderPosition(this.state.position);
+
+      return (
+          <div>
+              <h3>Position</h3>
+              {positionRender}
+              <h3>Attitude</h3>
+              {attitudeRender}
+              <h3>Map</h3>
+              <MapComponent
+                  ref={map => (this.map = map)}
+                  defaultZoom={21}
+                  network={Utils.ITINERARY}
+              />
+          </div>
+      );
+  }
 }
 
 export default ArCoreAbsoluteComponent;

package/src/components/GnssWifiPdrComponent.jsx

@@ -1,36 +1,24 @@
 import isEmpty from 'lodash.isempty';
 import React from 'react';
 
-import {
-    Itinerary, WGS84UserPosition
-} from '@wemap/geo';
-
 import Utils from './Utils';
 import EventType from '../events/EventType';
 import GnssWifiPdrProvider from '../providers/pose/GnssWifiPdrProvider';
 import MapComponent from './MapComponent';
 
-const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
-const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
-    [43.6091883, 3.8841242],
-    [43.6091709, 3.8842382],
-    [43.6091288, 3.884226],
-    [43.6091461, 3.884112]
-], false);
-
 class GnssWifiPdrComponent extends React.Component {
-
     constructor(props, context) {
         super(props, context);
         this.state = { position: null };
 
-        this.gnssWifiPdrProvider = new GnssWifiPdrProvider(this.onEvent, this.onError);
+        this.gnssWifiPdrProvider = new GnssWifiPdrProvider(
+            this.onEvent,
+            this.onError
+        );
     }
 
-
     componentDidMount() {
-        this.gnssWifiPdrProvider.enableMapMatching(ITINERARY);
+        this.gnssWifiPdrProvider.enableMapMatching(Utils.ITINERARY);
         this.gnssWifiPdrProvider.start();
     }
 
@@ -38,50 +26,47 @@ class GnssWifiPdrComponent extends React.Component {
         this.gnssWifiPdrProvider.stop();
     }
 
-    onEvent = events => {
-        const newState = {};
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                newState.position = event.data;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                newState.attitude = event.data;
-            }
-        });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
-
-        if (this.map) {
-            this.map.parseEvents(events);
-        }
-    };
-
-    onError = error => {
-        this.setState({
-            position: error,
-            attitude: error
-        });
-    }
-
-    render() {
-
-        const attitudeRender = Utils.renderAttitude(this.state.attitude);
-        const positionRender = Utils.renderPosition(this.state.position);
-
-        return (
-            <div>
-                <h3>Position</h3>
-                {positionRender}
-                <h3>Attitude</h3>
-                {attitudeRender}
-                <h3>Map</h3>
-                <MapComponent
-                    ref={map => (this.map = map)}
-                    network={ITINERARY} />
-            </div>
-
-        );
-    }
+  onEvent = events => {
+      const newState = {};
+      events.forEach(event => {
+          if (event.dataType === EventType.AbsolutePosition) {
+              newState.position = event.data;
+          } else if (event.dataType === EventType.AbsoluteAttitude) {
+              newState.attitude = event.data;
+          }
+      });
+      if (!isEmpty(newState)) {
+          this.setState(newState);
+      }
+
+      if (this.map) {
+          this.map.parseEvents(events);
+      }
+  };
+
+  onError = error => {
+      this.setState({
+          position: error,
+          attitude: error
+      });
+  };
+
+  render() {
+      const attitudeRender = Utils.renderAttitude(this.state.attitude);
+      const positionRender = Utils.renderPosition(this.state.position);
+
+      return (
+          <div>
+              <h3>Position</h3>
+              {positionRender}
+              <h3>Attitude</h3>
+              {attitudeRender}
+              <h3>Map</h3>
+              <MapComponent ref={map => (this.map = map)}
+                  network={Utils.ITINERARY} />
+          </div>
+      );
+  }
 }
 
 export default GnssWifiPdrComponent;

package/src/components/MapComponent.jsx

@@ -4,8 +4,9 @@ import 'mapbox-gl/dist/mapbox-gl.css';
 import PropTypes from 'prop-types';
 
 import {
-    WGS84, Attitude, Network
+    Attitude, Network, WGS84
 } from '@wemap/geo';
+
 import EventType from '../events/EventType';
 
 mapboxgl.accessToken = 'pk.eyJ1IjoibWFwYm94IiwiYSI6ImNpejY4M29iazA2Z2gycXA4N2pmbDZmangifQ.-g_vE53SD2WrJ6tFX7QHmA';
@@ -209,11 +210,11 @@ class MapComponent extends React.Component {
             }
         };
 
-        for (let i = 0; i < network.length; i++) {
+        for (let i = 0; i < network.edges.length; i++) {
             layer.source.data.geometry.coordinates.push(
                 [
-                    [network.edges[i].node1.lng, network.edges[i].node1.lat],
-                    [network.edges[i].node2.lng, network.edges[i].node2.lat]
+                    [network.edges[i].node1.coords.lng, network.edges[i].node1.coords.lat],
+                    [network.edges[i].node2.coords.lng, network.edges[i].node2.coords.lat]
                 ]
             );
         }

package/src/components/PdrComponent.jsx

@@ -1,39 +1,23 @@
 import isEmpty from 'lodash.isempty';
 import React from 'react';
 
-import {
-    Itinerary, WGS84UserPosition
-} from '@wemap/geo';
-
 import Utils from './Utils';
 import PdrProvider from '../providers/pose/pdr/PdrProvider';
 import EventType from '../events/EventType';
 import MapComponent from './MapComponent';
 
-const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
-const INITIAL_HEADING = 191.9;
-const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
-    [43.6091883, 3.8841242],
-    [43.6091709, 3.8842382],
-    [43.6091288, 3.884226],
-    [43.6091461, 3.884112]
-], false);
-
 class PdrComponent extends React.Component {
-
     constructor(props, context) {
         super(props, context);
         this.state = { position: null };
 
         this.pdrProvider = new PdrProvider(this.onEvent, this.onError);
-        this.pdrProvider.enableMapMatching(ITINERARY);
+        this.pdrProvider.enableMapMatching(Utils.ITINERARY);
     }
 
-
     componentDidMount() {
-        this.pdrProvider.setPosition(INITIAL_POSITION);
-        this.pdrProvider.setHeading(INITIAL_HEADING);
+        this.pdrProvider.setPosition(Utils.INITIAL_POSITION);
+        this.pdrProvider.setHeading(Utils.INITIAL_HEADING);
         this.pdrProvider.start();
     }
 
@@ -41,50 +25,47 @@ class PdrComponent extends React.Component {
         this.pdrProvider.stop();
     }
 
-    onEvent = events => {
-        const newState = {};
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                newState.position = event.data;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                newState.attitude = event.data;
-            }
-        });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
-
-        if (this.map) {
-            this.map.parseEvents(events);
-        }
-    };
-
-    onError = error => {
-        this.setState({
-            position: error,
-            attitude: error
-        });
-    }
-
-    render() {
-
-        const attitudeRender = Utils.renderAttitude(this.state.attitude);
-        const positionRender = Utils.renderPosition(this.state.position);
-
-        return (
-            <div>
-                <h3>Position</h3>
-                {positionRender}
-                <h3>Attitude</h3>
-                {attitudeRender}
-                <h3>Map</h3>
-                <MapComponent
-                    ref={map => (this.map = map)}
-                    network={ITINERARY} />
-            </div>
-
-        );
-    }
+  onEvent = events => {
+      const newState = {};
+      events.forEach(event => {
+          if (event.dataType === EventType.AbsolutePosition) {
+              newState.position = event.data;
+          } else if (event.dataType === EventType.AbsoluteAttitude) {
+              newState.attitude = event.data;
+          }
+      });
+      if (!isEmpty(newState)) {
+          this.setState(newState);
+      }
+
+      if (this.map) {
+          this.map.parseEvents(events);
+      }
+  };
+
+  onError = error => {
+      this.setState({
+          position: error,
+          attitude: error
+      });
+  };
+
+  render() {
+      const attitudeRender = Utils.renderAttitude(this.state.attitude);
+      const positionRender = Utils.renderPosition(this.state.position);
+
+      return (
+          <div>
+              <h3>Position</h3>
+              {positionRender}
+              <h3>Attitude</h3>
+              {attitudeRender}
+              <h3>Map</h3>
+              <MapComponent ref={map => (this.map = map)}
+                  network={Utils.ITINERARY} />
+          </div>
+      );
+  }
 }
 
 export default PdrComponent;

package/src/components/PositioningInclinationComponent.jsx

@@ -21,11 +21,17 @@ class PositioningInclinationComponent extends React.Component {
 
 
     start() {
-        this.id = this.props.positioningHandler.start(
+        const output = this.props.positioningHandler.start(
             [EventType.Inclination],
             this.onEvents,
             this.onError
-        ).id;
+        );
+
+        if (!output) {
+            return;
+        }
+
+        this.id = output.id;
     }
 
 
@@ -51,7 +57,7 @@ class PositioningInclinationComponent extends React.Component {
 
     onError = error => {
         this.setState({
-            errorer: true,
+            errored: true,
             inclination: error
         });
     }

package/src/components/PositioningPoseComponent.jsx

@@ -6,116 +6,107 @@ import EventType from '../events/EventType';
 import Utils from './Utils';
 import PositioningHandler from '../PositioningHandler';
 import StartStopComponent from './StartStopComponent';
-import {
-    WGS84UserPosition, Itinerary
-} from '@wemap/geo';
 import MapComponent from './MapComponent';
 
-const INITIAL_POSITION = new WGS84UserPosition(43.6091955, 3.8841255);
-const INITIAL_HEADING = 191.9;
-const ITINERARY = Itinerary.fromPoints([
-    [INITIAL_POSITION.lat, INITIAL_POSITION.lng],
-    [43.6091883, 3.8841242],
-    [43.6091709, 3.8842382],
-    [43.6091288, 3.884226],
-    [43.6091461, 3.884112]
-], false);
 
 class PositioningPoseComponent extends React.Component {
-
-    static propTypes = { positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired };
-
-    constructor(props, context) {
-        super(props, context);
-        this.state = {
-            position: null,
-            attitude: null,
-            errored: false
-        };
-    }
-
-
-    start() {
-        const output = this.props.positioningHandler.start(
-            [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
-            this.onEvents,
-            this.onError,
-            {
-                waitInputPosition: true,
-                useMapMatching: true
-            }
-        );
-
-        if (!output) {
-            return;
-        }
-
-        this.id = output.id;
-
-        this.props.positioningHandler.setItinerary(this.id, ITINERARY);
-        this.props.positioningHandler.setNetwork(this.id, ITINERARY);
-        this.props.positioningHandler.setPosition(this.id, INITIAL_POSITION);
-        this.props.positioningHandler.setHeading(this.id, INITIAL_HEADING);
-    }
-
-
-    stop() {
-        this.props.positioningHandler.stop(this.id);
-        this.setState({
-            position: null,
-            attitude: null,
-            errored: false
-        });
-    }
-
-    onEvents = (events) => {
-        const newState = {};
-        events.forEach(event => {
-            if (event.dataType === EventType.AbsolutePosition) {
-                newState.position = event.data;
-            } else if (event.dataType === EventType.AbsoluteAttitude) {
-                newState.attitude = event.data;
-            }
-        });
-        if (!isEmpty(newState)) {
-            this.setState(newState);
-        }
-
-        if (this.map) {
-            this.map.parseEvents(events);
-        }
-    };
-
-    onError = error => {
-        this.setState({
-            position: error,
-            attitude: error,
-            errored: true
-        });
-    }
-
-    render() {
-        const attitudeRender = Utils.renderAttitude(this.state.attitude);
-        const positionRender = Utils.renderPosition(this.state.position);
-
-        return (
-            <div>
-                <StartStopComponent
-                    onStart={() => this.start()}
-                    onStop={() => this.stop()}
-                    errored={this.state.errored} />
-
-                <h3>Position</h3>
-                {positionRender}
-                <h3>Attitude</h3>
-                {attitudeRender}
-                <h3>Map</h3>
-                <MapComponent
-                    ref={map => (this.map = map)}
-                    network={ITINERARY} />
-            </div>
-        );
-    }
+  static propTypes = {positioningHandler: PropTypes.instanceOf(PositioningHandler).isRequired};
+
+  constructor(props, context) {
+      super(props, context);
+      this.state = {
+          position: null,
+          attitude: null,
+          errored: false
+      };
+  }
+
+  start() {
+      const output = this.props.positioningHandler.start(
+          [EventType.AbsolutePosition, EventType.AbsoluteAttitude],
+          this.onEvents,
+          this.onError,
+          {
+              waitInputPosition: true,
+              useMapMatching: true
+          }
+      );
+
+      if (!output) {
+          return;
+      }
+
+      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);
+  }
+
+  stop() {
+      this.props.positioningHandler.stop(this.id);
+      this.setState({
+          position: null,
+          attitude: null,
+          errored: false
+      });
+  }
+
+  onEvents = events => {
+      const newState = {};
+      events.forEach(event => {
+          if (event.dataType === EventType.AbsolutePosition) {
+              newState.position = event.data;
+          } else if (event.dataType === EventType.AbsoluteAttitude) {
+              newState.attitude = event.data;
+          }
+      });
+      if (!isEmpty(newState)) {
+          this.setState(newState);
+      }
+
+      if (this.map) {
+          this.map.parseEvents(events);
+      }
+  };
+
+  onError = error => {
+      this.setState({
+          position: error,
+          attitude: error,
+          errored: true
+      });
+  };
+
+  render() {
+      const attitudeRender = Utils.renderAttitude(this.state.attitude);
+      const positionRender = Utils.renderPosition(this.state.position);
+
+      const itineraryRender = Utils.renderItineraryInfo(
+          this.state.position ? Utils.ITINERARY.getInfo(this.state.position) : null
+      );
+
+      return (
+          <div>
+              <StartStopComponent
+                  onStart={() => this.start()}
+                  onStop={() => this.stop()}
+                  errored={this.state.errored}
+              />
+
+              <h3>Position</h3>
+              {positionRender}
+              <h3>Attitude</h3>
+              {attitudeRender}
+              <h3>Map</h3>
+              <MapComponent ref={map => (this.map = map)}
+                  network={Utils.ITINERARY} />
+              <h3>ItineraryInfo</h3>
+              {itineraryRender}
+          </div>
+      );
+  }
 }
 
 export default PositioningPoseComponent;

package/src/components/Utils.js

@@ -1,10 +1,30 @@
 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';
 
 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) {
@@ -73,6 +93,38 @@ class Utils {
 
     }
 
+    static renderItineraryInfo(info) {
+
+        if (!info) {
+            return <p>Waiting</p>;
+        }
+
+        const step = info.nextStep;
+        let nextStepStr = '[' + step.number + '] ';
+        if (step.firstStep) {
+            nextStepStr += 'Depart';
+        } else if (step.lastStep) {
+            nextStepStr += 'Arrive';
+        } else {
+            nextStepStr += 'Turn '
+                + OsrmUtils.getModifierFromAngle(step.angle);
+        }
+
+
+        return (
+            <p>
+                projection: {info.projection.nearestElement.constructor.name}<br />
+                distanceOfProjection: {info.projection.distanceFromNearestElement.toFixed(1)}m<br />
+                traveledDistance: {info.traveledDistance.toFixed(1)}m
+                    ({(info.traveledPercentage * 100).toFixed(1)}%)<br />
+                remainingDistance: {info.remainingDistance.toFixed(1)}m
+                    ({(info.remainingPercentage * 100).toFixed(1)}%)<br />
+                nextStep: {nextStepStr}
+            </p>
+        );
+
+    }
+
     static renderInclination(inclination) {
         if (inclination === null) {
             return 'Waiting';
@@ -87,6 +139,7 @@ class Utils {
         return (<span><strong>[{error.constructor.name}]</strong> {error.message}</span>);
     }
 
+
 }
 
 export default Utils;

package/src/providers/others/MapMatchingProvider.js

@@ -1,6 +1,6 @@
 import Provider from '../Provider';
 import {
-    WGS84, Edge, Itinerary, Network, MapMatching
+    Itinerary, MapMatching, Network, WGS84
 } from '@wemap/geo';
 
 class MapMatchingProvider extends Provider {
@@ -46,29 +46,6 @@ class MapMatchingProvider extends Provider {
         return this.mapMatching !== null;
     }
 
-    /**
-     * Returns projection of a position on network
-     * @param {WGS84} position if position is null, projection of this.position is used
-     * @returns The projected position {WGS84} or null.
-     * @public
-     */
-    getProjectionOnNetwork(position = null) {
-
-        if (!this.mapMatching) {
-            return null;
-        }
-
-        let positionToProject = position;
-        if (!position) {
-            positionToProject = this.position;
-        }
-        if (!positionToProject) {
-            return null;
-        }
-
-        return this.mapMatching.getProjection(positionToProject, false, false);
-    }
-
 
     /**
      * Itinerary
@@ -87,60 +64,24 @@ class MapMatchingProvider extends Provider {
         this.itinerary = itinerary;
     }
 
-
     /**
      * Returns projection and itinerary info of a position on network
-     * @param {WGS84} position if position is null, projection of this.position is used
+     * @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 = null) {
+    getItineraryInfo(position) {
 
         if (!this.itinerary) {
             throw new Error('No itinerary found');
         }
-        const projection = this.getProjectionOnNetwork(position);
-        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');
+        const _position = position || this.position;
+        if (!_position) {
+            return null;
         }
 
-        return {
-            projection: projection,
-            traveledDistance,
-            traveledPercentage: traveledDistance / totalDistance,
-            remainingDistance: totalDistance - traveledDistance,
-            remainingPercentage: 1 - traveledDistance / totalDistance
-        };
+        return this.itinerary.getInfo(position || this.position);
     }
 }
 

package/src/providers/pose/GnssWifiPdrProvider.js

@@ -117,7 +117,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
             } else {
 
                 this.gnssPosition.bearing = this.attitude.headingDegrees;
-                const projection = this.mapMatching.getProjection(this.gnssPosition);
+                const projection = this.mapMatching.getProjection(this.gnssPosition, true, true);
 
                 if (projection && projection.projection) {
 
@@ -193,7 +193,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
             }
 
             let startEdge;
-            if (itinerary.firstEdge.getLength() <= MM_GNSS_DIST) {
+            if (itinerary.firstEdge.length <= MM_GNSS_DIST) {
                 startEdge = itinerary.firstEdge;
             } else {
                 startEdge = itinerary.secondEdge;
@@ -201,7 +201,7 @@ class GnssWifiPdrProvider extends MapMatchingProvider {
             const startPoint = WGS84UserPosition.fromWGS84(startEdge.node1);
             startPoint.alt = Constants.DEFAULT_ALTITUDE;
             this.pdrProvider.setPosition(startPoint);
-            this.pdrProvider.setStepDetectionLockerOrientation(startEdge.getBearing());
+            this.pdrProvider.setStepDetectionLockerOrientation(startEdge.bearing);
         }
 
     }

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

@@ -1,7 +1,7 @@
 import noop from 'lodash.noop';
 
 import {
-    Constants as GeoConstants, Itinerary, WGS84UserPosition, WGS84
+    Constants as GeoConstants, Itinerary, WGS84, WGS84UserPosition
 } from '@wemap/geo';
 import {
     rad2deg, Quaternion
@@ -255,7 +255,7 @@ class PdrProvider extends MapMatchingProvider {
             return newPositionWithoutMM;
         }
 
-        const projection = this.mapMatching.getProjection(newPositionWithoutMM);
+        const projection = this.mapMatching.getProjection(newPositionWithoutMM, true, true);
 
         if (!projection || !projection.projection) {
             return newPositionWithoutMM;
@@ -314,14 +314,15 @@ class PdrProvider extends MapMatchingProvider {
             throw new Error('Empty itinerary');
         }
 
-        if (itinerary.firstEdge.getLength() > LO_SEGMENT_SIZE) {
-            return itinerary.firstEdge.getBearing();
+        const edgeAt = itinerary.getEdgeAt(LO_SEGMENT_SIZE);
+        if (edgeAt) {
+            return edgeAt.bearing;
         }
 
         if (itinerary.length < 2) {
             throw new Error('Itinerary is too short');
         }
-        return itinerary.secondEdge.getBearing();
+        return itinerary.secondEdge.bearing;
     }
 
     setStepDetectionLockerOrientation(orientation) {