@wemap/geo 0.2.1 → 0.3.1

package/src/graph/GraphRouter.spec.js

@@ -0,0 +1,72 @@
+import { expect } from 'chai';
+
+import GraphRouter from './GraphRouter';
+
+import {
+    network, nodes, itineraryStart, itineraryEnd
+} from '../../tests/CommonTest';
+
+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);
+
+        const isEdgeInArray = (edgeArray, edge) => edgeArray.find(_edge =>
+            edge.node1 === _edge.node1
+            && edge.node2 === _edge.node2
+            && edge.level === _edge.level
+            && edge.data === _edge.data
+        );
+        const areEdgeArrayEquals = (edgeArray1, edgeArray2) => {
+            if (edgeArray1.length !== edgeArray2.length) {
+                return false;
+            }
+            for (let j = 0; j < edgeArray1.length; j++) {
+                if (!isEdgeInArray(edgeArray2, edgeArray1[j])) {
+                    return false;
+                }
+            }
+            for (let j = 0; j < edgeArray2.length; j++) {
+                if (!isEdgeInArray(edgeArray1, edgeArray2[j])) {
+                    return false;
+                }
+            }
+            return true;
+        };
+
+        expect(network.nodes.length).equals(nodesBefore.length);
+        for (let i = 0; i < nodesBefore.length; i++) {
+            const node = network.nodes[i];
+            const nodeBefore = nodesBefore[i];
+            expect(nodeBefore).equals(node);
+            expect(areEdgeArrayEquals(node.edges, nodeBefore.edges)).true;
+        }
+
+        expect(areEdgeArrayEquals(network.edges, edgesBefore)).true;
+    });
+
+    it('router returns shortest path', () => {
+
+        expect(itinerary.nodes.length).equal(11);
+
+        for (let i = 1; i <= 10; i++) {
+            expect(itinerary.nodes[i].data).equal(nodes[i + 6].data);
+        }
+
+    });
+
+    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,9 +1,16 @@
-
+/* eslint-disable max-statements */
 import { WGS84 } from '@wemap/geo';
 
 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';
+
+const SKIP_STEP_ANGLE_MAX = deg2rad(20);
 
 /**
  * Main attributes are:
@@ -19,15 +26,63 @@ class Itinerary extends Network {
         super();
         this.start = null;
         this.end = null;
-        this.length = -1;
+        this._steps = null;
+        this._length = 0;
+
+        // This array is for computational time gain only
+        // It helps to know if this.edges is in the same direction than the current itinerary
+        // true = opposite direction
+        // false = same direction
+        // if this.edgeDirectionReversed[i] is true, this.edges[i].node2 is before
+        //  this.edges[i].node1 following the current itinerary
+        this._edgesDirectionReversed = [];
+
+        // This array is for computational time gain only
+        // It helps to find next and previous steps by storing next steps indexes for each node
+        // The size of this array is the same than this.nodes
+        this._nextStepsIndexes = null;
+
+        this.mapMatching = new MapMatching(this);
+    }
+
+    /**
+     * Get route length
+     */
+    get length() {
+        if (!this._length) {
+            this._length = this.edges.reduce((acc, edge) => acc + edge.length, 0);
+        }
+        return this._length;
+    }
+
+    /**
+     * Get route duration with default speed
+     */
+    get duration() {
+        return this.getDuration();
     }
 
     /**
      * Get route duration
      * @param {Number} speed in km/h
      */
