@wemap/routers 6.0.0

package/src/otp/OtpUtils.spec.js

@@ -0,0 +1,97 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Coordinates } from '@wemap/geo';
+
+import { createRouterResponseFromJson } from './OtpUtils.js';
+
+import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+
+
+const { expect } = chai;
+chai.use(chaiAlmost(0.1));
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe('OtpUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-grenoble-otp-1.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.routerName).equal('otp');
+        expect(routerResponse.itineraries.length).equal(2);
+        expect(routerResponse.from.equalsTo(new Coordinates(45.187291, 5.723455))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(45.163729, 5.74085))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.coords.length).equal(162);
+        expect(itinerary1.duration).equal(1206);
+        expect(itinerary1.startTime).equal(1614607210000);
+        expect(itinerary1.endTime).equal(1614608416000);
+        expect(itinerary1.legs.length).equal(3);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        expect(itinerary1leg1.startTime).equal(1614607210000);
+        expect(itinerary1leg1.endTime).equal(1614607499000);
+        expect(itinerary1leg1.distance).almost.equal(260.14);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).equal('Origin');
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(45.187291, 5.723455))).true;
+        expect(itinerary1leg1.to.name).equal('Grenoble, Victor Hugo');
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(45.1887, 5.72533))).true;
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.mode).equal('BUS');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo.name).equal('C4');
+        expect(itinerary1leg2.transportInfo.routeColor).equal('F3D000');
+        expect(itinerary1leg2.transportInfo.routeTextColor).equal('000000');
+        expect(itinerary1leg2.transportInfo.directionName).equal('Eybens, Le Verderet');
+
+    });
+
+
+    it('RouterResponse - 2', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-grenoble-otp-2.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.itineraries.length).equal(2);
+        expect(routerResponse.from.equalsTo(new Coordinates(45.192514856662456, 5.731452541397871))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(45.18544, 5.73123))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.legs.length).equal(5);
+
+        expect(itinerary1.legs[0].mode).equal('WALK');
+
+        expect(itinerary1.legs[1].mode).equal('TRAM');
+        expect(itinerary1.legs[1].transportInfo).is.not.null;
+
+        expect(itinerary1.legs[2].mode).equal('WALK');
+
+        expect(itinerary1.legs[3].mode).equal('TRAM');
+        expect(itinerary1.legs[3].transportInfo).is.not.null;
+
+        expect(itinerary1.legs[4].mode).equal('WALK');
+
+    });
+
+
+});
+

package/src/wemap/WemapNetworkUtils.js

