@wemap/osm 0.1.0

package/assets/bureaux-wemap-montpellier-network.osm

@@ -0,0 +1,111 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version='0.6' generator='JOSM'>
+  <node id='-440460' action='modify' visible='true' lat='43.60927603206' lon='3.88424673798'>
+    <tag k='name' v='p7' />
+  </node>
+  <node id='-440462' action='modify' visible='true' lat='43.60913609818' lon='3.88411091795'>
+    <tag k='name' v='p3' />
+  </node>
+  <node id='-440464' action='modify' visible='true' lat='43.60929353543' lon='3.88425183223'>
+    <tag k='name' v='p8' />
+  </node>
+  <node id='-440466' action='modify' visible='true' lat='43.60930219142' lon='3.88427017086'>
+    <tag k='name' v='p9' />
+  </node>
+  <node id='-440468' action='modify' visible='true' lat='43.60911942685' lon='3.88422017773'>
+    <tag k='name' v='p4' />
+  </node>
+  <node id='-440470' action='modify' visible='true' lat='43.60935581261' lon='3.88428577699' />
+  <node id='-440472' action='modify' visible='true' lat='43.60919651074' lon='3.88412853633'>
+    <tag k='name' v='p1' />
+  </node>
+  <node id='-440474' action='modify' visible='true' lat='43.60931199709' lon='3.88413083832' />
+  <node id='-440476' action='modify' visible='true' lat='43.60917494597' lon='3.88421731753'>
+    <tag k='name' v='p6' />
+  </node>
+  <node id='-440478' action='modify' visible='true' lat='43.60918883875' lon='3.88412626772'>
+    <tag k='name' v='p2' />
+  </node>
+  <node id='-440480' action='modify' visible='true' lat='43.60936726345' lon='3.88427546746' />
+  <node id='-440482' action='modify' visible='true' lat='43.60917216742' lon='3.8842355275'>
+    <tag k='name' v='p5' />
+  </node>
+  <node id='-440484' action='modify' visible='true' lat='43.60931231268' lon='3.8842731166'>
+    <tag k='name' v='p10' />
+  </node>
+  <node id='-440486' action='modify' visible='true' lat='43.60932336323' lon='3.884200898'>
+    <tag k='name' v='p11' />
+  </node>
+  <node id='-440488' action='modify' visible='true' lat='43.6093629216' lon='3.884212726'>
+    <tag k='name' v='p12' />
+  </node>
+  <node id='-440490' action='modify' visible='true' lat='43.60935965678' lon='3.8842335535'>
+    <tag k='name' v='p13' />
+  </node>
+  <node id='-440492' action='modify' visible='true' lat='43.60932022256' lon='3.88422176261'>
+    <tag k='name' v='p14' />
+  </node>
+  <node id='-440494' action='modify' visible='true' lat='43.60931232238' lon='3.88427309743'>
+    <tag k='name' v='p15' />
+  </node>
+  <node id='-440496' action='modify' visible='true' lat='43.60936673756' lon='3.88428907078' />
+  <node id='-440498' action='modify' visible='true' lat='43.60926807571' lon='3.884260391'>
+    <tag k='name' v='p16' />
+  </node>
+  <way id='-440499' action='modify' visible='true'>
+    <nd ref='-440476' />
+    <nd ref='-440460' />
+    <nd ref='-440464' />
+    <nd ref='-440474' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='2' />
+  </way>
+  <way id='-440500' action='modify' visible='true'>
+    <nd ref='-440464' />
+    <nd ref='-440466' />
+    <nd ref='-440484' />
+    <nd ref='-440470' />
+    <nd ref='-440480' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='2' />
+  </way>
+  <way id='-440501' action='modify' visible='true'>
+    <nd ref='-440472' />
+    <nd ref='-440478' />
+    <nd ref='-440462' />
+    <nd ref='-440468' />
+    <nd ref='-440482' />
+    <nd ref='-440476' />
+    <nd ref='-440478' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='2' />
+  </way>
+  <way id='-440502' action='modify' visible='true'>
+    <nd ref='-440486' />
+    <nd ref='-440488' />
+    <nd ref='-440490' />
+    <nd ref='-440492' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='1;2' />
+    <tag k='stairs' v='yes' />
+  </way>
+  <way id='-440503' action='modify' visible='true'>
+    <nd ref='-440484' />
+    <nd ref='-440486' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='2' />
+  </way>
+  <way id='-440504' action='modify' visible='true'>
+    <nd ref='-440492' />
+    <nd ref='-440494' />
+    <nd ref='-440496' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='1' />
+  </way>
+  <way id='-440505' action='modify' visible='true'>
+    <nd ref='-440494' />
+    <nd ref='-440498' />
+    <tag k='highway' v='footway' />
+    <tag k='level' v='1' />
+  </way>
+</osm>

