@wemap/osm 2.7.6 → 2.7.8

package/src/network/OsmNetwork.spec.js

@@ -0,0 +1,103 @@
+/* eslint-disable max-statements */
+import { expect } from 'chai';
+import fs from 'fs';
+import path from 'path';
+
+import OsmParser from '../model/OsmParser';
+import OsmNetwork from './OsmNetwork';
+
+
+const loadFile = fileName => {
+    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
+    return fs.readFileSync(filePath, 'utf8');
+};
+
+describe('OsmNetwork - simple', () => {
+
+    let osmModel, osmNetwork;
+    const osmXmlString = loadFile('network-simple.osm');
+
+    it('Network creation', () => {
+
+        osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        osmNetwork = OsmNetwork.fromOsmModel(osmModel);
+
+        expect(osmNetwork.nodes.length).equals(3);
+        expect(osmNetwork.edges.length).equals(2);
+    });
+
+
+    it('Network creation - waySelectionFilter', () => {
+
+        const selectionNetwork = OsmNetwork.fromOsmModel(osmModel, () => true);
+
+        expect(selectionNetwork.nodes.length).equals(4);
+        expect(selectionNetwork.edges.length).equals(3);
+    });
+
+    it('Network creation - elevator', () => {
+
+        const elevatorModel = OsmParser.parseOsmXmlString(loadFile('network-elevator.osm'));
+        const elevatorNetwork = OsmNetwork.fromOsmModel(elevatorModel);
+
+        expect(elevatorNetwork.nodes.length).equals(7);
+        expect(elevatorNetwork.edges.length).equals(6);
+
+
+        const osmModel2 = OsmParser.parseOsmXmlString(`
+        <osm>
+            <node id='1' lat='43' lon='4'>
+                <tag k='highway' v='elevator' />
+                <tag k='level' v='0;1' />
+            </node>
+            <node id='2' lat='43' lon='3' />
+            <way id='3'>
+                <nd ref='1' />
+                <nd ref='2' />
+                <tag k='highway' v='footway' />
+                <tag k='level' v='0;1' />
+            </way>
+        </osm>
+        `);
+        expect(() => OsmNetwork.fromOsmModel(osmModel2)).throw(Error);
+    });
+
+
+    it('getNodeById', () => {
+        let node = osmNetwork.getNodeById(1);
+        expect(node).not.null;
+        expect(node.data.tags.name).equals('p1');
+
+        node = osmNetwork.getNodeById(5);
+        expect(node).undefined;
+    });
+
+
+    it('getNodeByName', () => {
+        let node = osmNetwork.getNodeByName('p1');
+        expect(node).not.undefined;
+
+        node = osmNetwork.getNodeByName('p5');
+        expect(node).undefined;
+    });
+
+    it('getEdgesById', () => {
+        let edges = osmNetwork.getEdgesById(101);
+        expect(edges.length).equals(2);
+        expect(edges[0].data.tags.name).equals('w1');
+        expect(edges[0].node1.data.tags.name).equals('p1');
+        expect(edges[0].node2.data.tags.name).equals('p2');
+        expect(edges[1].data.tags.name).equals('w1');
+        expect(edges[1].node1.data.tags.name).equals('p2');
+        expect(edges[1].node2.data.tags.name).equals('p3');
+
+        edges = osmNetwork.getEdgesById(3);
+        expect(edges.length).equals(0);
+    });
+
+    it('toDetailedString', () => {
+        expect(() => osmNetwork.toDetailedString()).not.throw(Error);
+    });
+});
+
+

package/src/network/OsmRouter.js

