@wemap/routers 10.3.1 → 10.5.0

package/helpers/InstructionManager.js

@@ -0,0 +1,155 @@
+import { roundFactor } from '@wemap/maths';
+import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
+import Step from '../src/model/Step.js';
+import { getTurnInfoFromAngle } from '../src/wemap/WemapRouterUtils.js';
+
+export default class InstructionManager {
+
+    useProposals = false;
+
+    /**
+     * @param {Step} step
+     * @returns {{type: string, direction?: string}}
+     */
+    static getInfoFromStep(step) {
+
+        let type, direction, directionExtra, levelChange;
+
+        if (step.levelChange) {
+            type = 'level-change';
+            levelChange = step.levelChange;
+        } else {
+            type = 'turn';
+            const turnInfo = getTurnInfoFromAngle(step.angle);
+            direction = turnInfo.direction;
+            directionExtra = turnInfo.directionExtra;
+        }
+
+        return {
+            type,
+            direction,
+            directionExtra,
+            levelChange,
+            name: step.name,
+            indoor: step.coords.level !== null
+        };
+    }
+
+    /**
+     * @param {Step} step
+     * @returns {string}
+     */
+    // eslint-disable-next-line max-statements
+    static getInstructionFromStep(step) {
+
+        const { direction, directionExtra } = getTurnInfoFromAngle(step.angle);
+        const isTurn = direction !== 'straight';
+
+        if (step.lastStep) {
+            if (isTurn && direction === 'left') {
+                return 'Your destination is on your left';
+            } else if (isTurn && direction === 'right') {
+                return 'Your destination is on your right';
+            }
+        }
+
+        const suffix = step.name ? ` on ${step.name}` : '';
+
+        if (step.levelChange) {
+            if (step.levelChange.direction === 'up') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go up the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go up the stairs';
+                }
+                return 'Go up' + suffix;
+            }
+            if (step.levelChange.direction === 'down') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go down the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go down the stairs';
+                }
+                return 'Go down' + suffix;
+            }
+            if (step.extras.subwayEntrance) {
+                return `Take exit ${step.extras.subwayEntranceRef}`;
+            }
+        }
+
+        if (isTurn) {
+            if (direction === 'left') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly left' + suffix;
+                }
+                return 'Turn left' + suffix;
+            }
+            if (direction === 'right') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly right' + suffix;
+                }
+                return 'Turn right' + suffix;
+            }
+        }
+
+
+        return '';
+    }
+
+
+    /**
+     * @param {ItineraryInfoManager} itineraryInfoManager
+     * @param {Coordinates} position
+     * @returns {string | null}
+     */
+    static getInstructionFromPosition(itineraryInfoManager, position) {
+        const itineraryInfo = itineraryInfoManager.getInfo(position);
+        if (!itineraryInfo) {
+            return null;
+        }
+
+        // If distance between itinerary and position is too far,
+        // something went wrong. (mapmatching.maxDistance)
+        if (this.useProposals && itineraryInfo.projection.distanceFromNearestElement > 15) {
+            return 'It seems that we are a little bit lost, please start again the localization process';
+        }
+
+        const { nextStep } = itineraryInfo;
+        if (!nextStep) {
+            return 'You are arrived';
+        }
+
+        const distNextStep = position.distanceTo(nextStep.coords);
+        const distRounded = roundFactor(distNextStep, 5);
+
+        if (this.useProposals && distNextStep > 10) {
+            return `Continue straight for ${distRounded}m`;
+        }
+
+
+        let instruction = InstructionManager.getInstructionFromStep(nextStep);
+
+        const stepWithImportantInfo = itineraryInfoManager._steps.find(step =>
+            step.levelChange
+            && step.number > itineraryInfo.nextStep.number
+            && step.coords.distanceTo(itineraryInfo.nextStep.coords) < 10
+        ) || null;
+
+        if (stepWithImportantInfo && stepWithImportantInfo.levelChange) {
+            const nextBearing = nextStep.coords.bearingTo(stepWithImportantInfo.coords);
+            const { direction } = getTurnInfoFromAngle(nextBearing - itineraryInfo.nextStep.previousBearing);
+            instruction = direction === 'straight' ? 'Continue straight' : `Turn ${direction}`;
+            const { direction: levelDirection, type: levelType } = stepWithImportantInfo.levelChange;
+            instruction += ` and take the ${levelType} going ${levelDirection}`;
+        }
+
+        if (distNextStep >= 5) {
+            instruction += ` in ${distRounded}m`;
+        }
+
+        return instruction;
+    }
+
+}

package/helpers/InstructionManagerV1.js

