@wemap/osm 0.1.1 → 0.2.1

package/assets/itinerary-osrm.json

@@ -0,0 +1 @@
+{"code":"Ok","routes":[{"geometry":{"coordinates":[[3.89678,43.600032],[3.896532,43.600216],[3.896247,43.600432],[3.896188,43.600488],[3.896151,43.600523],[3.895937,43.600726],[3.895824,43.600837],[3.89566,43.601048],[3.895605,43.601131],[3.895549,43.601243],[3.895511,43.601337],[3.895492,43.601413],[3.895485,43.601506],[3.89549,43.601585],[3.895549,43.601785],[3.895413,43.60181],[3.895353,43.601826],[3.895305,43.601628],[3.8953,43.60157],[3.89532,43.60143]],"type":"LineString"},"legs":[{"steps":[{"intersections":[{"out":0,"entry":[true],"bearings":[316],"location":[3.89678,43.600032]}],"driving_side":"right","geometry":{"coordinates":[[3.89678,43.600032],[3.896532,43.600216],[3.896247,43.600432],[3.896188,43.600488],[3.896151,43.600523],[3.895937,43.600726],[3.895824,43.600837],[3.89566,43.601048],[3.895605,43.601131],[3.895549,43.601243],[3.895511,43.601337],[3.895492,43.601413],[3.895485,43.601506],[3.89549,43.601585],[3.895549,43.601785]],"type":"LineString"},"mode":"walking","duration":165.6,"maneuver":{"bearing_after":316,"type":"depart","modifier":"right","bearing_before":0,"location":[3.89678,43.600032]},"weight":165.6,"distance":230.1,"name":""},{"intersections":[{"out":2,"location":[3.895549,43.601785],"bearings":[15,195,285],"entry":[true,false,true],"in":1}],"driving_side":"right","geometry":{"coordinates":[[3.895549,43.601785],[3.895413,43.60181],[3.895353,43.601826]],"type":"LineString"},"mode":"walking","duration":11.8,"maneuver":{"bearing_after":284,"type":"turn","modifier":"left","bearing_before":11,"location":[3.895549,43.601785]},"weight":11.8,"distance":16.5,"name":""},{"intersections":[{"out":2,"location":[3.895353,43.601826],"bearings":[15,105,195,285],"entry":[true,false,true,true],"in":1}],"driving_side":"right","geometry":{"coordinates":[[3.895353,43.601826],[3.895305,43.601628],[3.8953,43.60157],[3.89532,43.60143]],"type":"LineString"},"mode":"walking","duration":32.2,"maneuver":{"bearing_after":189,"type":"turn","modifier":"left","bearing_before":286,"location":[3.895353,43.601826]},"weight":32.2,"distance":44.5,"name":""},{"intersections":[{"in":0,"entry":[true],"bearings":[354],"location":[3.89532,43.60143]}],"driving_side":"right","geometry":{"coordinates":[[3.89532,43.60143],[3.89532,43.60143]],"type":"LineString"},"mode":"walking","duration":0,"maneuver":{"bearing_after":0,"location":[3.89532,43.60143],"bearing_before":174,"type":"arrive"},"weight":0,"distance":0,"name":""}],"distance":291,"duration":209.6,"summary":"","weight":209.6}],"distance":291,"duration":209.6,"weight_name":"duration","weight":209.6}],"waypoints":[{"hint":"4dUHgOOrJ4DOAAAAnwAAAKoFAAB5AwAAzgAAAJ8AAACqBQAAeQMAAAIAAADMdTsAoEiZAjd2OwDrSJkCDQB_CA61bn8=","name":"","location":[3.89678,43.600032]},{"hint":"3vZTgejVB4AEAAAAcgAAAF8AAADQAAAABAAAAHIAAABfAAAA0AAAAAIAAAAYcDsAFk6ZAhdwOwAWTpkCAgAvFg61bn8=","name":"","location":[3.89532,43.60143]}]}

package/package.json

@@ -11,7 +11,7 @@
         "directory": "packages/osm"
     },
     "name": "@wemap/osm",
-    "version": "0.1.1",
+    "version": "0.2.1",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -26,10 +26,10 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/geo": "^0.2.1",
+        "@wemap/geo": "^0.3.1",
         "@wemap/logger": "^0.1.5",
         "lodash.isnumber": "^3.0.3",
         "sax": "^1.2.4"
     },