-    getDuration(speed = 4) {
-        return (speed * 1000 / 3600) * this.length;
+    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);
+    }
+
+    get steps() {
+        if (!this._steps) {
+            this.generateSteps();
+        }
+        return this._steps;
     }
 
     /**
@@ -51,6 +106,147 @@ class Itinerary extends Network {
         return null;
     }
 
+    getNextNode(graphElement) {
+        if (graphElement instanceof Edge) {
+            const indexOfEdge = this.edges.indexOf(graphElement);
+            if (indexOfEdge !== -1) {
+                return this.nodes[indexOfEdge + 1];
+            }
+        }
+
+        if (graphElement instanceof Node) {
+            const indexOfNode = this.nodes.indexOf(graphElement);
+            if (indexOfNode !== -1 && indexOfNode !== this.nodes.length - 1) {
+                return this.nodes[indexOfNode + 1];
+            }
+        }
+        return null;
+    }
+
+    getNextEdge(graphElement) {
+        if (graphElement instanceof Edge) {
+            const indexOfEdge = this.edges.indexOf(graphElement);
+            if (indexOfEdge !== -1 && indexOfEdge !== this.edges.length - 1) {
+                return this.edges[indexOfEdge + 1];
+            }
+        }
+
+        if (graphElement instanceof Node) {
+            const indexOfNode = this.nodes.indexOf(graphElement);
+            if (indexOfNode !== -1 && indexOfNode !== this.edges.length) {
+                return this.edges[indexOfNode];
+            }
+        }
+        return null;
+    }
+
+    getNextStep(graphElement) {
+
+        if (graphElement instanceof Edge) {
+            const indexOfEdge = this.edges.indexOf(graphElement);
+            if (indexOfEdge !== -1) {
+                return this.getNextStepFromEdgeId(indexOfEdge);
+            }
+        } else if (graphElement instanceof Node) {
+            const indexOfNode = this.nodes.indexOf(graphElement);
+            if (indexOfNode !== -1) {
+                return this.getNextStepFromNodeId(indexOfNode);
+            }
+        }
+        return null;
+    }
+
+    getNextStepFromEdgeId(edgeId) {
+        return this.steps[this._nextStepsIndexes[edgeId + 1]];
+    }
+
+    getNextStepFromNodeId(nodeId) {
+        return this.steps[this._nextStepsIndexes[nodeId]];
+    }
+
+    getPreviousStep(graphElement) {
+
+        if (graphElement instanceof Edge) {
+            const indexOfEdge = this.edges.indexOf(graphElement);
+            if (indexOfEdge !== -1) {
+                return this.getPreviousStepFromEdgeId(indexOfEdge);
+            }
+        } else if (graphElement instanceof Node) {
+            const indexOfNode = this.nodes.indexOf(graphElement);
+            if (indexOfNode !== -1) {
+                return this.getPreviousStepFromNodeId(indexOfNode);
+            }
+        }
+        return null;
+    }
+
+    getPreviousStepFromEdgeId(edgeId) {
+        const previousStepId = this._nextStepsIndexes[edgeId + 1] - 1;
+        if (previousStepId !== -1) {
+            return this.steps[previousStepId];
+        }
+        return null;
+    }
+
+    getPreviousStepFromNodeId(nodeId) {
+        const previousStepId = this._nextStepsIndexes[nodeId] - 1;
+        if (previousStepId !== -1) {
+            return this.steps[previousStepId];
+        }
+        return null;
+    }
+
+    getInfo(position) {
+
+        if (!(position) instanceof WGS84) {
+            return null;
+        }
+
+        const projection = this.mapMatching.getProjection(position);
+        if (!projection) {
+            return null;
+        }
+
+        const totalDistance = this.length;
+        let traveledDistance = 0;
+        let nextStep, previousStep;
+
+        if (projection.nearestElement instanceof Node) {
+
+            let currentNodeIndex = 0;
+            while (this.nodes[currentNodeIndex] !== projection.nearestElement) {
+                traveledDistance += this.edges[currentNodeIndex].length;
+                currentNodeIndex++;
+            }
+            nextStep = this.getNextStepFromNodeId(currentNodeIndex);
+            previousStep = this.getPreviousStepFromNodeId(currentNodeIndex);
+
+        } else if (projection.nearestElement instanceof Edge) {
+
+            let currentEdgeIndex = 0;
+            while (this.edges[currentEdgeIndex] !== projection.nearestElement) {
+                traveledDistance += this.edges[currentEdgeIndex].length;
+                currentEdgeIndex++;
+            }
+            traveledDistance += this.nodes[currentEdgeIndex].coords
+                .distanceTo(projection.projection);
+            nextStep = this.getNextStepFromEdgeId(currentEdgeIndex);
+            previousStep = this.getPreviousStepFromEdgeId(currentEdgeIndex);
+
+        } else {
+            throw new Error('No projection found');
+        }
+
+        return {
+            nextStep,
+            previousStep,
+            projection,
+            traveledDistance,
+            traveledPercentage: traveledDistance / totalDistance,
+            remainingDistance: totalDistance - traveledDistance,
+            remainingPercentage: 1 - traveledDistance / totalDistance
+        };
+    }
 
     static fromNetworkNodes(nodes, start, end) {
 
@@ -59,32 +255,26 @@ class Itinerary extends Network {
          */
 
         const itinerary = new Itinerary();
-        itinerary.length = 0;
+        itinerary._length = 0;
         itinerary.start = start;
         itinerary.end = end;
 
