@wemap/geo 4.0.3 → 4.0.10

package/index.js

@@ -17,6 +17,8 @@ export { default as AbsoluteHeading } from './src/rotations/AbsoluteHeading.js';
 export { default as Edge } from './src/graph/Edge.js';
 export { default as GraphRouter } from './src/graph/GraphRouter.js';
 export { default as Itinerary } from './src/graph/Itinerary.js';
+export { default as ItineraryInfo } from './src/graph/ItineraryInfo.js';
+export { default as LevelChange } from './src/graph/LevelChange.js';
 export { default as Network } from './src/graph/Network.js';
 export { default as Node } from './src/graph/Node.js';
 export { default as MapMatching } from './src/graph/MapMatching.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "4.0.3",
+    "version": "4.0.10",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -30,5 +30,5 @@
         "@wemap/logger": "^4.0.0",
         "@wemap/maths": "^4.0.3"
     },
-    "gitHead": "91a82028ddda32038999582da381d1d0d8acd091"
+    "gitHead": "684e1328f164054572b32f241e3e3b85cc3b1362"
 }

package/src/Utils.js

@@ -90,14 +90,14 @@ export function trimRoute(route, startPosition = route[0], length = Number.MAX_V
         const p1 = route[currentPointIndex - 1];
         const p2 = route[currentPointIndex];
 
-        if (startPosition.equalsTo(p1)) {
+        if (Coordinates.equalsTo(startPosition, p1)) {
             newRoute.push(p1);
             previousPoint = p1;
             break;
         }
 
         const proj = startPosition.getSegmentProjection(p1, p2);
-        if (proj && proj.equalsTo(startPosition) && !proj.equalsTo(p2)) {
+        if (proj && Coordinates.equalsTo(startPosition, proj) && !proj.equalsTo(p2)) {
             newRoute.push(proj);
             previousPoint = proj;
             break;

package/src/graph/Itinerary.js

@@ -3,6 +3,7 @@ import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
 
 import Edge from './Edge.js';
+import ItineraryInfo from './ItineraryInfo.js';
 import MapMatching from './MapMatching.js';
 import Network from './Network.js';
 import Node from './Node.js';
@@ -249,7 +250,7 @@ class Itinerary extends Network {
 
     /**
      * @param {Coordinates} position
-     * @returns {?object}
+     * @returns {ItineraryInfo}
      */
     getInfo(position) {
 
@@ -290,7 +291,8 @@ class Itinerary extends Network {
 
         }
 
-        return {
+        const itineraryInfo = new ItineraryInfo();
+        return Object.assign(itineraryInfo, {
             nextStep,
             previousStep,
             projection,
@@ -298,7 +300,7 @@ class Itinerary extends Network {
             traveledPercentage: traveledDistance / totalDistance,
             remainingDistance: totalDistance - traveledDistance,
             remainingPercentage: 1 - traveledDistance / totalDistance
-        };
+        });
     }
 
     static fromNetworkNodes(nodes, start, end) {

package/src/graph/Itinerary.spec.js

@@ -506,6 +506,7 @@ describe('Multi - Level Itinerary (down)', () => {
         new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2'),
         new Edge(nodes[3], nodes[4], new Level(0), 'e3')
     ];
+    edges[1].isStairs = true;
 
     const itinerary = new Itinerary(nodes, edges);
     itinerary.start = new Coordinates(43.6091367, 3.8839298, null, new Level(1));
@@ -528,7 +529,8 @@ describe('Multi - Level Itinerary (down)', () => {
         expect(steps[1].nodes[0]).equal(nodes[1]);
         expect(steps[1].levelChange).is.not.null;
         expect(steps[1].levelChange.direction).equal('down');
-        expect(steps[1].levelChange.diff).equal(-1);
+        expect(steps[1].levelChange.difference).equal(-1);
+        expect(steps[1].levelChange.type).equal('stairs');
         expect(steps[1].nodes[1]).equal(nodes[2]);
         expect(steps[1].nodes[2]).equal(nodes[3]);
 
@@ -579,7 +581,7 @@ describe('Multi - Level Itinerary (up)', () => {
         expect(steps[1].nodes[0]).equal(nodes[1]);
         expect(steps[1].levelChange).is.not.null;
         expect(steps[1].levelChange.direction).equal('up');
-        expect(steps[1].levelChange.diff).equal(1);
+        expect(steps[1].levelChange.difference).equal(1);
         expect(steps[1].nodes[1]).equal(nodes[2]);
         expect(steps[1].nodes[2]).equal(nodes[3]);
 

package/src/graph/ItineraryInfo.js

@@ -0,0 +1,29 @@
+import Projection from './Projection.js';
+import Step from './Step.js';
+
+class ItineraryInfo {
+
+    /** @type {Step} */
+    nextStep;
+
+    /** @type {Step} */
+    previousStep;
+
+    /** @type {Projection} */
+    projection;
+
+    /** @type {number} */
+    traveledDistance;
+
+    /** @type {number} */
+    traveledPercentage;
+
+    /** @type {number} */
+    remainingDistance;
+
+    /** @type {number} */
+    remainingPercentage;
+
+}
+
+export default ItineraryInfo;

package/src/graph/LevelChange.js

@@ -0,0 +1,43 @@
+import Level from '../coordinates/Level.js';
+import Network from './Network.js';
+import Node from './Node.js';
+
+class LevelChange {
+
+    /** @type {String} [up|down] */
+    direction;
+
+    /** @type {number} [-2, -1, 1, ...] */
+    difference;
+
+    /** @type {string} [elevator|conveyor|stairs] */
+    type = null;
+
+    /**
+     * @param {Node} firstNode
+     * @param {Node} secondNode
+     * @returns {LevelChange}
+     */
+    static fromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = Network.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.isStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
+
+}
+
+export default LevelChange;

package/src/graph/Node.js

@@ -13,6 +13,9 @@ class Node {
     /** @type {string} */
     name = null;
 
+    /** @type {boolean} */
+    subwayEntrance = false;
+
     /** @type {Edge[]} */
     edges = [];
 
@@ -221,6 +224,9 @@ class Node {
         if (this.name !== null) {
             output.name = this.name;
         }
+        if (this.subwayEntrance !== null) {
+            output.subwayEntrance = this.subwayEntrance;
+        }
         return output;
     }
 
@@ -231,6 +237,9 @@ class Node {
         if (properties.name) {
             this.name = properties.name;
         }
+        if (properties.subwayEntrance) {
+            this.subwayEntrance = properties.subwayEntrance;
+        }
         return this;
     }
 }

package/src/graph/Step.js

@@ -1,6 +1,7 @@
 import Coordinates from '../coordinates/Coordinates.js';
 
 import Edge from './Edge.js';
+import LevelChange from './LevelChange.js';
 import Node from './Node.js';
 import { getDurationFromLength } from './Utils.js';
 
@@ -30,7 +31,7 @@ class Step {
     /** @type {boolean} */
     lastStep = false;
 
-    /** @type {object} */
+    /** @type {LevelChange} */
     levelChange = null;
 
     /** @type {number} */

package/src/graph/StepsGeneration.js

@@ -1,11 +1,12 @@
+/* eslint-disable complexity */
 /* eslint-disable max-statements */
 import {
     diffAngle, deg2rad
 } from '@wemap/maths';
 
 import Coordinates from '../coordinates/Coordinates.js';
-import Level from '../coordinates/Level.js';
 import Itinerary from './Itinerary.js';
+import LevelChange from './LevelChange.js';
 
 import Step from './Step.js';
 
@@ -52,7 +53,7 @@ class StepsGeneration {
             const splitStepCondition = splitByAngle || splitByLevel;
 
             // New step creation
-            if (isFirstStep || splitStepCondition) {
+            if (isFirstStep || splitStepCondition || node.isSubwayEntrance()) {
 
                 previousStep = currentStep;
 
@@ -63,11 +64,7 @@ class StepsGeneration {
                 currentStep.nextBearing = bearing;
 
                 if (splitByLevel) {
-                    const diff = Level.diff(node.coords.level, nextNode.coords.level);
-                    currentStep.levelChange = {
-                        direction: diff > 0 ? 'up' : 'down',
-                        diff
-                    };
+                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
                 }
 
                 currentStep.nodes.push(node);