package/index.js

@@ -0,0 +1,11 @@
+import OsmNetwork from './src/network/OsmNetwork';
+import OsmParser from './src/model/OsmParser';
+import OsmRouter from './src/network/OsmRouter';
+import OsrmUtils from './src/osrm/OsrmUtils';
+
+export {
+    OsmNetwork,
+    OsmParser,
+    OsmRouter,
+    OsrmUtils
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+    "author": "Wemap",
+    "contributors": [
+        "Thibaud Michel <thibaud@getwemap.com>"
+    ],
+    "description": "Wemap OSM utils package",
+    "main": "index.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/wemap/wemap-utils-js.git",
+        "directory": "packages/osm"
+    },
+    "name": "@wemap/osm",
+    "version": "0.1.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\\\""
+    },
+    "keywords": [
+        "utils",
+        "osm",
+        "wemap"
+    ],
+    "license": "ISC",
+    "dependencies": {
+        "@wemap/geo": "^0.2.0",
+        "@wemap/logger": "^0.1.5",
+        "lodash.isnumber": "^3.0.3",
+        "sax": "^1.2.4"
+    },
+    "gitHead": "6673bc4d0f4b6ff404534e0642122c340fe58483"
+}

package/src/model/OsmElement.js

@@ -0,0 +1,9 @@
+class OsmElement {
+
+    constructor(id) {
+        this.id = id;
+        this.tags = {};
+    }
+}
+
+export default OsmElement;

package/src/model/OsmModel.js

@@ -0,0 +1,24 @@
+import OsmParser from './OsmParser';
+
+class OsmModel {
+
+    constructor() {
+        this.nodes = [];
+        this.ways = [];
+    }
+
+    getNodeById(id) {
+        return this.nodes.find(node => node.id === id);
+    }
+
+    getNodeByName(name) {
+        return this.nodes.find(node => node.tags.name === name);
+    }
+
+    static fromXmlString(xmlString) {
+        return OsmParser.parseOsmXmlString(xmlString);
+    }
+
+}
+
+export default OsmModel;

package/src/model/OsmNode.js

@@ -0,0 +1,22 @@
+import { WGS84 } from '@wemap/geo';
+
+import OsmElement from './OsmElement';
+
+class OsmNode extends OsmElement {
+
+    constructor(id, coords) {
+        super(id);
+        this.ways = [];
+        this.coords = coords;
+    }
+
+    static fromSax(attr) {
+        const node = new OsmNode(
+            Number(attr.id),
+            new WGS84(Number(attr.lat), Number(attr.lon)));
+        node.action = attr.action;
+        return node;
+    }
+}
+
+export default OsmNode;

package/src/model/OsmParser.js