-        let nextItineraryNode;
-
         for (let i = 0; i < nodes.length; i++) {
 
             const networkNode = nodes[i];
-            const itineraryNode = nextItineraryNode ? nextItineraryNode : networkNode.clone();
 
-            itinerary.nodes.push(itineraryNode);
+            itinerary.nodes.push(networkNode);
 
             if (i === nodes.length - 1) {
                 break;
             }
-            const nextNetworkNode = nodes[i + 1];
-            nextItineraryNode = nextNetworkNode.clone();
 
+            const nextNetworkNode = nodes[i + 1];
             const networkEdge = Network.getEdgeByNodes(networkNode.edges, networkNode, nextNetworkNode);
-            const itineraryEdge = networkEdge.clone(itineraryNode, nextItineraryNode);
-            itineraryNode.edges.push(itineraryEdge);
-            nextItineraryNode.edges.push(itineraryEdge);
+            itinerary._edgesDirectionReversed.push(networkNode !== networkEdge.node1);
 
-            itinerary.edges.push(itineraryEdge);
-            itinerary.length += itineraryEdge.length;
+            itinerary.edges.push(networkEdge);
+            itinerary._length += networkEdge.length;
         }
 
         return itinerary;
@@ -97,7 +287,7 @@ class Itinerary extends Network {
      */
     static fromOrderedPointsArray(points, start, end, lngLatFormat) {
         const route = new Itinerary();
-        route.length = 0;
+        route._length = 0;
         route.start = new WGS84(start[lngLatFormat ? 1 : 0],
             start[lngLatFormat ? 0 : 1]);
         route.end = new WGS84(end[lngLatFormat ? 1 : 0],
@@ -114,12 +304,9 @@ class Itinerary extends Network {
 
             if (lastPoint) {
                 const edge = new Edge(lastPoint, currentPoint);
-
+                route._edgesDirectionReversed.push(false);
                 route.edges.push(edge);
-                route.length += edge.length;
-
-                currentPoint.edges.push(edge);
-                lastPoint.edges.push(edge);
+                route._length += edge.length;
             }
 
             route.nodes.push(currentPoint);
@@ -129,5 +316,90 @@ class Itinerary extends Network {
         return route;
     }
 
+
+    generateSteps() {
+
+        this._steps = [];
+        this._nextStepsIndexes = [];
+
+        let currentStep, previousStep;
+        let previousBearing = this.start.bearingTo(this.nodes[0].coords);
+
+        for (let i = 0; i < this.nodes.length - 1; i++) {
+
+            const node = this.nodes[i];
+            const nextNode = this.nodes[i + 1];
+            const edge = this.edges[i];
+
+            const { length } = edge;
+            const bearing = edge.bearing + (edge.node1 !== node ? Math.PI : 0);
+            const angle = diffAngle(previousBearing, bearing + Math.PI);
+
+            // If it is not the first iteration
+            if (currentStep) {
+                currentStep.nodes.push(node);
+            }
+
+            if (!currentStep || Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX) {
+
+                previousStep = currentStep;
+
+                currentStep = new Step();
+                currentStep.number = this._steps.length + 1;
+                currentStep.angle = angle;
+                currentStep.previousBearing = previousBearing;
+                currentStep.nextBearing = bearing;
+                currentStep.nodes.push(node);
+                this._steps.push(currentStep);
+
+                if (!previousStep) {
+                    currentStep.firstStep = true;
+                }
+
+                const indexOfCurrentStep = this._steps.length - 1;
+                const numberOfNodesToFill = previousStep ? previousStep.nodes.length - 1 : 1;
+                for (let j = 0; j < numberOfNodesToFill; j++) {
+                    this._nextStepsIndexes.push(indexOfCurrentStep);
+                }
+            }
+
+            currentStep.edges.push(edge);
+            currentStep._length += length;
+
+            if (i === this.nodes.length - 2) {
+                currentStep.nodes.push(nextNode);
+            }
+
+            previousBearing = bearing;
+        }
+
+        const lastNode = this.nodes[this.nodes.length - 1];
+        if (lastNode.coords !== this.end) {
+
+            const lastStep = new Step();
+            lastStep.number = this._steps.length + 1;
+            lastStep._length = 0;
+            lastStep.nextBearing = lastNode.coords.bearingTo(this.end);
+            lastStep.previousBearing = previousBearing;
+            lastStep.lastStep = true;
+            lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
+            lastStep.nodes.push(lastNode);
+            this._steps.push(lastStep);
+
+            if (!currentStep) {
+                lastStep.firstStep = true;
+            }
+
+            const indexOfCurrentStep = this._steps.length - 1;
+            const numberOfNodesToFill = currentStep ? currentStep.nodes.length - 1 : 1;
+            for (let j = 0; j < numberOfNodesToFill; j++) {
+                this._nextStepsIndexes.push(indexOfCurrentStep);
+            }
+        } else {
+            currentStep.lastStep = true;
+        }
+
+    }
+
 }
 export default Itinerary;

package/src/graph/Itinerary.spec.js

@@ -0,0 +1,168 @@
+/* eslint-disable max-statements */
+import { expect } from 'chai';
+
+import GraphRouter from './GraphRouter';
+
+import {
+    network, nodes, itineraryStart, itineraryEnd, edges
+} from '../../tests/CommonTest';
+import Level from '../coordinates/Level';
+import WGS84 from '../coordinates/WGS84';
+
+describe('Itinerary', () => {
+
+    const router = new GraphRouter(network);
+    const itinerary = router.getShortestPath(itineraryStart, itineraryEnd);
+
+    it('is readable', () => {
+
+        for (let i = 0; i < itinerary.nodes.length; i++) {
+            const node = itinerary.nodes[i];
+
+            if (i !== itinerary.nodes.length - 1) {
+
+                const reversed = itinerary._edgesDirectionReversed[i];
+                const firstNode = reversed ? itinerary.edges[i].node2 : itinerary.edges[i].node1;
+                const secondNode = reversed ? itinerary.edges[i].node1 : itinerary.edges[i].node2;
+
+                expect(firstNode).equal(node);
+                expect(secondNode).equal(itinerary.nodes[i + 1]);
+            }
+
+        }
+    });
+
+    it('verify getNextEdge() and getNextNode()', () => {
+
+        let currentNode, currentEdge;
+
+        // Iterate on nodes
+        currentNode = itinerary.nodes[0];
+        for (let i = 0; i < itinerary.nodes.length - 1; i++) {
+            currentEdge = itinerary.getNextEdge(currentNode);
+            expect(itinerary.edges.indexOf(currentEdge)).equal(i);
+
+            currentNode = itinerary.getNextNode(currentNode);
+            expect(itinerary.nodes.indexOf(currentNode)).equal(i + 1);
+        }
+        expect(itinerary.getNextNode(currentNode)).is.null;
+        expect(itinerary.getNextEdge(currentNode)).is.null;
+
+        // Iterate on edges
+        currentEdge = itinerary.edges[0];
+        for (let i = 0; i < itinerary.edges.length - 1; i++) {
+            currentNode = itinerary.getNextNode(currentEdge);
+            expect(itinerary.nodes.indexOf(currentNode)).equal(i + 1);
+
+            currentEdge = itinerary.getNextEdge(currentEdge);
+            expect(itinerary.edges.indexOf(currentEdge)).equal(i + 1);
+        }
+        const lastNode = itinerary.getNextNode(currentEdge);
+        expect(lastNode).is.not.null;
+        expect(itinerary.getNextNode(lastNode)).is.null;
+        expect(itinerary.getNextEdge(currentEdge)).is.null;
+    });
+
+    it('verify steps', () => {
+
+        const steps = itinerary.steps;
+        expect(steps.length).equal(10);
+
+        expect(steps[0].nodes[1]).equal(nodes[7]);
+        expect(steps[0].nodes[2]).equal(nodes[8]);
+
+        for (let i = 2; i <= 9; i++) {
+            expect(steps[i - 1].nodes[0]).equal(nodes[i + 6]);
+            expect(steps[i - 1].nodes[1]).equal(nodes[i + 7]);
+        }
+
+        expect(steps[9].nodes[0]).equal(nodes[16]);
+    });
+
+
+    it('verify next and previous steps', () => {
+
+        const {
+            steps, _nextStepsIndexes
+        } = itinerary;
+        const itineraryNodes = itinerary.nodes;
+        const itineraryEdges = itinerary.edges;
+
+        expect(_nextStepsIndexes.length).equal(itinerary.nodes.length);
+
+        expect(_nextStepsIndexes[0]).equal(0);
+        expect(_nextStepsIndexes[1]).equal(1);
+        for (let i = 2; i <= 10; i++) {
+            expect(_nextStepsIndexes[i]).equal(i - 1);
+        }
+
+        expect(itinerary.getNextStep(itineraryNodes[0])).equal(steps[0]);
+        expect(itinerary.getNextStep(itineraryNodes[1])).equal(steps[1]);
+        for (let i = 2; i <= 10; i++) {
+            expect(itinerary.getNextStep(itineraryNodes[i])).equal(steps[i - 1]);
+        }
+
+        expect(itinerary.getNextStep(itineraryEdges[0])).equal(steps[1]);
+        for (let i = 1; i <= 9; i++) {
+            expect(itinerary.getNextStep(itineraryEdges[i])).equal(steps[i]);
+        }
+
+
+        expect(itinerary.getPreviousStep(itineraryNodes[0])).is.null;
+        expect(itinerary.getPreviousStep(itineraryNodes[1])).equal(steps[0]);
+        for (let i = 3; i <= 10; i++) {
+            expect(itinerary.getPreviousStep(itineraryNodes[i])).equal(steps[i - 2]);
+        }
+
+        expect(itinerary.getPreviousStep(itineraryEdges[0])).equal(steps[0]);
+        for (let i = 2; i <= 9; i++) {
+            expect(itinerary.getPreviousStep(itineraryEdges[i])).equal(steps[i - 1]);
+        }
+
+    });
+
+    it('info', () => {
+        let itineraryInfo;
+        let currentPosition;
+
+        currentPosition = new WGS84(43.6092811, 3.8842406, null, new Level(2));
+        itineraryInfo = itinerary.getInfo(currentPosition);
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection).is.not.undefined;
+        expect(itineraryInfo.projection.projection).instanceOf(WGS84);
+        expect(itineraryInfo.projection.nearestElement).equal(edges[7]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(30.35, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(0.79, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(0.97, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(0.03, 0.01);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[0]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[1]);
+
+        currentPosition = new WGS84(43.6092811, 3.8842406, null, null);
+        itineraryInfo = itinerary.getInfo(currentPosition);
+        expect(itineraryInfo).is.null;
+
+
+        currentPosition = new WGS84(43.6093476, 3.8841978, null, new Level(2));
+        itineraryInfo = itinerary.getInfo(currentPosition);
+        expect(itineraryInfo.projection.nearestElement).equal(edges[11]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(17.37, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(13.76, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(0.56, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(0.44, 0.01);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[4]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[5]);
+
+
+        currentPosition = new WGS84(43.6093182, 3.8842847, null, new Level(1));
+        itineraryInfo = itinerary.getInfo(currentPosition);
+        expect(itineraryInfo.projection.nearestElement).equal(nodes[15]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(5.02, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(26.11, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(0.16, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(0.84, 0.01);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[7]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[8]);
+    });
+
+});

package/src/graph/MapMatching.js

@@ -35,7 +35,7 @@ class MapMatching {
         this.network = network;
     }
 
-    getProjection(location, useDistance = true, useBearing = true, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
+    getProjection(location, useDistance = false, useBearing = false, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
 
         if (!this.network) {
             return null;
@@ -49,6 +49,12 @@ class MapMatching {
             return null;
         }
 
+        const updateProjectionLevelFromEdge = (_edge, _projection) => {
+            if (_edge.level) {
+                _projection.level = _edge.level.clone();
+            }
+        };
+
         const projection = {};
         projection.origin = location;
         projection.distanceFromNearestElement = Number.MAX_VALUE;
@@ -83,6 +89,7 @@ class MapMatching {
                     projection.distanceFromNearestElement = distNode1;
                     projection.nearestElement = edge.node1;
                     projection.projection = edge.node1.coords.clone();
+                    updateProjectionLevelFromEdge(edge, projection.projection);
                 }
 
                 // Check node 2
@@ -92,12 +99,14 @@ class MapMatching {
                     projection.distanceFromNearestElement = distNode2;
                     projection.nearestElement = edge.node2;
                     projection.projection = edge.node2.coords.clone();
+                    updateProjectionLevelFromEdge(edge, projection.projection);
                 }
             }
 
             // Check edge
             const segmentProjection = location.getProjection(edge);
             if (segmentProjection) {
+                updateProjectionLevelFromEdge(edge, segmentProjection);
                 const distEdge = location.distanceTo(segmentProjection);
                 if (distEdge < projection.distanceFromNearestElement
                     && (!useDistance || distEdge <= this._maxDistance)) {