-    "gitHead": "dc8de098a46002417ccf368038a1e093e42f1a8e"
+    "gitHead": "7b84c9d55646761f75f19235a15be8a1b73b3dbf"
 }

package/src/network/OsmNetwork.js

@@ -39,8 +39,6 @@ class OsmNetwork extends Network {
                 edge.data = way;
                 edge.level = way.level;
                 networkModel.edges.push(edge);
-                firstNode.edges.push(edge);
-                secondNode.edges.push(edge);
 
                 firstNode = secondNode;
             }
@@ -54,6 +52,9 @@ class OsmNetwork extends Network {
         return this.nodes.find(node => node.data.id === id);
     }
 
+    getNodeByName(name) {
+        return this.nodes.find(node => node.data.tags.name === name);
+    }
 
     getEdgeById(id) {
         return this.edges.find(edge => edge.data.id === id);

package/src/network/OsmRouter.spec.js

@@ -1,22 +1,20 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
+/* eslint-disable max-statements */
+import { expect } from 'chai';
 import fs from 'fs';
 import path from 'path';
 
-import {
-    WGS84, Level
-} from '@wemap/geo';
+import { Node } from '@wemap/geo';
 
 import OsmParser from '../model/OsmParser';
 import OsmRouter from './OsmRouter';
 import OsmNetwork from './OsmNetwork';
 
-
-const expect = chai.expect;
-chai.use(chaiAlmost());
+import {
+    itineraryStart, itineraryEnd
+} from '../../../geo/tests/CommonTest';
 
 
-describe('OsmRouter', () => {
+describe('OsmRouter - Multi-level itinerary', () => {
 
     const filePath = path.resolve(__dirname, '../../assets/bureaux-wemap-montpellier-network.osm');
     const osmXmlString = fs.readFileSync(filePath, 'utf8');
@@ -25,60 +23,46 @@ describe('OsmRouter', () => {
     const networkModel = OsmNetwork.fromOsmModel(osmModel);
     const router = new OsmRouter(networkModel);
 
-    it('Multi-level itinerary', () => {
 
-        const start = new WGS84(43.6092754, 3.8842306);
-        start.level = Level.fromString(2);
+    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
 
-        const end = new WGS84(43.6092602, 3.8842669);
-        end.level = Level.fromString(1);
+    const p = [];
+    it('Search for nodes', () => {
+        for (let i = 1; i <= 16; i++) {
+            p[i] = networkModel.getNodeByName('p' + i);
+            expect(p[i]).instanceOf(Node);
+        }
+    });
 
-        const itinerary = router.getShortestPath(start, end);
+    it('Router return shortest path', () => {
 
         expect(itinerary.nodes.length).equal(11);
 
-        expect(itinerary.nodes[1].data.tags.name).equal('p7');
-        expect(itinerary.nodes[2].data.tags.name).equal('p8');
-        expect(itinerary.nodes[3].data.tags.name).equal('p9');
-        expect(itinerary.nodes[4].data.tags.name).equal('p10');
-        expect(itinerary.nodes[5].data.tags.name).equal('p11');
-        expect(itinerary.nodes[6].data.tags.name).equal('p12');
-        expect(itinerary.nodes[7].data.tags.name).equal('p13');
-        expect(itinerary.nodes[8].data.tags.name).equal('p14');
-        expect(itinerary.nodes[9].data.tags.name).equal('p15');
-        expect(itinerary.nodes[10].data.tags.name).equal('p16');
-
+        for (let i = 1; i <= 10; i++) {
+            expect(itinerary.nodes[i].data).equal(p[i + 6].data);
+        }
 
-        /**
-         * Verify if itinerary is ordered
-         */
+    });
 
-        for (let i = 0; i < itinerary.nodes.length; i++) {
-            const node = itinerary.nodes[i];
+    it('Verify steps', () => {
 
-            expect(node.edges.length).equal(i === 0 || i === itinerary.nodes.length - 1 ? 1 : 2);
+        const steps = itinerary.steps;
+        expect(steps.length).equal(10);
 
-            if (i !== itinerary.nodes.length - 1) {
-                expect(itinerary.edges[i].node1).equal(node);
-                expect(itinerary.edges[i].node2).equal(itinerary.nodes[i + 1]);
-            }
+        expect(steps[0].nodes[1].data).equal(p[7].data);
+        expect(steps[0].nodes[2].data).equal(p[8].data);
 
+        for (let i = 2; i <= 9; i++) {
+            expect(steps[i - 1].nodes[0].data).equal(p[i + 6].data);
+            expect(steps[i - 1].nodes[1].data).equal(p[i + 7].data);
         }
 
+        expect(steps[9].nodes[0].data).equal(p[16].data);
     });
 
 
     it('No route itinerary', () => {
-
-        const start = new WGS84(43.6092754, 3.8842306);
-        start.level = Level.fromString(2);
-
-        const end = new WGS84(43.6092602, 3.8842669);
-        end.level = Level.fromString(1);
-
-        const itinerary = router.getShortestPath(start, end, { useStairs: false });
-
-        expect(itinerary).is.undefined;
-
+        const itineraryWithoutStairs = router.getShortestPath(itineraryStart, itineraryEnd, { useStairs: false });
+        expect(itineraryWithoutStairs).is.undefined;
     });
 });

package/src/osrm/OsrmUtils.js

@@ -1,99 +1,87 @@
 /* eslint-disable max-statements */
-
 import {
-    Network, WGS84
+    WGS84, Itinerary, Node, Edge, Level
 } from '@wemap/geo';
-import { Utils as MathUtils } from '@wemap/maths';
+import {
+    rad2deg, Utils as MathUtils
+} from '@wemap/maths';
 
 
 class OsrmUtils {
 
-    static itineraryToOsrmJson(itinerary, altitudeFactor = 1) {
-
-        const {
-            edges, nodes, start, end, length
-        } = itinerary;
+    static wgs84ToJson(wgs84) {
+        const output = [wgs84.lng, wgs84.lat];
+        if (wgs84.level) {
+            output.push(wgs84.level.toString());
+        }
+        return output;
+    }
 
-        const coordinates = [];
-        const steps = [];
+    static jsonToWgs84(json) {
+        const output = new WGS84(json[1], json[0]);
+        if (json.length > 2) {
+            output.level = Level.fromString(json[2]);
+        }
+        return output;
+    }
 
-        nodes.forEach(node => {
-            const nodeCoordsModified = node.coords.clone();
-            if (altitudeFactor !== 1 && nodeCoordsModified.level) {
-                nodeCoordsModified.level.multiplyBy(altitudeFactor);
-            }
-            coordinates.push(nodeCoordsModified.toJson(WGS84.FORMAT_LNG_LAT_STRLEVEL));
-        });
+    static nodesToJsonCoords(nodes) {
+        return nodes.map(node => OsrmUtils.wgs84ToJson(node.coords));
+    }
 
-        let previousBearing;
+    static itineraryToOsrmJson(itinerary) {
 
-        for (let i = -1; i < nodes.length; i++) {
+        const itinerarySteps = itinerary.steps;
+        const osrmSteps = [];
 
-            let node;
-            let nextNode;
+        const lastStepId = itinerarySteps.length - 1;
+        for (let i = 0; i <= lastStepId; i++) {
 
-            let nodeCoords;
-            let nodeTags;
-            let nextNodeCoords;
-            let nextEdgeTags;
+            const {
+                nodes, length, nextEdgeData, nextBearing, previousBearing, angle, node, duration
+            } = itinerarySteps[i];
 
-            if (i === -1) {
-                nodeCoords = start;
-                previousBearing = 0;
-            } else {
-                node = nodes[i];
-                nodeCoords = node.coords;
-                nodeTags = node.tags;
-            }
+            const edgeData = i !== lastStepId ? nextEdgeData : itinerary.edges[lastStepId];
+            const name = edgeData && edgeData.tags ? nextEdgeData.tags.name : '';
 
-            if (i + 1 === nodes.length) {
-                nextNodeCoords = end;
-            } else {
-                nextNode = nodes[i + 1];
-                nextNodeCoords = nextNode.coords;
-            }
+            let type = i === 0 ? 'depart' : 'turn';
+            type = i === lastStepId ? 'arrive' : type;
 
-            if (node && nextNode) {
-                const edge = Network.getEdgeByNodes(edges, nextNode, node);
-                nextEdgeTags = edge.data.tags;
-            }
+            const bearingBefore = MathUtils.positiveMod(i === 0 ? 0 : previousBearing, 2 * Math.PI);
+            const bearingAfter = MathUtils.positiveMod(i === lastStepId ? 0 : nextBearing, 2 * Math.PI);
 
-            const bearing = MathUtils.positiveMod(nodeCoords.bearingTo(nextNodeCoords), 2 * Math.PI);
-            const distance = nodeCoords.distanceTo(nextNodeCoords);
-            const angle = MathUtils.positiveMod(MathUtils.diffAngle(previousBearing, bearing + Math.PI), 2 * Math.PI) * 180 / Math.PI;
-            const modifier = i === -1 ? 'start' : OsrmUtils.getModifierFromAngle(angle);
+            const osrmStep = {
+                geometry: {
+                    type: 'LineString',
+                    coordinates: OsrmUtils.nodesToJsonCoords(nodes)
+                },
+                distance: length,
+                duration,
+                name,
+                maneuver: {
+                    bearing_before: rad2deg(bearingBefore),
+                    bearing_after: rad2deg(bearingAfter),
+                    location: OsrmUtils.wgs84ToJson(node.coords),
+                    type
+                },
+                wemap: {}
+            };
 
-            const nodeCoordsModified = nodeCoords.clone();
-            if (altitudeFactor !== 1 && nodeCoordsModified.level) {
-                nodeCoordsModified.level.multiplyBy(altitudeFactor);
+            if (node.data && node.data.tags) {
+                osrmStep.wemap.nodeTags = node.data.tags;
             }
 
-            steps.push({
-                maneuver: {
-                    bearing_before: previousBearing * 180 / Math.PI,
-                    bearing_after: bearing * 180 / Math.PI,
-                    location: nodeCoordsModified.toJson(WGS84.FORMAT_LNG_LAT_STRLEVEL),
-                    modifier
-                },
-                distance,
-                nodeTags,
-                nextEdgeTags
-            });
+            if (i !== lastStepId) {
+                osrmStep.wemap.nextEdgeTags = nextEdgeData.tags;
+            }
 
-            previousBearing = bearing;
-        }
+            // The first modifier is not mandatory by OSRM.
+            // if (i !== 0) {
+            osrmStep.maneuver.modifier = OsrmUtils.getModifierFromAngle(angle);
+            // }
 
-        const endNodeCoordsModified = end.clone();
-        if (altitudeFactor !== 1 && endNodeCoordsModified.level) {
-            endNodeCoordsModified.level.multiplyBy(altitudeFactor);
+            osrmSteps.push(osrmStep);
         }
-        steps.push({maneuver: {
-            bearing_before: previousBearing * 180 / Math.PI,
-            bearing_after: 0,
-            location: endNodeCoordsModified.toJson(WGS84.FORMAT_LNG_LAT_STRLEVEL),
-            modifier: 'arrive'
-        }});
-
 
         return {
             'code': 'Ok',
@@ -101,17 +89,17 @@ class OsrmUtils {
                 {
                     'geometry': {
                         'type': 'LineString',
-                        'coordinates': coordinates
+                        'coordinates': OsrmUtils.nodesToJsonCoords(itinerary.nodes)
                     },
                     'legs': [
                         {
-                            'duration': itinerary.getDuration(),
-                            'distance': length,
-                            'steps': steps
+                            'duration': itinerary.duration,
+                            'distance': itinerary.length,
+                            'steps': osrmSteps
                         }
                     ],
-                    'distance': length,
-                    'duration': itinerary.getDuration(),
+                    'distance': itinerary.length,
+                    'duration': itinerary.duration,
                     'weight_name': 'routability',
                     'weight': 0
                 }
@@ -125,7 +113,10 @@ class OsrmUtils {
     }
 
 
-    static getModifierFromAngle(angle) {
+    static getModifierFromAngle(_angle) {
+
+        const angle = MathUtils.positiveMod(rad2deg(_angle), 360);
+
         if (angle > 0 && angle < 60) {
             return 'sharp right';
         }
@@ -149,6 +140,59 @@ class OsrmUtils {
         }
         return 'u turn';
     }
+
+    /**
+     * Generate Itinerary from OSRM JSON, start and end.
+     * @param {Object} json JSON file provided by OSRM.
+     * @param {Array} start Array of <lng, lat[, level]>
+     * @param {Array} end Array of <lng, lat[, level]>
+     */
+    static createItineraryFromJson(json, start, end) {
+        const itinerary = new Itinerary();
+
+        itinerary.start = OsrmUtils.jsonToWgs84(start);
+        itinerary.end = OsrmUtils.jsonToWgs84(end);
+
+        const {
+            legs, geometry
+        } = json.routes[0];
+        const { steps } = legs[0];
+
+        let previousNode;
+        const { coordinates } = geometry;
+        for (let i = 0; i < coordinates.length; i++) {
+            const node = new Node(OsrmUtils.jsonToWgs84(coordinates[i]));
+            itinerary.nodes.push(node);
+
+            if (previousNode) {
+                const edge = new Edge(previousNode, node);
+                edge.level = Level.union(previousNode.coords.level, node.coords.level);
+                itinerary.edges.push(edge);
+            }
+
+            previousNode = node;
+        }
+
+        for (let i = 0; i < steps.length; i++) {
+            const step = steps[i];
+            if (step.wemap) {
+                const stepLocation = step.maneuver.location;
+                const location = OsrmUtils.jsonToWgs84(stepLocation);
+                const existingNode = itinerary.getNodeByCoords(location);
+
+                if (step.wemap.nodeTags) {
+                    existingNode.data = { tags: step.wemap.nodeTags };
+                }
+
+                if (step.wemap.nextEdgeTags) {
+                    const nextEdge = existingNode.edges[i === 0 ? 0 : 1];
+                    nextEdge.data = { tags: step.wemap.nextEdgeTags };
+                }
+            }
+        }
+
+        return itinerary;
+    }
 }
 
 export default OsrmUtils;

package/src/osrm/OsrmUtils.spec.js

@@ -0,0 +1,168 @@
+/* eslint-disable max-statements */
+import { expect } from 'chai';
+import fs from 'fs';
+import path from 'path';
+
+import { Level } from '@wemap/geo';
+
+import OsmParser from '../model/OsmParser';
+import OsmRouter from '../network/OsmRouter';
+import OsmNetwork from '../network/OsmNetwork';
+import OsrmUtils from './OsrmUtils';
+
+import {
+    itineraryStart, itineraryEnd
+} from '../../../geo/tests/CommonTest';
+
+describe('OsmRouter - Multi-level itinerary', () => {
+
+
+    it('OSRM JSON to Itinerary', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-osrm.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+
+        const json = JSON.parse(fileString);
+
+        const start = [3.8968868999999997, 43.6001066];
+        const end = [3.895319, 43.601430];
+
+        const itinerary = OsrmUtils.createItineraryFromJson(json, start, end);
+
+        expect(json.routes[0].geometry.coordinates.length).equal(itinerary.nodes.length);
+        expect(itinerary.nodes.length).equal(itinerary.edges.length + 1);
+
+    });
+
+    let osrmWemapJson, wemapItinerary;
+    it('Itinerary to OSRM JSON', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/bureaux-wemap-montpellier-network.osm');
+        const osmXmlString = fs.readFileSync(filePath, 'utf8');
+
+        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        const networkModel = OsmNetwork.fromOsmModel(osmModel);
+        const router = new OsmRouter(networkModel);
+
+        wemapItinerary = router.getShortestPath(itineraryStart, itineraryEnd);
+
+        osrmWemapJson = OsrmUtils.itineraryToOsrmJson(wemapItinerary);
+        const itinerarySteps = wemapItinerary.steps;
+
+        const {
+            geometry, legs
+        } = osrmWemapJson.routes[0];
+
+        const p = [];
+        for (let i = 1; i <= 16; i++) {
+            p[i] = networkModel.getNodeByName('p' + i);
+        }
+
+
+        /**
+         * Verify if JSON geometry corresponds to Itinerary points
+         */
+        const { coordinates } = geometry;
+        expect(coordinates.length).equal(11);
+        for (let i = 1; i < 11; i++) {
+            expect(p[i + 6].coords.equalsTo(OsrmUtils.jsonToWgs84(coordinates[i]))).true;
+        }
+
+        /**
+         * Verify location, type and modifier of each step
+         */
+        const { steps } = legs[0];
+        for (let i = 0; i < steps.length; i++) {
+            const {
+                location, type
+            } = steps[i].maneuver;
+            expect(itinerarySteps[i].node.coords.equalsTo(OsrmUtils.jsonToWgs84(location))).true;
+
+            let expectedType;
+            switch (i) {
+            case 0:
+                expectedType = 'depart';
+                break;
+            case steps.length - 1:
+                expectedType = 'arrive';
+                break;
+            default:
+                expectedType = 'turn';
+            }
+            expect(type).equals(expectedType);
+        }
+
+        // The first modifier is not mandatory by OSRM.
+        expect(steps[0].maneuver.modifier).equals('left');
+        expect(steps[0].distance).be.closeTo(2.33, 0.01);
+        expect(steps[0].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+        expect(steps[1].maneuver.modifier).equals('right');
+        expect(steps[1].distance).be.closeTo(1.76, 0.01);
+        expect(steps[1].maneuver.bearing_after).be.closeTo(56.90, 0.01);
+
+        expect(steps[2].maneuver.modifier).equals('left');
+        expect(steps[2].distance).be.closeTo(1.15, 0.01);
+        expect(steps[2].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+        expect(steps[3].maneuver.modifier).equals('left');
+        expect(steps[3].distance).be.closeTo(5.95, 0.01);
+        expect(steps[3].maneuver.bearing_after).be.closeTo(281.93, 0.01);
+
+        expect(steps[4].maneuver.modifier).equals('right');
+        expect(steps[4].distance).be.closeTo(4.51, 0.01);
+        expect(steps[4].maneuver.bearing_after).be.closeTo(12.22, 0.01);
+
+        expect(steps[5].maneuver.modifier).equals('right');
+        expect(steps[5].distance).be.closeTo(1.72, 0.01);
+        expect(steps[5].maneuver.bearing_after).be.closeTo(102.22, 0.01);
+
+        expect(steps[6].maneuver.modifier).equals('right');
+        expect(steps[6].distance).be.closeTo(4.49, 0.01);
+        expect(steps[6].maneuver.bearing_after).be.closeTo(192.22, 0.01);
+
+        expect(steps[7].maneuver.modifier).equals('left');
+        expect(steps[7].distance).be.closeTo(4.23, 0.01);
+        expect(steps[7].maneuver.bearing_after).be.closeTo(102.00, 0.01);
+
+        expect(steps[8].maneuver.modifier).equals('right');
+        expect(steps[8].distance).be.closeTo(5.03, 0.01);
+        expect(steps[8].maneuver.bearing_after).be.closeTo(191.75, 0.01);
+
+        expect(steps[9].maneuver.modifier).equals('left');
+        expect(steps[9].distance).be.closeTo(0, 0.01);
+        expect(steps[9].maneuver.bearing_after).be.closeTo(0, 0.01);
+
+    });
+
+
+    it('Itinerary to OSRM JSON to Itinerary', () => {
+
+        const json = osrmWemapJson;
+
+        const start = OsrmUtils.wgs84ToJson(itineraryStart);
+        const end = OsrmUtils.wgs84ToJson(itineraryEnd);
+
+        const itinerary = OsrmUtils.createItineraryFromJson(json, start, end);
+
+        expect(itinerary.nodes.length).equal(wemapItinerary.nodes.length);
+        for (let i = 0; i < itinerary.nodes.length; i++) {
+            const itineraryNode = itinerary.nodes[i];
+            const wemapItineraryNode = wemapItinerary.nodes[i];
+            expect(itineraryNode.coords.equalsTo(wemapItineraryNode.coords)).true;
+        }
+
+        expect(itinerary.edges.length).equal(wemapItinerary.edges.length);
+        for (let i = 0; i < itinerary.edges.length; i++) {
+            const itineraryEdge = itinerary.edges[i];
+            const wemapItineraryEdge = wemapItinerary.edges[i];
+            const firstNode = wemapItineraryEdge[wemapItinerary._edgesDirectionReversed[i] ? 'node2' : 'node1'];
+            const secondNode = wemapItineraryEdge[wemapItinerary._edgesDirectionReversed[i] ? 'node1' : 'node2'];
+            expect(itineraryEdge.node1.coords.equalsTo(firstNode.coords)).true;
+            expect(itineraryEdge.node2.coords.equalsTo(secondNode.coords)).true;
+            expect(Level.equalsTo(itineraryEdge.level, wemapItineraryEdge.level)).true;
+        }
+
+    });
+
+});

package/src/osrm/OsrmItinerary.js

@@ -1,5 +0,0 @@
-class OsrmItinerary {
-
-}
-
-export default OsrmItinerary;