@@ -0,0 +1,100 @@
+import sax from 'sax';
+
+import { Level } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import OsmModel from './OsmModel';
+import OsmNode from './OsmNode';
+import OsmWay from './OsmWay';
+
+class OsmParser {
+
+    static parseOsmXmlString(osmXmlString) {
+
+        const model = new OsmModel();
+        const parser = sax.parser(true);
+
+        let buffer;
+
+        parser.onopentag = (node) => {
+
+            switch (node.name) {
+            case 'node': {
+                const osmNode = OsmNode.fromSax(node.attributes);
+                buffer = osmNode;
+                model.nodes.push(osmNode);
+                break;
+            }
+            case 'way': {
+                const osmWay = OsmWay.fromSax(node.attributes);
+                buffer = osmWay;
+                model.ways.push(osmWay);
+                break;
+            }
+            case 'tag': {
+                if (!buffer) {
+                    return;
+                }
+                const {
+                    k, v
+                } = node.attributes;
+                buffer.tags[k] = v;
+                break;
+            }
+            case 'nd': {
+                if (!buffer || !(buffer instanceof OsmWay)) {
+                    return;
+                }
+                const nodeId = Number(node.attributes.ref);
+                const refNode = model.getNodeById(nodeId);
+                if (!refNode) {
+                    Logger.warn('Node: ' + nodeId + ' in way ' + buffer.id + ' not found');
+                    return;
+                }
+
+                buffer.nodes.push(refNode);
+                refNode.ways.push(buffer);
+                break;
+            }
+            }
+        };
+
+        parser.write(osmXmlString);
+
+        for (let i = 0; i < model.ways.length; i++) {
+            const way = model.ways[i];
+            if (way.tags.level) {
+                way.level = Level.fromString(way.tags.level);
+            }
+        }
+
+        for (let i = 0; i < model.nodes.length; i++) {
+            const node = model.nodes[i];
+            if (node.ways.length === 0) {
+                continue;
+            }
+
+            // Get node level from ways connected to this node.
+            // Node level is intersection of all levels of connected ways.
+            let tmpLevel = node.coords.level;
+            node.ways.forEach(way => {
+                if (way.level) {
+                    if (!tmpLevel) {
+                        tmpLevel = way.level.clone();
+                    } else {
+                        tmpLevel = tmpLevel.intersect(way.level);
+                        if (!tmpLevel) {
+                            Logger.error('Error: Something bad happend during parsing: We cannot retrieve node level from adjacent ways: ' + node.coords);
+                        }
+                    }
+                }
+            });
+            node.coords.level = tmpLevel;
+        }
+
+        return model;
+    }
+
+}
+
+export default OsmParser;

package/src/model/OsmWay.js

@@ -0,0 +1,18 @@
+import OsmElement from './OsmElement';
+
+class OsmWay extends OsmElement {
+
+    constructor(id) {
+        super(id);
+        this.nodes = [];
+    }
+
+    static fromSax(attr) {
+        const way = new OsmWay(Number(attr.id));
+        way.action = attr.action;
+        return way;
+    }
+
+}
+
+export default OsmWay;

package/src/network/OsmNetwork.js

@@ -0,0 +1,64 @@
+import {
+    Edge, Node, Network
+} from '@wemap/geo';
+
+
+const HIGHWAYS_PEDESTRIANS = ['footway', 'steps'];
+const DEFAULT_WAY_SELECTOR = way => HIGHWAYS_PEDESTRIANS.includes(way.tags.highway);
+
+/**
+ * A typical network with nodes (Node) and edges (Edge)
+ */
+class OsmNetwork extends Network {
+
+    static fromOsmModel(osmModel, _waySelectionFilter) {
+
+        const waySelectionFilter = _waySelectionFilter || DEFAULT_WAY_SELECTOR;
+
+        const networkModel = new OsmNetwork();
+
+        const getOrCreateNode = osmNode => {
+            let node = networkModel.nodes.find(graphNode => osmNode.id === graphNode.data.id);
+            if (!node) {
+                node = new Node(osmNode.coords, osmNode);
+                networkModel.nodes.push(node);
+            }
+            return node;
+        };
+
+        osmModel.ways.forEach(way => {
+            if (!waySelectionFilter(way)) {
+                return;
+            }
+
+            let firstNode = getOrCreateNode(way.nodes[0]);
+            for (let i = 1; i < way.nodes.length; i++) {
+                const secondNode = getOrCreateNode(way.nodes[i]);
+
+                const edge = new Edge(firstNode, secondNode);
+                edge.data = way;
+                edge.level = way.level;
+                networkModel.edges.push(edge);
+                firstNode.edges.push(edge);
+                secondNode.edges.push(edge);
+
+                firstNode = secondNode;
+            }
+
+        });
+
+        return networkModel;
+    }
+
+    getNodeById(id) {
+        return this.nodes.find(node => node.data.id === id);
+    }
+
+
+    getEdgeById(id) {
+        return this.edges.find(edge => edge.data.id === id);
+    }
+
+}
+
+export default OsmNetwork;

package/src/network/OsmRouter.js