@@ -20,28 +20,26 @@ class OsmRouter extends GraphRouter {
         };
 
         const edgeWeightFn = edge => {
-            if (edge.data && edge.data.tags && edge.data.tags.highway === 'elevator') {
+            if (edge.data.tags.highway === 'elevator') {
                 return 30;
             }
             return Utils.getDurationFromLength(edge.length);
         };
 
         const acceptOneWayFn = (edge, reversed) => {
-            if (edge.data && edge.data.tags) {
-                const {
-                    oneway, highway, conveying
-                } = edge.data.tags;
-                if (reversed && (oneway === 'yes' || oneway === 'true' || oneway === '1')) {
+            const {
+                oneway, highway, conveying
+            } = edge.data.tags;
+            if (reversed && (oneway === 'yes' || oneway === 'true' || oneway === '1')) {
+                return false;
+            }
+            if (conveying && highway) {
+                if (conveying === 'forward' && reversed) {
+                    return false;
+                } if (conveying === 'backward' && !reversed) {
+                    return false;
+                } if (conveying === 'yes' && reversed) {
                     return false;
-                }
-                if (conveying && highway) {
-                    if (conveying === 'forward' && reversed) {
-                        return false;
-                    } if (conveying === 'backward' && !reversed) {
-                        return false;
-                    } if (conveying === 'yes' && reversed) {
-                        return false;
-                    }
                 }
             }
             return true;

package/src/network/OsmRouter.spec.js

@@ -12,9 +12,16 @@ import OsmParser from '../model/OsmParser';
 import OsmRouter from './OsmRouter';
 import OsmNetwork from './OsmNetwork';
 
-import {
-    itineraryStart, itineraryEnd
-} from '../../../graph/tests/CommonTest';
+const itineraryStart = new WGS84(43.6092754, 3.8842306, null, new Level(2));
+const itineraryEnd = new WGS84(43.6092602, 3.8842669, null, new Level(1));
+
+
+const loadNetwork = fileName => {
+    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
+    const osmXmlString = fs.readFileSync(filePath, 'utf8');
+    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+    return OsmNetwork.fromOsmModel(osmModel);
+};
 
 const verifyNodesOrder = (nodes, names) => {
     expect(nodes.length).equals(names.length);
@@ -32,14 +39,9 @@ const generateNodeNames = (start, end) =>
 
 describe('OsmRouter - Multi-level itinerary', () => {
 
-    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 networkModel = loadNetwork('bureaux-wemap-montpellier-network.osm');
     const router = new OsmRouter(networkModel);
 
-
     const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
 
     const p = [];
@@ -93,11 +95,7 @@ describe('OsmRouter - Multi-level itinerary', () => {
 
 describe('OsmRouter - One Way itinerary', () => {
 
-    const filePath = path.resolve(__dirname, '../../assets/one-way.osm');
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    const networkModel = OsmNetwork.fromOsmModel(osmModel);
+    const networkModel = loadNetwork('one-way.osm');
     const router = new OsmRouter(networkModel);
 
     it('do not use oneway', () => {
@@ -118,11 +116,7 @@ describe('OsmRouter - One Way itinerary', () => {
 
 describe('OsmRouter - Conveying', () => {
 
-    const filePath = path.resolve(__dirname, '../../assets/gare-de-lyon-extract.osm');
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-
-    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-    const networkModel = OsmNetwork.fromOsmModel(osmModel);
+    const networkModel = loadNetwork('gare-de-lyon-extract.osm');
     const router = new OsmRouter(networkModel);
 
     it('do not use oneway conveying', () => {
@@ -141,3 +135,24 @@ describe('OsmRouter - Conveying', () => {
 });
 
 
+describe('OsmRouter - Conveying - backward', () => {
+
+    const networkModel = loadNetwork('network-conveying-backward.osm');
+    const router = new OsmRouter(networkModel);
+
+    it('do not use oneway conveying', () => {
+
+        const start = networkModel.getNodeByName('p6');
+        const end = networkModel.getNodeByName('p13');
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(itinerary).is.not.undefined;
+        verifyNodesOrder(itinerary.nodes, ['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
+
+        const itineraryOtherWay = router.getShortestPath(end, start);
+        expect(itineraryOtherWay).is.not.undefined;
+        verifyNodesOrder(itineraryOtherWay.nodes, ['p13', 'p12', 'p9', 'p8', 'p6']);
+    });
+});
+
+

package/src/osrm/OsrmUtils.js

@@ -8,31 +8,10 @@ import {
 import {
     rad2deg, Utils as MathUtils, diffAngle, deg2rad
 } from '@wemap/maths';
-import Logger from '@wemap/logger';
 
 
 class OsrmUtils {
 
-    static wgs84ToJson(wgs84) {
-        const output = [wgs84.lng, wgs84.lat];
-        if (wgs84.level) {
-            output.push(wgs84.level.toString());
-        }
-        return output;
-    }
-
-    static jsonToWgs84(json) {
-        const output = new WGS84(json[1], json[0]);
-        if (json.length > 2) {
-            output.level = Level.fromString(json[2]);
-        }
-        return output;
-    }
-
-    static nodesToJsonCoords(nodes) {
-        return nodes.map(node => OsrmUtils.wgs84ToJson(node.coords));
-    }
-
     static itineraryToOsrmJson(itinerary) {
 
         const itinerarySteps = itinerary.steps;
@@ -117,42 +96,6 @@ class OsrmUtils {
         };
     }
 
-    static noRouteFoundJson(message) {
-        return {
-            'code': 'NoRoute',
-            message
-        };
-    }
-
-
-    static getModifierFromAngle(_angle) {
-
-        const angle = MathUtils.positiveMod(rad2deg(_angle), 360);
-
-        if (angle > 0 && angle < 60) {
-            return 'sharp right';
-        }
-        if (angle >= 60 && angle < 140) {
-            return 'right';
-        }
-        if (angle >= 140 && angle < 160) {
-            return 'slight right';
-        }
-        if (angle >= 160 && angle <= 200) {
-            return 'straight';
-        }
-        if (angle > 200 && angle <= 220) {
-            return 'slight left';
-        }
-        if (angle > 220 && angle <= 300) {
-            return 'left';
-        }
-        if (angle > 300 && angle < 360) {
-            return 'sharp left';
-        }
-        return 'u turn';
-    }
-
     /**
      * Generate Itinerary from OSRM JSON, start and end.
      * @param {Object} json JSON file provided by OSRM.
@@ -168,7 +111,6 @@ class OsrmUtils {
         const {
             legs, geometry
         } = json.routes[0];
-        const { steps } = legs[0];
 
         /**
          * Create nodes and edges from geometry
@@ -188,7 +130,8 @@ class OsrmUtils {
             previousNode = node;
         }
 
-        if (steps && steps.length > 0) {
+        if (legs && legs[0]) {
+            const { steps } = legs[0];
             OsrmUtils.parseSteps(itinerary, steps);
         }
 
@@ -226,8 +169,8 @@ class OsrmUtils {
                 const wgs84 = OsrmUtils.jsonToWgs84(coords);
                 const node = itinerary.getNodeByCoords(wgs84);
                 if (!node) {
-                    Logger.error('Cannot parse this itinerary coordinates');
-                    return;
+                    throw new Error('Cannot parse these step coordinates, '
+                    + 'they are not found in main itinerary: ' + wgs84.toString());
                 }
                 step.nodes.push(node);
 
@@ -282,6 +225,63 @@ class OsrmUtils {
             itinerary._steps.push(step);
         }
     }
+
+    static getModifierFromAngle(_angle) {
+
+        const angle = MathUtils.positiveMod(rad2deg(_angle), 360);
+
+        if (angle > 0 && angle < 60) {
+            return 'sharp right';
+        }
+        if (angle >= 60 && angle < 140) {
+            return 'right';
+        }
+        if (angle >= 140 && angle < 160) {
+            return 'slight right';
+        }
+        if (angle >= 160 && angle <= 200) {
+            return 'straight';
+        }
+        if (angle > 200 && angle <= 220) {
+            return 'slight left';
+        }
+        if (angle > 220 && angle <= 300) {
+            return 'left';
+        }
+        if (angle > 300 && angle < 360) {
+            return 'sharp left';
+        }
+        return 'u turn';
+    }
+
+    static wgs84ToJson(wgs84) {
+        const output = [wgs84.lng, wgs84.lat];
+        if (wgs84.level) {
+            output.push(wgs84.level.toString());
+        }
+        return output;
+    }
+
+    static jsonToWgs84(json) {
+        const output = new WGS84(json[1], json[0]);
+        if (json.length > 2) {
+            output.level = Level.fromString(json[2]);
+        }
+        return output;
+    }
+
+    static nodesToJsonCoords(nodes) {
+        return nodes.map(node => OsrmUtils.wgs84ToJson(node.coords));
+    }
+
+
+    static noRouteFoundJson(message) {
+        return {
+            'code': 'NoRoute',
+            message
+        };
+    }
+
 }
 
 export default OsrmUtils;