@wemap/osm 0.3.6 → 1.0.0

package/package.json

@@ -11,13 +11,13 @@
         "directory": "packages/osm"
     },
     "name": "@wemap/osm",
-    "version": "0.3.6",
+    "version": "1.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
     "homepage": "https://github.com/wemap/wemap-utils-js#readme",
     "scripts": {
-        "test": "mocha -r esm \\\"src/**/*.spec.js\\\""
+        "test": "mocha -r esm \"src/**/*.spec.js\""
     },
     "keywords": [
         "utils",
@@ -26,11 +26,11 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/geo": "^1.0.3",
-        "@wemap/graph": "^1.0.3",
+        "@wemap/geo": "^1.0.4",
+        "@wemap/graph": "^1.0.5",
         "@wemap/logger": "^0.1.7",
         "lodash.isnumber": "^3.0.3",
         "sax": "^1.2.4"
     },
-    "gitHead": "ecc9848b178778edd77176fc4c329faccdde032a"
+    "gitHead": "cab48c01923850987968f072a8f7075a34b3cc32"
 }

package/src/osrm/OsrmUtils.js

@@ -3,11 +3,12 @@ import {
     Level, WGS84
 } from '@wemap/geo';
 import {
-    Edge, Node, Itinerary
+    Edge, Node, Itinerary, Step, Network
 } from '@wemap/graph';
 import {
-    rad2deg, Utils as MathUtils
+    rad2deg, Utils as MathUtils, diffAngle, deg2rad
 } from '@wemap/maths';
