@wemap/geo 6.0.0 → 6.2.3

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "6.0.0",
+    "version": "6.2.3",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -30,5 +30,5 @@
         "@wemap/logger": "^6.0.0",
         "@wemap/maths": "^6.0.0"
     },
-    "gitHead": "a377d6fd98b48ce0e083ece1c695642947c456cc"
+    "gitHead": "e88b0f15de31c30588aaacdadcbad2da46f9673d"
 }

package/src/Utils.js

@@ -85,6 +85,10 @@ export function trimRoute(route, startPosition = route[0], length = Number.MAX_V
     let currentPointIndex;
     let cumulativeDistance = 0;
 
+    if (route.length <= 1) {
+        throw new Error('Route must have at least 2 points');
+    }
+
     for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
 
         const p1 = route[currentPointIndex - 1];

package/src/Utils.spec.js

@@ -60,6 +60,8 @@ describe('Geo Utils', () => {
         const route = [p1, p2, p3];
 
         expect(() => trimRoute(route, new Coordinates(0, 0))).throw(Error);
+        expect(() => trimRoute([p1], p1)).throw(Error);
+        expect(() => trimRoute([], null)).throw(Error);
 
         newRoute = trimRoute(route);
         expect(newRoute.length).equals(3);

package/src/coordinates/Level.js

@@ -7,6 +7,18 @@ import Logger from '@wemap/logger';
  */
 class Level {
 
+    /** @type {number?} */
+    val = null;
+
+    /** @type {boolean} */
+    isRange = false;
+
+    /** @type {number?} */
+    low = null;
+
+    /** @type {number?} */
+    up = null;
+
     /**
      * Level constructor
      *  1 argument: level is not a range and first argument is the level

package/src/coordinates/Level.spec.js

@@ -12,13 +12,13 @@ Logger.enable(false);
 const checkSingle = (_level, _value) => {
     expect(_level.isRange).false;
     expect(_level.val).equals(_value);
-    expect(_level.low).undefined;
-    expect(_level.up).undefined;
+    expect(_level.low).is.null;
+    expect(_level.up).is.null;
 };
 
 const checkRange = (_level, _value1, _value2) => {
     expect(_level.isRange).true;
-    expect(_level.val).undefined;
+    expect(_level.val).is.null;
     expect(_level.low).equals(Math.min(_value1, _value2));
     expect(_level.up).equals(Math.max(_value1, _value2));
 };

package/src/graph/GraphNode.js

@@ -19,6 +19,9 @@ class GraphNode {
     /** @type {?T} */
     builtFrom = null;
 
+    /** @type {boolean} */
+    io = false;
+
     /**
      * @param {Coordinates} coords
      * @param {T} builtFrom
@@ -74,6 +77,7 @@ class GraphNode {
         const node = new GraphNode(this.coords);
         node.edges = this.edges.slice(0);
         node.builtFrom = this.builtFrom;
+        node.io = this.io;
         return node;
     }
 
@@ -94,7 +98,7 @@ class GraphNode {
     }
 
     generateLevelFromEdges() {
-        let tmpLevel;
+        let tmpLevel = null;
         for (let i = 0; i < this.edges.length; i++) {
             const edge = this.edges[i];
             if (edge.level) {
@@ -196,6 +200,16 @@ class GraphNode {
         return true;
     }
 
+    /**
+     * Set node.io to true for nodes that make the link between
+     * indoor and outdoor edges
+     */
+    checkIO() {
+        this.io = this._coords.level !== null
+            && this.edges.some(edge => edge.level === null);
+        return true;
+    }
+
     /**
      * @param {GraphNode[]} nodes
      */
@@ -208,10 +222,15 @@ class GraphNode {
         // In some cases, node levels cannot be retrieve just using adjacent edges
         // (e.g stairs without network at one of its bounds)
         // To infer this node level, we use inferNodeLevelByRecursion()
-        return nodes.reduce((acc, node) => acc
+        const res = nodes.reduce((acc, node) => acc
             && node.inferNodeLevelByNeighboors()
             && node.inferNodeLevelByRecursion()
         , true);
+
+        // Finally define nodes that are links between indoor and outdoor
+        nodes.forEach(node => node.checkIO());
+
+        return res;
     }
 }
 

package/src/graph/MapMatching.js

@@ -1,6 +1,7 @@
 /* eslint-disable complexity */
 /* eslint-disable max-statements */
 import { diffAngleLines } from '@wemap/maths';
+import { GraphEdge } from '@wemap/geo';
 
 import Constants from '../Constants.js';
 import Coordinates from '../coordinates/Coordinates.js';
@@ -71,6 +72,12 @@ class MapMatching {
      * @returns {boolean} an array of two elements.
      *  First is true if projection will be used on the specified edge, false otherwise.
      *  Second is true if projection will be used on the nodes of the specified edge, false otherwise.
+     *
+     * @param {GraphEdge} edge
+     * @param {Coordinates} location
+     * @param {boolean} useBearing
+     * @param {boolean} useMultiLevelSegments
+     * @param {Function} acceptEdgeFn
      */
     _shouldProjectOnEdgeAndNodes(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
 
@@ -95,11 +102,11 @@ class MapMatching {
             checkEdge = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node1.coords.level)) {
+        if (!Level.equalsTo(location.level, edge.node1.coords.level) && !edge.node1.io) {
             checkNode1 = false;
         }
 
-        if (!Level.equalsTo(location.level, edge.node2.coords.level)) {
+        if (!Level.equalsTo(location.level, edge.node2.coords.level) && !edge.node2.io) {
             checkNode2 = false;
         }
 

package/src/router/GraphItinerary.js

@@ -36,8 +36,16 @@ class GraphItinerary {
 
         itinerary.nodes = networkNodes.map(node => {
             const newNode = node.clone();
+
             // Remove node edges, they will be added later.
             newNode.edges = [];
+
+            // Let consider io nodes level = null for GraphItinerary
+            if (newNode.io) {
+                newNode.coords = newNode.coords.clone();
+                newNode.coords.level = null;
+            }
+
             return newNode;
         });
 

package/src/router/GraphRouter.js

@@ -86,12 +86,19 @@ class GraphRouter {
         const startNode = retrieveOrCreateNearestNode(start);
         const endNode = retrieveOrCreateNearestNode(end);
 
-        const graphItinerary = this.getShortestPathBetweenGraphNodes(
-            startNode,
-            endNode,
-            acceptEdgeFn,
-            weightEdgeFn
-        );
+        let graphItinerary;
+
+        if (startNode === endNode) {
+            graphItinerary = GraphItinerary.fromNetworkNodes([startNode], []);
+        } else {
+            graphItinerary = this.getShortestPathBetweenGraphNodes(
+                startNode,
+                endNode,
+                acceptEdgeFn,
+                weightEdgeFn
+            );
+        }
+
         graphItinerary.start = start instanceof GraphNode ? start.coords : start;
         graphItinerary.end = end instanceof GraphNode ? end.coords : end;
 

package/src/router/GraphRouter.spec.js

@@ -133,6 +133,14 @@ describe('GraphRouter', () => {
         expect(getNodesNames(itinerary)).deep.equals(['p0', 'p1', 'p2']);
     });
 
+    it('use common node', () => {
+        itinerary = getShortestPath(router, start, nodes[0]);
+        expect(getNodesNames(itinerary)).deep.equals(['p0']);
+
+        itinerary = getShortestPath(router, nodes[0], start);
+        expect(getNodesNames(itinerary)).deep.equals(['p0']);
+    });
+
     it('errors', () => {
 
         expect(() => getShortestPath(router, null, end)).throw(Error);
@@ -141,8 +149,6 @@ describe('GraphRouter', () => {
         expect(() => getShortestPath(router, start, new Coordinates(0, 0))).throw(NoRouteFoundError);
         expect(() => getShortestPath(router, new Coordinates(43.609226, 3.8841013), null)).throw(Error);
 
-        expect(() => getShortestPath(router, start, nodes[0])).throw(NoRouteFoundError);
-        expect(() => getShortestPath(router, nodes[0], start)).throw(NoRouteFoundError);
     });
 });