@@ -0,0 +1,195 @@
+import { Level, GraphEdge, GraphNode, Network } from '@wemap/geo';
+import { OsmElement, OsmModel, OsmNode, OsmWay } from '@wemap/osm';
+
+
+export const HIGHWAYS_PEDESTRIANS = ['footway', 'steps', 'pedestrian', 'living_street', 'path', 'track', 'sidewalk'];
+
+export const DEFAULT_WAY_SELECTOR = way => {
+    return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway)
+        || way.tags.footway === 'sidewalk'
+        || way.tags.public_transport === 'platform'
+        || way.tags.railway === 'platform';
+};
+
+/**
+ * @param {Network<OsmElement>} network
+ * @param {string} name
+ */
+export function getNodeByName(network, name) {
+    return network.nodes.find(({ builtFrom }) => builtFrom.tags.name === name);
+}
+
+/**
+ * @param {Network<OsmElement>} network
+ * @param {string} name
+ */
+export function getEdgeByName(network, name) {
+    return network.edges.find(({ builtFrom }) => builtFrom.tags.name === name);
+}
+
+/**
+ * @param {GraphEdge<OsmElement>} edge
+ * @param {OsmWay} way
+ * @returns {boolean}
+ */
+function manageOneWay(edge, way) {
+
+    const { highway, oneway, conveying } = way.tags;
+
+    edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
+        || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
+
+    if (edge.isOneway && conveying === 'backward') {
+        const tmpNode = edge.node1;
+        edge.node1 = edge.node2;
+        edge.node2 = tmpNode;
+    }
+}
+
+/**
+ * @param {Network} networkModel
+ * @param {GraphNode} node
+ */
+function createNodesAndEdgesFromElevator(networkModel, node) {
+
+    /** @type {GraphNode[]} */
+    const createdNodes = [];
+    const getOrCreateLevelNode = (level, builtFrom) => {
+        let levelNode = createdNodes.find(({ coords }) => Level.equalsTo(level, coords.level));
+        if (!levelNode) {
+            levelNode = new GraphNode(node.coords.clone(), builtFrom);
+            levelNode.coords.level = level;
+            createdNodes.push(levelNode);
+            networkModel.nodes.push(levelNode);
+        }
+        return levelNode;
+    };
+
+    // Create nodes from node.edges
+    node.edges.forEach(edge => {
+        if (edge.level.isRange) {
+            throw new Error('Cannot handle this elevator edge due to ambiguity');
+        }
+
+        const levelNode = getOrCreateLevelNode(edge.level, node.builtFrom);
+        if (edge.node1 === node) {
+            edge.node1 = levelNode;
+        } else {
+            edge.node2 = levelNode;
+        }
+        levelNode.edges.push(edge);
+    });
+
+    // Create edges from createdNodes
+    for (let i = 0; i < createdNodes.length; i++) {
+        for (let j = i + 1; j < createdNodes.length; j++) {
+
+            const createdNode1 = createdNodes[i];
+            const createdNode2 = createdNodes[j];
+
+            const newEdge = new GraphEdge(
+                createdNode1,
+                createdNode2,
+                new Level(createdNode1.coords.level.val, createdNode2.coords.level.val),
+                node.builtFrom
+            );
+            networkModel.edges.push(newEdge);
+        }
+    }
+
+    // Remove the historical elevator node from the network
+    networkModel.nodes = networkModel.nodes.filter(_node => _node !== node);
+}
+
+
+/**
+ * @param {OsmModel} osmModel
+ * @param {function} _waySelectionFilter
+ * @returns {Network<OsmElement>}
+ */
+export function createNetworkFromOsmModel(
+    osmModel,
+    waySelectionFilter = DEFAULT_WAY_SELECTOR
+) {
+
+    const networkModel = new Network();
+
+    const nodesCreated = {};
+    const elevatorNodes = [];
+
+    /**
+     * @param {OsmNode} osmNode
+     */
+    const getOrCreateNode = osmNode => {
+        let node = nodesCreated[osmNode.id];
+        if (!node) {
+            node = new GraphNode(osmNode.coords, osmNode);
+            nodesCreated[osmNode.id] = node;
+            networkModel.nodes.push(node);
+
+            if (osmNode.tags.highway === 'elevator') {
+                elevatorNodes.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 GraphEdge(firstNode, secondNode, way.level, way);
+            manageOneWay(edge, way);
+            networkModel.edges.push(edge);
+            firstNode = secondNode;
+        }
+
+    });
+
+    elevatorNodes.forEach(node => {
+        // We have to clone this node for each connected edge
+        createNodesAndEdgesFromElevator(networkModel, node);
+    });
+
+    GraphNode.generateNodesLevels(networkModel.nodes);
+
+    return networkModel;
+}
+
+
+// /**
+//  * @param {GraphNode} node
+//  * @param {object} tags
+//  */
+// static _applyNodePropertiesFromTags(node, tags) {
+//     node.name = tags.name || null;
+//     node.subwayEntrance = tags.railway === 'subway_entrance';
+//     if (node.subwayEntrance && tags.ref) {
+//         node.subwayEntranceRef = tags.ref;
+//     }
+// }
+
+// /**
+//  * @param {GraphEdge} edge
+//  * @param {object} tags
+//  */
+// static _applyEdgePropertiesFromTags(edge, tags) {
+//     const { highway, oneway, conveying, name } = tags;
+//     edge.name = name || null;
+//     edge.isStairs = highway === 'steps';
+//     edge.isConveying = 'conveying' in tags;
+//     edge.isOneway = Boolean((oneway === 'yes' || oneway === 'true' || oneway === '1')
+//         || (conveying && highway && ['yes', 'forward', 'backward'].includes(conveying)));
+
+//     if (conveying === 'backward') {
+//         const tmpNode = edge.node1;
+//         edge.node1 = edge.node2;
+//         edge.node2 = tmpNode;
+//     }
+
+// }

package/src/wemap/WemapNetworkUtils.spec.js