+import Logger from '@wemap/logger';
 
 
 class OsrmUtils {
@@ -164,6 +165,9 @@ class OsrmUtils {
         } = json.routes[0];
         const { steps } = legs[0];
 
+        /**
+         * Create nodes and edges from geometry
+         */
         let previousNode;
         const { coordinates } = geometry;
         for (let i = 0; i < coordinates.length; i++) {
@@ -179,48 +183,95 @@ class OsrmUtils {
             previousNode = node;
         }
 
-        for (let i = 0; i < steps.length; i++) {
-            const step = steps[i];
+        if (steps && steps.length > 0) {
+            OsrmUtils.parseSteps(itinerary, steps);
+        }
 
-            const nodeData = {};
-            const nextEdgeData = {};
+        return itinerary;
+    }
 
-            if (step.wemap) {
-                if (step.wemap.nodeTags) {
-                    nodeData.tags = step.wemap.nodeTags;
-                }
+    static parseSteps(itinerary, jsonSteps) {
 
-                if (step.wemap.nextEdgeTags) {
-                    nextEdgeData.osmTags = step.wemap.nextEdgeTags;
-                    if (nextEdgeData.osmTags.name) {
-                        nextEdgeData.name = nextEdgeData.osmTags.name;
-                    }
-                }
-            }
+        itinerary._steps = [];
+        itinerary._nextStepsIndexes = [];
+
+        for (let i = 0; i < jsonSteps.length; i++) {
+            const jsonStep = jsonSteps[i];
+
+            const step = new Step();
+            step.number = i + 1;
+            step.firstStep = i === 0;
+            step.lastStep = i === jsonSteps.length - 1;
+
+
+            /**
+             * Add nodes and edges to step
+             */
+            step.nodes = [];
+            step.edges = [];
 
-            if (step.name) {
-                nextEdgeData.name = step.name;
+            let previousNode;
+            let { coordinates } = jsonStep.geometry;
+
+            // The OSRM last step is twice the last node. So, remove the second.
+            if (step.lastStep) {
+                coordinates = [coordinates[0]];
             }
+            coordinates.forEach(coords => {
+                const wgs84 = OsrmUtils.jsonToWgs84(coords);
+                const node = itinerary.getNodeByCoords(wgs84);
+                if (!node) {
+                    Logger.error('Cannot parse this itinerary coordinates');
+                    return;
+                }
+                step.nodes.push(node);
 
-            const hasNodeData = Object.keys(nodeData).length !== 0;
-            const hasNextEdgeData = Object.keys(nextEdgeData).length !== 0;
-            if (hasNodeData || hasNextEdgeData) {
-                const stepLocation = step.maneuver.location;
-                const location = OsrmUtils.jsonToWgs84(stepLocation);
-                const existingNode = itinerary.getNodeByCoords(location);
+                const isLastNode = coordinates[coordinates.length - 1] === coords;
+                if (!isLastNode || step.lastStep) {
+                    itinerary._nextStepsIndexes.push(i);
+                }
 
-                if (hasNodeData) {
-                    existingNode.data = nodeData;
+                if (previousNode) {
+                    const edge = Network.getEdgeByNodes(previousNode.edges, previousNode, node);
+                    step.edges.push(edge);
                 }
 
-                if (hasNextEdgeData && i !== steps.length - 1) {
-                    const nextEdge = existingNode.edges[i === 0 ? 0 : 1];
-                    nextEdge.data = nextEdgeData;
+                previousNode = node;
+            });
+
+            /**
+             * Add common fields
+             */
+            step.previousBearing = step.firstStep
+                ? itinerary.start.bearingTo(itinerary.nodes[0].coords)
+                : deg2rad(jsonStep.maneuver.bearing_before);
+            step.nextBearing = step.lastStep
+                ? previousNode.coords.bearingTo(itinerary.end)
+                : deg2rad(jsonStep.maneuver.bearing_after);
+            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+            step.name = jsonStep.name;
+
+            /**
+             * Wemap fields
+             */
+            if (jsonStep.wemap) {
+                const firstNode = itinerary.nodes[0];
+                if (jsonStep.wemap.nodeTags && firstNode) {
+                    firstNode.data = { tags: jsonStep.wemap.nodeTags };
+                }
+
+                const firstEdge = itinerary.edges[0];
+                if (jsonStep.wemap.nextEdgeTags && firstEdge) {
+                    firstEdge.data = {
+                        tags: jsonStep.wemap.nextEdgeTags,
+                        name: jsonStep.name
+                    };
+
                 }
             }
-        }
 
-        return itinerary;
+            itinerary._steps.push(step);
+        }
     }
 }
 

package/src/osrm/OsrmUtils.spec.js

@@ -3,7 +3,9 @@ import { expect } from 'chai';
 import fs from 'fs';
 import path from 'path';
 
-import { Level } from '@wemap/geo';
+import {
+    Level, WGS84
+} from '@wemap/geo';
 
 import OsmParser from '../model/OsmParser';
 import OsmRouter from '../network/OsmRouter';
@@ -31,7 +33,67 @@ describe('OsrmUtils', () => {
 
         expect(json.routes[0].geometry.coordinates.length).equal(itinerary.nodes.length);
         expect(itinerary.nodes.length).equal(itinerary.edges.length + 1);
-
+        expect(itinerary.nodes.length).equal(19);
+
+        const { steps } = itinerary;
+        expect(steps.length).equal(5);
+
+        let step;
+        step = steps[0];
+        expect(WGS84.equalsTo(step.location, new WGS84(43.600777, 3.875607))).true;
+        expect(OsrmUtils.getModifierFromAngle(step.angle)).equals('left');
+        expect(step.nodes.length).equals(6);
+        expect(step.edges.length).equals(5);
+        expect(step.firstStep).true;
+        expect(step.lastStep).false;
+        expect(step.name).equals('');
+
+        step = steps[1];
+        expect(WGS84.equalsTo(step.location, new WGS84(43.599881, 3.876396))).true;
+        expect(OsrmUtils.getModifierFromAngle(step.angle)).equals('right');
+        expect(step.nodes.length).equals(12);
+        expect(step.edges.length).equals(11);
+        expect(step.firstStep).false;
+        expect(step.lastStep).false;
+        expect(step.name).equals('Boulevard Vieussens');
+
+        step = steps[2];
+        expect(WGS84.equalsTo(step.location, new WGS84(43.599577, 3.874655))).true;
+        expect(OsrmUtils.getModifierFromAngle(step.angle)).equals('left');
+        expect(step.nodes.length).equals(2);
+        expect(step.edges.length).equals(1);
+        expect(step.firstStep).false;
+        expect(step.lastStep).false;
+        expect(step.name).equals('Impasse Bizeray');
+
+        step = steps[3];
+        expect(WGS84.equalsTo(step.location, new WGS84(43.599063, 3.874623))).true;
+        expect(OsrmUtils.getModifierFromAngle(step.angle)).equals('right');
+        expect(step.nodes.length).equals(2);
+        expect(step.edges.length).equals(1);
+        expect(step.firstStep).false;
+        expect(step.lastStep).false;
+        expect(step.name).equals('Rue du Docteur Louis Perrier');
+
+        step = steps[4];
+        expect(WGS84.equalsTo(step.location, new WGS84(43.59906, 3.873865))).true;
+        expect(OsrmUtils.getModifierFromAngle(step.angle)).equals('left');
+        expect(step.nodes.length).equals(1);
+        expect(step.edges.length).equals(0);
+        expect(step.firstStep).false;
+        expect(step.lastStep).true;
+        expect(step.name).equals('Rue du Docteur Louis Perrier');
+
+        expect(itinerary._nextStepsIndexes.length).equals(itinerary.nodes.length);
+        for (let i = 0; i <= 4; i++) {
+            expect(itinerary._nextStepsIndexes[i]).equals(0);
+        }
+        for (let i = 5; i <= 15; i++) {
+            expect(itinerary._nextStepsIndexes[i]).equals(1);
+        }
+        expect(itinerary._nextStepsIndexes[16]).equals(2);
+        expect(itinerary._nextStepsIndexes[17]).equals(3);
+        expect(itinerary._nextStepsIndexes[18]).equals(4);
     });
 
     let osrmWemapJson, wemapItinerary;
@@ -80,14 +142,14 @@ describe('OsrmUtils', () => {
 
             let expectedType;
             switch (i) {
-            case 0:
-                expectedType = 'depart';
-                break;
-            case steps.length - 1:
-                expectedType = 'arrive';
-                break;
-            default:
-                expectedType = 'turn';
+                case 0:
+                    expectedType = 'depart';
+                    break;
+                case steps.length - 1:
+                    expectedType = 'arrive';
+                    break;
+                default:
+                    expectedType = 'turn';
             }
             expect(type).equals(expectedType);
         }