@@ -0,0 +1,104 @@
+import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
+import Step from '../src/model/Step.js';
+import OsrmRemoteRouter from '../src/remote/osrm/OsrmRemoteRouter.js';
+
+export default class InstructionManagerV1 {
+
+    /**
+     * @param {Step} step
+     * @returns {string}
+     */
+    // eslint-disable-next-line max-statements, complexity
+    static getInstructionFromStep(step) {
+
+        const modifier = OsrmRemoteRouter.getModifierFromAngle(step.angle);
+        let direction, directionExtra;
+        if (modifier.includes('left')) {
+            direction = 'left';
+        } else if (modifier.includes('right')) {
+            direction = 'right';
+        }
+        if (modifier.includes('slight')) {
+            directionExtra = 'slight';
+        }
+        const isTurn = modifier !== 'straight';
+
+        if (step.lastStep) {
+            if (isTurn && direction === 'left') {
+                return 'Your destination is on your left';
+            } else if (isTurn && direction === 'right') {
+                return 'Your destination is on your right';
+            }
+        }
+
+        const suffix = step.name ? ` on ${step.name}` : '';
+
+        if (step.levelChange) {
+            if (step.levelChange.direction === 'up') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go up the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go up the stairs';
+                }
+                return 'Go up' + suffix;
+            }
+            if (step.levelChange.direction === 'down') {
+                if (step.levelChange.type === 'conveyor') {
+                    return 'Go down the escalator';
+                }
+                if (step.levelChange.type === 'stairs') {
+                    return 'Go down the stairs';
+                }
+                return 'Go down' + suffix;
+            }
+            if (step.extras.subwayEntrance) {
+                return `Take exit ${step.extras.subwayEntranceRef}`;
+            }
+        }
+
+        if (isTurn) {
+            if (direction === 'left') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly left' + suffix;
+                }
+                return 'Turn left' + suffix;
+            }
+            if (direction === 'right') {
+                if (directionExtra === 'slight') {
+                    return 'Turn slightly right' + suffix;
+                }
+                return 'Turn right' + suffix;
+            }
+        }
+
+
+        return '';
+    }
+
+
+    /**
+     * @param {ItineraryInfoManager} itineraryInfoManager
+     * @param {Coordinates} position
+     * @returns {string | null}
+     */
+    static getInstructionFromPosition(itineraryInfoManager, position) {
+        const itineraryInfo = itineraryInfoManager.getInfo(position);
+        if (!itineraryInfo) {
+            return null;
+        }
+
+        const { nextStep } = itineraryInfo;
+        if (!nextStep) {
+            return null;
+        }
+
+        const distNextStep = position.distanceTo(nextStep.coords);
+        const nextStep2 = itineraryInfoManager._steps.find((step) => step.number > nextStep.number);
+        if (distNextStep < 3 && nextStep2) {
+            return InstructionManagerV1.getInstructionFromStep(nextStep2);
+        }
+
+        return InstructionManagerV1.getInstructionFromStep(nextStep);
+    }
+}

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "10.3.1",
+    "version": "10.5.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -30,10 +30,10 @@
         "@turf/boolean-point-in-polygon": "^6.5.0",
         "@turf/convex": "^6.5.0",
         "@turf/helpers": "^6.5.0",
-        "@wemap/geo": "^10.3.1",
+        "@wemap/geo": "^10.5.0",
         "@wemap/logger": "^10.0.0",
         "@wemap/maths": "^10.3.1",
-        "@wemap/osm": "^10.3.1"
+        "@wemap/osm": "^10.5.0"
     },
-    "gitHead": "e4775e59dd3db76cf7b3d1e63a3e2402bf5f0088"
+    "gitHead": "da571076de6bd9f4f2653d097763ff1244a36ebb"
 }

package/src/wemap-meta/IOMap.js

@@ -3,7 +3,7 @@ import convexHullFn from '@turf/convex';
 import { polygon as turfPolygon } from '@turf/helpers';
 
 import { Coordinates, GraphNode, GraphRouter, Network, NoRouteFoundError } from '@wemap/geo';
-import { OsmParser, OsmNetworkUtils } from '@wemap/osm';
+import { OsmParser, OsmNetworkUtils, OsmElement } from '@wemap/osm';
 import { Itinerary, WemapRouterOptions, WemapRouterUtils } from '@wemap/routers';
 
 import Constants from '../Constants.js';
@@ -13,16 +13,22 @@ class IOMap {
     /** @type {?string} */
     name;
 
-    /** @type {!GraphRouter} */
+    /** @type {!Network<OsmElement>} */
+    network;
+
+    /** @type {!GraphRouter<OsmElement>} */
     router;
 
     /** @type {!([number, number][])} */
     bounds;
 
 
-    /** @type {!(GraphNode[])} */
+    /** @type {!(GraphNode<OsmElement>[])} */
     entryPoints;
 
+    /** @type {number[]} */
+    disabledWays = [];
+
     /**
      * @param {Network} network The network of the map
      * @param {GraphNode[]} entryPoints The map vertex that can be used to go inside / outside a IOMap
@@ -33,6 +39,7 @@ class IOMap {
     constructor(network, entryPoints, bounds = null, name = null) {
 
         this.name = name;
+        this.network = network;
         this.router = new GraphRouter(network);
 
         // Entry points
@@ -189,6 +196,16 @@ class IOMap {
         // Transform a network itinerary (nodes, edges...) to a router itinerary (legs, steps...)
         return WemapRouterUtils.createItineraryFromGraphItinerary(graphItinerary, Constants.ROUTING_MODE.WALK);
     }
+
+    enableWay(osmId) {
+        const edges = this.network.edges.filter(edge => edge.builtFrom.id === osmId);
+        this.router.disabledEdges = this.router.disabledEdges.filter(edge => !edges.includes(edge));
+    }
+
+    disableWay(osmId) {
+        const edges = this.network.edges.filter(edge => edge.builtFrom.id === osmId);
+        this.router.disabledEdges.push(...edges);
+    }
 }
 
 export default IOMap;