@@ -0,0 +1,109 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Network } from '@wemap/geo';
+import { verifyCoherence } from '@wemap/geo/tests/CommonTest.js';
+
+import { OsmModel, OsmParser } from '@wemap/osm';
+
+import { createNetworkFromOsmModel, getNodeByName, getEdgeByName } from './WemapNetworkUtils.js';
+
+const { expect } = chai;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+
+const loadFile = fileName => {
+    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
+    return fs.readFileSync(filePath, 'utf8');
+};
+
+describe('OsmNetwork - simple', () => {
+
+    /** @type {OsmModel} */
+    let osmModel;
+
+    /** @type {Network} */
+    let network;
+    const osmXmlString = loadFile('network-simple.osm');
+
+    it('Network creation', () => {
+
+        osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        network = createNetworkFromOsmModel(osmModel);
+
+        verifyCoherence(network);
+        expect(network.nodes.length).equals(3);
+        expect(network.edges.length).equals(2);
+    });
+
+
+    it('Network creation - waySelectionFilter', () => {
+
+        const selectionNetwork = createNetworkFromOsmModel(osmModel, () => true);
+
+        verifyCoherence(selectionNetwork);
+        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 = createNetworkFromOsmModel(elevatorModel);
+
+        verifyCoherence(elevatorNetwork);
+        expect(elevatorNetwork.nodes.length).equals(7);
+        expect(elevatorNetwork.edges.length).equals(7);
+
+
+        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(() => createNetworkFromOsmModel(osmModel2)).throw(Error);
+    });
+
+    it('getNodeByName', () => {
+        let node = getNodeByName(network, 'p1');
+        expect(node).not.undefined;
+
+        node = getNodeByName(network, 'p5');
+        expect(node).is.undefined;
+    });
+});
+
+
+describe('OsmNetwork - with stairs', () => {
+
+    /** @type {OsmModel} */
+    let osmModel;
+
+    /** @type {Network} */
+    let network;
+    const osmXmlString = loadFile('bureaux-wemap-montpellier-network.osm');
+
+    it('Network creation', () => {
+
+        osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        network = createNetworkFromOsmModel(osmModel);
+
+        verifyCoherence(network);
+
+        expect(getEdgeByName(network, 'w6').builtFrom.tags.highway).equal('steps');
+    });
+
+});

package/src/wemap/WemapRouter.js

@@ -0,0 +1,27 @@
+import { Coordinates, GraphItinerary, GraphRouter, Network } from '@wemap/geo';
+import { OsmElement } from '@wemap/osm';
+
+import WemapRouterOptions from './WemapRouterOptions.js';
+
+class WemapRouter extends GraphRouter {
+
+    /**
+     * @param {!Network<OsmElement>} network
+     */
+    constructor(network) {
+        super(network);
+    }
+
+    /**
+     * @param {Coordinates} start
+     * @param {Coordinates} end
+     * @param {WemapRouterOptions} options
+     * @returns {GraphItinerary<OsmElement>}
+     */
+    getShortestPath(start, end, options = new WemapRouterOptions()) {
+        return super.getShortestPath(start, end, options);
+    }
+
+}
+
+export default WemapRouter;

package/src/wemap/WemapRouter.spec.js