@@ -0,0 +1,25 @@
+import { GraphRouter } from '@wemap/geo';
+
+const DEFAULT_OPTIONS = { useStairs: true };
+
+class OsmRouter extends GraphRouter {
+
+    getShortestPath(start, end, _options) {
+
+        const options = Object.assign({}, DEFAULT_OPTIONS, _options);
+
+        const edgeSelectionFilter = edge => {
+
+            return options.useStairs
+                || (
+                    edge.data.tags.stairs !== 'yes'
+                    && edge.data.tags.highway !== 'steps'
+                );
+        };
+
+        return super.getShortestPath(start, end, edgeSelectionFilter);
+    }
+
+}
+
+export default OsmRouter;

package/src/network/OsmRouter.spec.js

@@ -0,0 +1,84 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import fs from 'fs';
+import path from 'path';
+
+import {
+    WGS84, Level
+} from '@wemap/geo';
+
+import OsmParser from '../model/OsmParser';
+import OsmRouter from './OsmRouter';
+import OsmNetwork from './OsmNetwork';
+
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+
+describe('OsmRouter', () => {
+
+    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);
+
+    it('Multi-level 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);
+
+        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');
+
+
+        /**
+         * Verify if itinerary is ordered
+         */
+
+        for (let i = 0; i < itinerary.nodes.length; i++) {
+            const node = itinerary.nodes[i];
+
+            expect(node.edges.length).equal(i === 0 || i === itinerary.nodes.length - 1 ? 1 : 2);
+
+            if (i !== itinerary.nodes.length - 1) {
+                expect(itinerary.edges[i].node1).equal(node);
+                expect(itinerary.edges[i].node2).equal(itinerary.nodes[i + 1]);
+            }
+
+        }
+
+    });
+
+
+    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;
+
+    });
+});

package/src/osrm/OsrmItinerary.js

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

package/src/osrm/OsrmUtils.js

@@ -0,0 +1,154 @@
+/* eslint-disable max-statements */
+
+import {
+    Network, WGS84
+} from '@wemap/geo';
+import { Utils as MathUtils } from '@wemap/maths';
+
+
+class OsrmUtils {
+
+    static itineraryToOsrmJson(itinerary, altitudeFactor = 1) {
+
+        const {
+            edges, nodes, start, end, length
+        } = itinerary;
+
+        const coordinates = [];
+        const steps = [];
+
+        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));
+        });
+
+        let previousBearing;
+
+        for (let i = -1; i < nodes.length; i++) {
+
+            let node;
+            let nextNode;
+
+            let nodeCoords;
+            let nodeTags;
+            let nextNodeCoords;
+            let nextEdgeTags;
+
+            if (i === -1) {
+                nodeCoords = start;
+                previousBearing = 0;
+            } else {
+                node = nodes[i];
+                nodeCoords = node.coords;
+                nodeTags = node.tags;
+            }
+
+            if (i + 1 === nodes.length) {
+                nextNodeCoords = end;
+            } else {
+                nextNode = nodes[i + 1];
+                nextNodeCoords = nextNode.coords;
+            }
+
+            if (node && nextNode) {
+                const edge = Network.getEdgeByNodes(edges, nextNode, node);
+                nextEdgeTags = edge.data.tags;
+            }
+
+            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 nodeCoordsModified = nodeCoords.clone();
+            if (altitudeFactor !== 1 && nodeCoordsModified.level) {
+                nodeCoordsModified.level.multiplyBy(altitudeFactor);
+            }
+
+            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
+            });
+
+            previousBearing = bearing;
+        }
+
+        const endNodeCoordsModified = end.clone();
+        if (altitudeFactor !== 1 && endNodeCoordsModified.level) {
+            endNodeCoordsModified.level.multiplyBy(altitudeFactor);
+        }
+        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',
+            'routes': [
+                {
+                    'geometry': {
+                        'type': 'LineString',
+                        'coordinates': coordinates
+                    },
+                    'legs': [
+                        {
+                            'duration': itinerary.getDuration(),
+                            'distance': length,
+                            'steps': steps
+                        }
+                    ],
+                    'distance': length,
+                    'duration': itinerary.getDuration(),
+                    'weight_name': 'routability',
+                    'weight': 0
+                }
+            ],
+            'waypoints': []
+        };
+    }
+
+    static get noRouteFoundJson() {
+        return { 'code': 'NoRoute' };
+    }
+
+
+    static getModifierFromAngle(angle) {
+        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';
+    }
+}
+
+export default OsrmUtils;