@wemap/geo 4.0.14 → 5.0.3

package/src/graph/Network.spec.js

@@ -3,6 +3,10 @@ import chai from 'chai';
 import Constants from '../Constants.js';
 import Coordinates from '../coordinates/Coordinates.js';
 import Network from './Network.js';
+import GraphNode from './GraphNode.js';
+import GraphEdge from './GraphEdge.js';
+
+import Level from '../coordinates/Level.js';
 
 import {
     nodes, edges, network
@@ -26,7 +30,7 @@ describe('Network', () => {
 
         let node = network.getNodeByCoords(nodes[2].coords.clone());
         expect(node).not.null;
-        expect(node.name).equals('p2');
+        expect(node.builtFrom).equals('p2');
 
         node = network.getNodeByCoords(new Coordinates(43.601888, 3.8841263));
         expect(node).undefined;
@@ -36,23 +40,12 @@ describe('Network', () => {
 
         let edge = network.getEdgeByNodes(nodes[1], nodes[2]);
         expect(edge).not.null;
-        expect(edge.name).equals('e0');
+        expect(edge.builtFrom).equals('e0');
 
         edge = network.getEdgeByNodes(nodes[0], nodes[2]);
         expect(edge).undefined;
     });
 
-    it('getEdgeByName', () => {
-
-        let edge = network.getEdgeByName('e1');
-        expect(edge).not.null;
-        expect(edge.name).equals('e1');
-        expect(edge).equals(edges[1]);
-
-        edge = network.getEdgeByName('abc');
-        expect(edge).undefined;
-    });
-
     it('getBoundingBox', () => {
 
         let boundingBox = network.getBoundingBox();
@@ -85,11 +78,69 @@ describe('Network', () => {
         const networkBis = Network.fromCompressedJson(networkJson);
 
         networkBis.nodes.forEach((node, i) => {
-            expect(node.equalsTo(network.nodes[i])).is.true;
+            expect(node.coords.equalsTo(network.nodes[i].coords)).is.true;
         });
 
         networkBis.edges.forEach((edge, i) => {
-            expect(edge.equalsTo(network.edges[i])).is.true;
+            expect(edge.node1.coords.equalsTo(network.edges[i].node1.coords)).is.true;
+            expect(edge.node2.coords.equalsTo(network.edges[i].node2.coords)).is.true;
+            expect(edge.isOneway).equals(network.edges[i].isOneway);
         });
     });
+
+
+    it('getEdgesAtLevel', () => {
+
+        const _nodes = [
+            new GraphNode(new Coordinates(43.6091194, 3.884099, null, new Level(0)), 'p0'),
+            new GraphNode(new Coordinates(43.6093629, 3.8842777, null, new Level(0)), 'p1'),
+            new GraphNode(new Coordinates(43.6094654, 3.8842167, null, new Level(0, 1)), 'p2'),
+            new GraphNode(new Coordinates(43.6094902, 3.8843416, null, new Level(1)), 'p3'),
+            new GraphNode(new Coordinates(43.6095463, 3.8843837, null, new Level(1)), 'p4'),
+            new GraphNode(new Coordinates(43.6095552, 3.8844971, null, new Level(2)), 'p5'),
+            new GraphNode(new Coordinates(43.6095908, 3.8844662, null, new Level(1)), 'p6'),
+            new GraphNode(new Coordinates(43.6096412, 3.8844706, null, new Level(1)), 'p7')
+        ];
+
+        const _edges = [
+            new GraphEdge(_nodes[0], _nodes[1], new Level(0), 'e0'),
+            new GraphEdge(_nodes[1], _nodes[2], new Level(0), 'e1'),
+            new GraphEdge(_nodes[2], _nodes[3], new Level(1), 'e2'),
+            new GraphEdge(_nodes[3], _nodes[4], new Level(1), 'e3'),
+            new GraphEdge(_nodes[4], _nodes[5], new Level(1, 2), 'e4'),
+            new GraphEdge(_nodes[5], _nodes[6], new Level(1, 2), 'e5'),
+            new GraphEdge(_nodes[6], _nodes[7], new Level(1), 'e6')
+        ];
+
+        const _network = new Network(_nodes, _edges);
+
+        const edgesAtLevel0 = _network.getEdgesAtLevel(new Level(0), false);
+        expect(edgesAtLevel0.length).equals(2);
+        expect(edgesAtLevel0[0].builtFrom).equals('e0');
+        expect(edgesAtLevel0[1].builtFrom).equals('e1');
+
+        const segmentsAtLevel1 = _network.getEdgesAtLevel(new Level(1), false);
+        expect(segmentsAtLevel1.length).equals(3);
+        expect(segmentsAtLevel1[0].builtFrom).equals('e2');
+        expect(segmentsAtLevel1[1].builtFrom).equals('e3');
+        expect(segmentsAtLevel1[2].builtFrom).equals('e6');
+
+        const segmentsAtLevel2 = _network.getEdgesAtLevel(new Level(2), false);
+        expect(segmentsAtLevel2.length).equals(0);
+        const segmentsAtLevel2b = _network.getEdgesAtLevel(new Level(2), true);
+        expect(segmentsAtLevel2b.length).equals(2);
+
+        const edgesAtLevel01 = _network.getEdgesAtLevel(new Level(0, 1), false);
+        expect(edgesAtLevel01.length).equals(5);
+        const edgesAtLevel01b = _network.getEdgesAtLevel(new Level(0, 1), true);
+        expect(edgesAtLevel01b.length).equals(7);
+
+        const edgesAtLevel12 = _network.getEdgesAtLevel(new Level(1, 2), false);
+        expect(edgesAtLevel12.length).equals(5);
+
+        const edgesAtLevel02 = _network.getEdgesAtLevel(new Level(0, 2), false);
+        expect(edgesAtLevel02.length).equals(7);
+
+    });
+
 });

package/src/router/GraphItinerary.js

@@ -0,0 +1,70 @@
+import Coordinates from '../coordinates/Coordinates.js';
+import GraphNode from '../graph/GraphNode.js';
+import GraphEdge from '../graph/GraphEdge.js';
+import { getEdgeByNodes } from '../graph/GraphUtils.js';
+
+/**
+ * @template T
+ */
+class GraphItinerary {
+
+    /** @type {Coordinates} */
+    start;
+
+    /** @type {Coordinates} */
+    end;
+
+    /** @type {GraphNode<T>[]} */
+    nodes;
+
+    /** @type {GraphEdge<T>[]} */
+    edges;
+
+    /** @type {number[]} */
+    edgesWeights;
+
+
+    /**
+     * @template T
+     * @param {GraphNode<T>[]} networkNodes
+     * @param {number[]} edgesWeights
+     * @returns {GraphItinerary<T>}
+     */
+    static fromNetworkNodes(networkNodes, edgesWeights) {
+        const itinerary = new GraphItinerary();
+        itinerary.edgesWeights = edgesWeights;
+
+        itinerary.nodes = networkNodes.map(node => {
+            const newNode = node.clone();
+            // Remove node edges, they will be added later.
+            newNode.edges = [];
+            return newNode;
+        });
+
+        itinerary.edges = [];
+        networkNodes.forEach((node, idx, arr) => {
+            if (idx === 0) {
+                return;
+            }
+
+            // Retrieve network edge
+            const prevNode = arr[idx - 1];
+            const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
+
+            // Create itinerary edge
+            const newEdge = new GraphEdge(
+                itinerary.nodes[idx - 1],
+                itinerary.nodes[idx],
+                edge.level,
+                edge.builtFrom
+            );
+            newEdge.isOneway = edge.isOneway;
+            itinerary.edges.push(newEdge);
+        });
+
+        return itinerary;
+
+    }
+}
+
+export default GraphItinerary;

package/src/router/GraphItinerary.spec.js

@@ -0,0 +1,18 @@
+import chai from 'chai';
+
+import GraphItinerary from './GraphItinerary.js';
+
+const { expect } = chai;
+
+/**
+ * @param {GraphItinerary} itinerary
+ */
+export function isReadable(itinerary) {
+    for (let i = 0; i < itinerary.nodes.length; i++) {
+        const node = itinerary.nodes[i];
+        if (i !== itinerary.nodes.length - 1) {
+            expect(itinerary.edges[i].node1).equal(node);
+            expect(itinerary.edges[i].node2).equal(itinerary.nodes[i + 1]);
+        }
+    }
+}

package/src/{graph → router}/GraphRouter.js

@@ -1,59 +1,55 @@
 import Coordinates from '../coordinates/Coordinates.js';
 
-import Edge from './Edge.js';
-import Itinerary from './Itinerary.js';
-import Network from './Network.js';
-import Node from './Node.js';
-import MapMatching from './MapMatching.js';
-import { getDurationFromLength } from './Utils.js';
-import NoRouteFoundError from './NoRouteFoundError.js';
+import GraphEdge from '../graph/GraphEdge.js';
+import Network from '../graph/Network.js';
+import GraphNode from '../graph/GraphNode.js';
+import MapMatching from '../graph/MapMatching.js';
 
-const DEFAULT_MM_DISTANCE = 50;
-const DEFAULT_OPTIONS = { useStairs: true };
+import NoRouteFoundError from './NoRouteFoundError.js';
+import GraphRouterOptions from './GraphRouterOptions.js';
+import GraphItinerary from './GraphItinerary.js';
 
+/**
+ * @template T
+ * @abstract
+ */
 class GraphRouter {
 
-    /** @type {function} */
-    static defaultWeightFn = edge => edge.isElevator ? 30 : getDurationFromLength(edge.length);
-
-    /** @type {!Network} */
+    /** @type {!Network<T>} */
     _network;
 
     /**
-     * @param {!Network} network
-     * @param {number} mapMatchingMaxDistance
+     * @param {!Network<T>} network
      */
-    constructor(network, mapMatchingMaxDistance = DEFAULT_MM_DISTANCE) {
+    constructor(network) {
         this._network = network;
         this._mapMatching = new MapMatching(network);
-        this._mapMatching.maxDistance = mapMatchingMaxDistance;
     }
 
     /**
-     *
-     * @param {!Node|!Coordinates} start
-     * @param {!Node|!Coordinates} end
-     * @param {object} _options
-     * @returns {Itinerary}
+     * @template T
+     * @param {!GraphNode<T>|!Coordinates} start
+     * @param {!GraphNode<T>|!Coordinates} end
+     * @param {GraphRouterOptions} _options
+     * @returns {GraphItinerary<T>}
      */
-    getShortestPath(start, end, _options) {
+    getShortestPath(start, end, options = new GraphRouterOptions()) {
 
-        if (!(start instanceof Node) && !(start instanceof Coordinates)) {
+        if (!(start instanceof GraphNode) && !(start instanceof Coordinates)) {
             throw new Error('Unknown start type');
         }
 
-        if (!(end instanceof Node) && !(end instanceof Coordinates)) {
+        if (!(end instanceof GraphNode) && !(end instanceof Coordinates)) {
             throw new Error('Unknown end type');
         }
 
-        const options = Object.assign({}, DEFAULT_OPTIONS, _options);
-        const acceptEdgeFn = options.useStairs ? () => true : edge => !edge.isStairs;
-        const weightEdgeFn = GraphRouter.defaultWeightFn;
+        const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
+        this._mapMatching.maxDistance = projectionMaxDistance;
 
         const createdNodes = [];
 
         const retrieveOrCreateNearestNode = point => {
-            if (point instanceof Node) {
+            if (point instanceof GraphNode) {
                 return point;
             }
 
@@ -69,7 +65,7 @@ class GraphRouter {
                     + `> ${this._mapMatching.maxDistance.toFixed(0)} meters`
                 );
             }
-            if (proj.nearestElement instanceof Node) {
+            if (proj.nearestElement instanceof GraphNode) {
                 return proj.nearestElement;
             }
             // if (proj.nearestElement instanceof Edge)
@@ -87,39 +83,39 @@ class GraphRouter {
             }
         };
 
-        try {
-            const startNode = retrieveOrCreateNearestNode(start);
-            const endNode = retrieveOrCreateNearestNode(end);
+        const startNode = retrieveOrCreateNearestNode(start);
+        const endNode = retrieveOrCreateNearestNode(end);
 
-            const path = this.getShortestPathInternal(startNode, endNode, acceptEdgeFn, weightEdgeFn);
-
-            if (!path || !path.length) {
-                throw new NoRouteFoundError(start, end);
-            }
+        const graphItinerary = this.getShortestPathBetweenGraphNodes(
+            startNode,
+            endNode,
+            acceptEdgeFn,
+            weightEdgeFn
+        );
+        graphItinerary.start = start instanceof GraphNode ? start.coords : start;
+        graphItinerary.end = end instanceof GraphNode ? end.coords : end;
 
-            const route = Itinerary.fromNetworkNodes(path,
-                start instanceof Node ? start._coords : start,
-                end instanceof Node ? end.coords : end);
+        removeCreatedNodes();
 
-            removeCreatedNodes();
-            return route;
-        } catch (e) {
-            removeCreatedNodes();
-            throw e;
+        if (!graphItinerary.nodes.length) {
+            throw new NoRouteFoundError(start, end);
         }
+
+        return graphItinerary;
+
     }
 
     /**
-     * @param {Edge} edge
+     * @param {GraphEdge<T>} edge
      * @param {Coordinates} point
      */
     createNodeInsideEdge(edge, point) {
         const a = edge.node1;
         const b = edge.node2;
 
-        const m = new Node(point);
+        const m = new GraphNode(point);
         m.coords.level = edge.level;
-        m.name = edge.name;
+        m.builtFrom = edge.builtFrom;
 
         const u = edge.clone();
         u.node1 = a;
@@ -143,7 +139,7 @@ class GraphRouter {
     }
 
     /**
-     * @param {Node} _node
+     * @param {GraphNode<T>} _node
      */
     removeNodeFromPreviouslyCreatedEdge(_node) {
         const u = _node.edges[0];
@@ -163,7 +159,7 @@ class GraphRouter {
         );
     }
 
-    getShortestPathInternal(start, end, acceptEdgeFn, weightFn) {
+    getShortestPathBetweenGraphNodes(start, end, acceptEdgeFn, weightFn) {
         const distanceMap = {},
             checking = {},
             vertexList = {},
@@ -247,11 +243,14 @@ class GraphRouter {
             delete vertexList[current];
         }
 
+        const edgesWeights = [];
+
         // now we have the most efficient paths for all vertices
         // build the path for the user specified vertex(end)
         let endId = end.uniqueRouterId;
         while (parentVertices[endId]) {
             path.unshift(vertexNodes[endId]);
+            edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
             endId = parentVertices[endId];
         }
         if (path.length !== 0) {
@@ -263,7 +262,8 @@ class GraphRouter {
             delete vertex.uniqueRouterId;
         });
 
-        return path;
+        // This clone the itinerary and temporary nodes
+        return GraphItinerary.fromNetworkNodes(path, edgesWeights);
     }
 }
 export default GraphRouter;