@@ -0,0 +1,221 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import {
+    Level, Coordinates, GraphNode, Network, GraphItinerary
+} from '@wemap/geo';
+import { OsmElement, OsmParser } from '@wemap/osm';
+
+
+import WemapRouter from './WemapRouter.js';
+import WemapRouterOptions from './WemapRouterOptions.js';
+import WemapStepsGeneration from './WemapStepsGeneration.js';
+import { createNetworkFromOsmModel, getNodeByName } from './WemapNetworkUtils.js';
+
+import LevelChange from '../model/LevelChange.js';
+
+const { expect } = chai;
+chai.use(chaiAlmost(0.01));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+
+/**
+ * @param {GraphItinerary<OsmElement>} _itinerary
+ * @returns {string[]}
+ */
+const getNodesNames = _itinerary => {
+    return _itinerary.nodes.map(({ builtFrom }) => builtFrom.tags.name || null);
+};
+
+
+const itineraryStart = new Coordinates(43.6092754, 3.8842306, null, new Level(2));
+const itineraryEnd = new Coordinates(43.6092602, 3.8842669, null, new Level(1));
+
+
+/**
+ * @param {string} fileName
+ * @returns {Network}
+ */
+const loadNetwork = fileName => {
+    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
+    const osmXmlString = fs.readFileSync(filePath, 'utf8');
+    const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+    return createNetworkFromOsmModel(osmModel);
+};
+
+const generateNodeNames = (start, end) =>
+    new Array(end - start + 1).fill().map((_, idx) => 'p' + (idx + start));
+
+describe('WemapRouter - Multi-level itinerary', () => {
+
+    const networkModel = loadNetwork('bureaux-wemap-montpellier-network.osm');
+    const router = new WemapRouter(networkModel);
+
+    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
+
+    /** @type {GraphNode<OsmElement>[]} */
+    const p = [];
+
+    it('Search for nodes', () => {
+        for (let i = 1; i <= 16; i++) {
+            p[i] = getNodeByName(networkModel, 'p' + i);
+            expect(p[i]).instanceOf(GraphNode);
+        }
+    });
+
+    it('Router return shortest path', () => {
+        expect(getNodesNames(itinerary)).deep.equals(
+            ['w2', ...generateNodeNames(7, 16)]
+        );
+    });
+
+    it('Verify steps', () => {
+
+        const steps = WemapStepsGeneration.fromGraphItinerary(itinerary);
+        expect(steps.length).equal(8);
+
+        expect(steps[0].coords.equalsTo(itineraryStart.getSegmentProjection(p[6].coords, p[7].coords))).true;
+        expect(steps[0].name).equals('w2');
+        expect(steps[0].number).equals(1);
+        expect(steps[0].angle).almost.equals(-1.57);
+        expect(steps[0].previousBearing).almost.equals(1.778);
+        expect(steps[0].nextBearing).almost.equals(0.207);
+        expect(steps[0].distance).almost.equals(2.328);
+        expect(steps[0].duration).almost.equals(1.676);
+        expect(steps[0].firstStep).true;
+        expect(steps[0].lastStep).false;
+        expect(steps[0].levelChange).is.null;
+        expect(steps[0].extras).is.empty;
+
+        expect(steps[1].coords.equalsTo(p[8].coords)).true;
+        expect(steps[1].name).equals('w3');
+        expect(steps[1].number).equals(2);
+        expect(steps[1].distance).almost.equals(1.764);
+        expect(steps[1].firstStep).false;
+        expect(steps[1].lastStep).false;
+
+        expect(steps[2].coords.equalsTo(p[9].coords)).true;
+        expect(steps[2].name).equals('w3');
+
+        expect(steps[3].coords.equalsTo(p[10].coords)).true;
+        expect(steps[3].name).equals('w5');
+
+        expect(steps[4].coords.equalsTo(p[11].coords)).true;
+        expect(steps[4].name).equals('w6');
+        expect(steps[4].levelChange).instanceOf(LevelChange);
+        expect(steps[4].levelChange.difference).equals(-1);
+        expect(steps[4].levelChange.direction).equals('down');
+        expect(steps[4].levelChange.type).equals('stairs');
+
+        expect(steps[5].coords.equalsTo(p[14].coords)).true;
+        expect(steps[5].name).equals('w7');
+
+        expect(steps[6].coords.equalsTo(p[15].coords)).true;
+        expect(steps[6].name).equals('w9');
+
+        expect(steps[7].coords.equalsTo(p[16].coords)).true;
+        expect(steps[7].name).is.null;
+        expect(steps[7].lastStep).true;
+    });
+
+
+    it('router returns shortest path 2', () => {
+
+        const start = new Coordinates(43.609219, 3.8841743, null, new Level(2));
+        const end = new Coordinates(43.60917216742, 3.8842355275, null, new Level(2));
+        const itinerary2 = router.getShortestPath(start, end);
+
+        expect(getNodesNames(itinerary2)).deep.equals(['w1', 'p6', 'p5']);
+    });
+
+    it('do not use stairs', () => {
+
+        const itineraryWithoutStairs = router.getShortestPath(
+            itineraryStart, itineraryEnd,
+            WemapRouterOptions.WITHOUT_STAIRS
+        );
+        expect(itineraryWithoutStairs.nodes.length).equal(11);
+        itineraryWithoutStairs.edges.forEach((edge) => {
+            expect(edge.builtFrom.tags.highway).is.not.equal('steps');
+        });
+    });
+
+    // it('toCompressedJson / fromCompressedJson', () => {
+    //     const json = itinerary.toCompressedJson();
+    //     expect(() => JSON.stringify(json)).not.throw(Error);
+
+    //     const itineraryBis = Itinerary.fromCompressedJson(json);
+    //     verifyCoherence(itineraryBis);
+    //     expect(itineraryBis.nodes.length).equal(11);
+    //     verifyNodesOrder(itineraryBis.nodes, ['w2', ...generateNodeNames(7, 16)]);
+    // });
+
+});
+
+describe('WemapRouter - One Way itinerary', () => {
+
+    const networkModel = loadNetwork('one-way.osm');
+    const router = new WemapRouter(networkModel);
+
+    it('do not use oneway', () => {
+
+        const start = new Coordinates(43.6094542, 3.8842072);
+        const end = new Coordinates(43.6093792, 3.8841889);
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(itinerary).is.not.undefined;
+        expect(getNodesNames(itinerary)).deep.equals(['p0', 'p1', 'p2', 'p3']);
+
+        const itineraryOtherWay = router.getShortestPath(end, start);
+        expect(itineraryOtherWay).is.not.undefined;
+        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p3', 'p2', 'p5', 'p4', 'p1', 'p0']);
+    });
+});
+
+
+describe('WemapRouter - Conveying', () => {
+
+    const networkModel = loadNetwork('gare-de-lyon-extract.osm');
+    const router = new WemapRouter(networkModel);
+
+    it('do not use oneway conveying', () => {
+
+        const start = new Coordinates(48.8445715, 2.3718927, null, new Level(0));
+        const end = new Coordinates(48.84443728652394, 2.3721685669363524, null, new Level(-1));
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(itinerary).is.not.undefined;
+        expect(getNodesNames(itinerary)).deep.equals(['p11', 'p12', 'p9', 'p8', 'p6', null]);
+
+        const itineraryOtherWay = router.getShortestPath(end, start);
+        expect(itineraryOtherWay).is.not.undefined;
+        expect(getNodesNames(itineraryOtherWay)).deep.equals([null, 'p6', 'p7', 'p10', 'p11']);
+    });
+});
+
+
+describe('WemapRouter - Conveying - backward', () => {
+
+    const networkModel = loadNetwork('network-conveying-backward.osm');
+    const router = new WemapRouter(networkModel);
+
+    it('do not use oneway conveying', () => {
+
+        const start = getNodeByName(networkModel, 'p6');
+        const end = getNodeByName(networkModel, 'p13');
+
+        const itinerary = router.getShortestPath(start, end);
+        expect(itinerary).is.not.undefined;
+        expect(getNodesNames(itinerary)).deep.equals(['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
+
+        const itineraryOtherWay = router.getShortestPath(end, start);
+        expect(itineraryOtherWay).is.not.undefined;
+        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p13', 'p12', 'p9', 'p8', 'p6']);
+    });
+});
+
+

package/src/wemap/WemapRouterOptions.js

@@ -0,0 +1,32 @@
+import { GraphRouterOptions } from '@wemap/geo';
+import { OsmElement } from '@wemap/osm';
+
+class WemapRouterOptions extends GraphRouterOptions {
+
+    /** @type {WemapRouterOptions} */
+    static DEFAULT = new WemapRouterOptions();
+
+    /**
+     * @returns {WemapRouterOptions}
+     */
+    static get WITHOUT_STAIRS() {
+        const options = new WemapRouterOptions();
+        options.acceptEdgeFn = edge => edge.builtFrom.tags.highway !== 'steps';
+        return options;
+    }
+
+    /**
+     * Get route duration
+     * @param {Number} speed in km/h
+     */
+    static getDurationFromLength(length, speed = 5) {
+        return length / (speed * 1000 / 3600);
+    }
+
+    /** @type {function(GraphEdge<OsmElement>):boolean} */
+    weightEdgeFn = edge => edge.builtFrom.isElevator ? 30 : WemapRouterOptions.getDurationFromLength(edge.length);
+
+
+}
+
+export default WemapRouterOptions;