@wemap/geo 0.3.9 → 0.4.0

package/index.js

@@ -1,4 +1,5 @@
 import Constants from './src/Constants';
+import Utils from './src/Utils';
 
 import Attitude from './src/rotations/Attitude';
 
@@ -23,6 +24,7 @@ export {
     MapMatching,
     Network,
     Node,
+    Utils,
     WGS84,
     WGS84UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.3.9",
+    "version": "0.4.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -31,5 +31,5 @@
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "84a60e64b0968bc45f0f76cc26c08e165dbe6985"
+    "gitHead": "08d7d843add321d899aef07f9e2ec7739270dc70"
 }

package/src/Utils.js

@@ -0,0 +1,12 @@
+class Utils {
+
+    /**
+     * Get route duration
+     * @param {Number} speed in km/h
+     */
+    static getDurationFromLength(length, speed = 5) {
+        return length / (speed * 1000 / 3600);
+    }
+}
+
+export default Utils;

package/src/graph/GraphRouter.js

@@ -7,16 +7,31 @@ import Edge from './Edge';
 import Itinerary from './Itinerary';
 import Node from './Node';
 import MapMatching from './MapMatching';
+import Utils from '../Utils';
+
+const DEFAULT_ACCEPT_EDGE_FN = () => true;
+const DEFAULT_ACCEPT_ONEWAY_FN = () => true;
+const DEFAULT_WEIGHT_FN = edge => Utils.getDurationFromLength(edge.length);
 
 class GraphRouter {
 
-    constructor(network) {
+    constructor(network, mapMatchingMaxDistance = 50) {
         this.network = network;
         this.mapMatching = new MapMatching(network);
-        this.mapMatching.maxDistance = 50;
+        this.mapMatching.maxDistance = mapMatchingMaxDistance;
     }
 
-    getShortestPath(_start, _end, acceptEdgeFn = () => true) {
+    getShortestPath(
+        _start,
+        _end,
+        _acceptEdgeFn,
+        _weightFn,
+        _acceptOneWayFn) {
+
+        const acceptEdgeFn = _acceptEdgeFn || DEFAULT_ACCEPT_EDGE_FN;
+        const weightFn = _weightFn || DEFAULT_WEIGHT_FN;
+        const acceptOneWayFn = _acceptOneWayFn || DEFAULT_ACCEPT_ONEWAY_FN;
+
         let start;
         let startNodeCreated;
 
@@ -74,7 +89,8 @@ class GraphRouter {
             throw new Error('Cannot provide path because no end point has been found');
         }
 
-        const path = this.getShortestPathInternal(start, end, acceptEdgeFn);
+        const path = this.getShortestPathInternal(start, end,
+            acceptEdgeFn, weightFn, acceptOneWayFn);
 
         let route;
         if (path && path.length !== 0) {
@@ -138,7 +154,7 @@ class GraphRouter {
         );
     }
 
-    getShortestPathInternal(start, end, acceptEdgeFn) {
+    getShortestPathInternal(start, end, acceptEdgeFn, weightFn, acceptOneWayFn) {
         const distanceMap = {},
             checking = {},
             vertexList = {},
@@ -189,7 +205,7 @@ class GraphRouter {
                 })
                 // for each vertex we can reach
                 .forEach(edge => {
-                    let to, from;
+                    let to, from, reversed = false;
                     // determine the direction of travel
                     if (edge.node1.uniqueRouterId === current) {
                         to = edge.node2.uniqueRouterId;
@@ -197,10 +213,16 @@ class GraphRouter {
                     } else {
                         to = edge.node1.uniqueRouterId;
                         from = edge.node2.uniqueRouterId;
+                        reversed = true;
                     }
+
+                    if (!acceptOneWayFn(edge, reversed)) {
+                        return;
+                    }
+
                     // distance is how far we travelled to reach the
                     // current vertex, plus cost of travel the next(to)
-                    const distance = distanceMap[current] + edge.length;
+                    const distance = distanceMap[current] + weightFn(edge);
 
                     // if we have found a cheaper path
                     // update the hash of costs

package/src/graph/GraphRouter.spec.js

@@ -1,23 +1,30 @@
 import { expect } from 'chai';
 
+import WGS84 from '../coordinates/WGS84';
 import GraphRouter from './GraphRouter';
+import Node from './Node';
+import Edge from './Edge';
 
 import {
-    network, nodes, itineraryStart, itineraryEnd
+    network, nodes, itineraryStart, itineraryEnd, routingOptions
 } from '../../tests/CommonTest';
+import Network from './Network';
 
-describe('GraphRouter', () => {
 
+const {
+    acceptEdgeWithoutStairsFn, weightFn, acceptOneWayFn
+} = routingOptions;
+
+describe('GraphRouter', () => {
 
     const router = new GraphRouter(network);
     let itinerary;
 
-
     it('network did not change', () => {
         const nodesBefore = network.nodes.slice(0);
         const edgesBefore = network.edges.slice(0);
 
-        itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
+        itinerary = router.getShortestPath(itineraryStart, itineraryEnd, null, weightFn);
 
         const isEdgeInArray = (edgeArray, edge) => edgeArray.find(_edge =>
             edge.node1 === _edge.node1
@@ -62,11 +69,91 @@ describe('GraphRouter', () => {
         }
 
     });
+});
+
+
+describe('GraphRouter - Itinerary without stairs', () => {
+
+    const router = new GraphRouter(network);
+    const itinerary = router.getShortestPath(
+        itineraryStart,
+        itineraryEnd,
+        acceptEdgeWithoutStairsFn,
+        weightFn
+    );
+    const itineraryWithoutRestriction = router.getShortestPath(
+        itineraryStart,
+        itineraryEnd,
+        null,
+        weightFn
+    );
+
+    it('no stairs found', () => {
+        expect(itinerary).is.not.undefined;
+        expect(itinerary.edges.some(node => node.data && node.data.stairs)).false;
+
+        expect(itineraryWithoutRestriction).is.not.undefined;
+        expect(itineraryWithoutRestriction.edges.some(node => node.data && node.data.stairs)).true;
+    });
+});
+
+
+describe('GraphRouter - Itinerary one way', () => {
+
+    const owNodes = [
+        new Node(new WGS84(43.6094442, 3.8842049), { name: 'p0' }),
+        new Node(new WGS84(43.6094286, 3.8842011), { name: 'p1' }),
+        new Node(new WGS84(43.6094058, 3.8841955), { name: 'p2' }),
+        new Node(new WGS84(43.6093893, 3.8841914), { name: 'p3' }),
+        new Node(new WGS84(43.6094256, 3.8842247), { name: 'p4' }),
+        new Node(new WGS84(43.6094028, 3.8842191), { name: 'p5' })
+    ];
+
+    const owEdges = [
+        new Edge(owNodes[0], owNodes[1], { name: 'e0' }),
+        new Edge(owNodes[1], owNodes[2], { name: 'e1', oneWay: true }),
+        new Edge(owNodes[2], owNodes[3], { name: 'e2' }),
+        new Edge(owNodes[1], owNodes[4], { name: 'e3' }),
+        new Edge(owNodes[4], owNodes[5], { name: 'e4' }),
+        new Edge(owNodes[5], owNodes[2], { name: 'e5' })
+    ];
+    const owNetwork = new Network(owNodes, owEdges);
+    const owRouter = new GraphRouter(owNetwork);
+
+    const start = new WGS84(43.6094542, 3.8842072);
+    const end = new WGS84(43.6093792, 3.8841889);
+
+    const itinerary = owRouter.getShortestPath(
+        start,
+        end,
+        null,
+        weightFn,
+        acceptOneWayFn
+    );
+
+    const itineraryOtherWay = owRouter.getShortestPath(
+        end,
+        start,
+        null,
+        weightFn,
+        acceptOneWayFn
+    );
+
+    it('do not use oneway segments', () => {
+
+        expect(itinerary).is.not.undefined;
+        expect(itinerary.nodes[0]).equals(owNodes[0]);
+        expect(itinerary.nodes[1]).equals(owNodes[1]);
+        expect(itinerary.nodes[2]).equals(owNodes[2]);
+        expect(itinerary.nodes[3]).equals(owNodes[3]);
+
+        expect(itineraryOtherWay).is.not.undefined;
+        expect(itineraryOtherWay.nodes[0]).equals(owNodes[3]);
+        expect(itineraryOtherWay.nodes[1]).equals(owNodes[2]);
+        expect(itineraryOtherWay.nodes[2]).equals(owNodes[5]);
+        expect(itineraryOtherWay.nodes[3]).equals(owNodes[4]);
+        expect(itineraryOtherWay.nodes[4]).equals(owNodes[1]);
+        expect(itineraryOtherWay.nodes[5]).equals(owNodes[0]);
 
-    it('no route found', () => {
-        const itineraryWithoutStairs = router.getShortestPath(itineraryStart, itineraryEnd,
-            edge => !edge.data || !edge.data.hasOwnProperty('stairs') || !edge.data.stairs
-        );
-        expect(itineraryWithoutStairs).is.undefined;
     });
 });

package/src/graph/Itinerary.js

@@ -1,14 +1,15 @@
 /* eslint-disable max-statements */
 import { WGS84, Level } from '@wemap/geo';
+import {
+    diffAngle, deg2rad
+} from '@wemap/maths';
 
 import Network from './Network';
 import Edge from './Edge';
 import Node from './Node';
 import Step from './Step';
-import {
-    diffAngle, deg2rad
-} from '@wemap/maths';
 import MapMatching from './MapMatching';
+import Utils from '../Utils';
 
 const SKIP_STEP_ANGLE_MAX = deg2rad(20);
 
@@ -67,15 +68,7 @@ class Itinerary extends Network {
      * @param {Number} speed in km/h
      */
     getDuration(speed) {
-        return Itinerary.getDurationFromLength(this.length, speed);
-    }
-
-    /**
-     * Get route duration
-     * @param {Number} speed in km/h
-     */
-    static getDurationFromLength(length, speed = 4) {
-        return length / (speed * 1000 / 3600);
+        return Utils.getDurationFromLength(this.length, speed);
     }
 
     get steps() {

package/src/graph/Itinerary.spec.js

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import GraphRouter from './GraphRouter';
 
 import {
-    network, nodes, itineraryStart, itineraryEnd, edges
+    network, nodes, itineraryStart, itineraryEnd, edges, routingOptions
 } from '../../tests/CommonTest';
 import Level from '../coordinates/Level';
 import WGS84 from '../coordinates/WGS84';
@@ -12,7 +12,8 @@ import WGS84 from '../coordinates/WGS84';
 describe('Itinerary', () => {
 
     const router = new GraphRouter(network);
-    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
+    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd, null,
+        routingOptions.weightFn);
 
     it('is readable', () => {
 

package/src/graph/Network.js

@@ -3,9 +3,9 @@
  */
 class Network {
 
-    constructor() {
-        this.nodes = [];
-        this.edges = [];
+    constructor(nodes, edges) {
+        this.nodes = Array.isArray(nodes) ? nodes : [];
+        this.edges = Array.isArray(edges) ? edges : [];
     }
 
     getNodeByCoords(coords) {
@@ -27,12 +27,12 @@ class Network {
 
         let nodeToStringFn = _nodeToStringFn;
         if (!nodeToStringFn) {
-            nodeToStringFn = node => `${node.data.name}`;
+            nodeToStringFn = node => `${node.data}`;
         }
 
         let edgeToStringFn = _edgeToStringFn;
         if (!_edgeToStringFn) {
-            edgeToStringFn = edge => `${edge.data.name}`;
+            edgeToStringFn = edge => `${edge.data}`;
         }
 
         let output

package/src/graph/Step.js

@@ -1,4 +1,4 @@
-import Itinerary from './Itinerary';
+import Utils from '../Utils';
 
 class Step {
 
@@ -49,7 +49,7 @@ class Step {
      * @param {Number} speed in km/h
      */
     getDuration(speed) {
-        return Itinerary.getDurationFromLength(this.length, speed);
+        return Utils.getDurationFromLength(this.length, speed);
     }
 
 }

package/tests/CommonTest.js

@@ -5,6 +5,7 @@ import {
 import Edge from '../src/graph/Edge';
 import Node from '../src/graph/Node';
 import Network from '../src/graph/Network';
+import Utils from '../src/Utils';
 
 const nodes = [
     new Node(new WGS84(43.6092404, 3.884099), { name: 'p0' }),
@@ -23,7 +24,11 @@ const nodes = [
     new Node(new WGS84(43.6093597, 3.8842336), { name: 'p13' }),
     new Node(new WGS84(43.6093202, 3.8842218), { name: 'p14' }),
     new Node(new WGS84(43.6093123, 3.8842731), { name: 'p15' }),
-    new Node(new WGS84(43.6092681, 3.8842604), { name: 'p16' })
+    new Node(new WGS84(43.6092681, 3.8842604), { name: 'p16' }),
+    new Node(new WGS84(43.6093279, 3.8842777), { name: 'p17' }),
+    new Node(new WGS84(43.6093279, 3.8842777), { name: 'p18' }),
+    new Node(new WGS84(43.6093323, 3.8842483), { name: 'p19a' }),
+    new Node(new WGS84(43.6093323, 3.8842483), { name: 'p19b' })
 ];
 
 const edges = [
@@ -42,7 +47,12 @@ const edges = [
     new Edge(nodes[12], nodes[13], { name: 'e12', stairs: true }, new Level(1, 2)),
     new Edge(nodes[13], nodes[14], { name: 'e13', stairs: true }, new Level(1, 2)),
     new Edge(nodes[14], nodes[15], { name: 'e14' }, new Level(1)),
-    new Edge(nodes[15], nodes[16], { name: 'e15' }, new Level(1))
+    new Edge(nodes[15], nodes[16], { name: 'e15' }, new Level(1)),
+    new Edge(nodes[15], nodes[17], { name: 'e16' }, new Level(1)),
+    new Edge(nodes[19], nodes[17], { name: 'e17' }, new Level(1)),
+    new Edge(nodes[10], nodes[18], { name: 'e18' }, new Level(2)),
+    new Edge(nodes[20], nodes[18], { name: 'e19' }, new Level(2)),
+    new Edge(nodes[19], nodes[20], { name: 'e20', elevator: true }, new Level(1, 2))
 ];
 
 const network = new Network();
@@ -52,6 +62,25 @@ network.nodes = nodes;
 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 detailedStringArgs = [
+    node => !node.data ? 'created' : `${node.data.name}`,
+    edge => !edge.data ? 'created' : `${edge.data.name}`
+];
+
+const routingOptions = {
+
+    acceptOneWayFn: (edge, reversed) => !(edge.data && edge.data.oneWay && reversed),
+
+    acceptEdgeWithoutStairsFn: edge => !(edge.data && edge.data.stairs),
+
+    weightFn: edge => {
+        if (edge.data && edge.data.elevator) {
+            return 30;
+        }
+        return Utils.getDurationFromLength(edge.length);
+    }
+};
+
 export {
-    nodes, edges, network, itineraryStart, itineraryEnd
+    nodes, edges, network, itineraryStart, itineraryEnd, routingOptions, detailedStringArgs
 };