@wemap/routers 6.2.2 → 7.0.0

package/src/remote/osrm/OsrmRemoteRouter.js

@@ -0,0 +1,331 @@
+/* eslint-disable max-statements */
+
+import { Level, Coordinates } from '@wemap/geo';
+import { rad2deg, positiveMod } from '@wemap/maths';
+
+import Itinerary from '../../model/Itinerary.js';
+import { generateStepsMetadata } from '../RemoteRouterUtils.js';
+import RouterResponse from '../../model/RouterResponse.js';
+import Leg from '../../model/Leg.js';
+import Step from '../../model/Step.js';
+import LevelChange from '../../model/LevelChange.js';
+import RemoteRouter from '../RemoteRouter.js';
+import Constants from '../../Constants.js';
+import RoutingModeCorrespondanceNotFound from '../RoutingModeCorrespondanceNotFound.js';
+import RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance = new Map();
+inputModeCorrespondance.set(Constants.ROUTING_MODE.CAR, 'driving');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.WALK, 'walking');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BIKE, 'bike');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BUS, 'bus');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.MULTI, 'walking');
+
+
+/**
+ * Singleton.
+ */
+class OsrmRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'osrm';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const osrmMode = inputModeCorrespondance.get(mode);
+        if (!osrmMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+        }
+
+        let url = endpointUrl + '/route/v1/' + osrmMode + '/';
+        url += waypoints.map(waypoint => [waypoint.longitude + ',' + waypoint.latitude]).join(';');
+        url += '?geometries=geojson&overview=full&steps=true';
+
+        return url;
+    }
+
+    /**
+     * @param {Coordinates} coordinates
+     * @returns {object}
+     */
+    coordinatesToJson(coordinates) {
+        const output = [coordinates.lng, coordinates.lat];
+        if (coordinates.level) {
+            output.push(coordinates.level.toString());
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        const output = new Coordinates(json[1], json[0]);
+        if (json.length > 2) {
+            output.level = Level.fromString(json[2]);
+        }
+        return output;
+    }
+
+    nodesToJsonCoords(nodes) {
+        return nodes.map(node => this.coordinatesToJson(node.coords));
+    }
+
+
+    getModifierFromAngle(_angle) {
+
+        const angle = positiveMod(rad2deg(_angle), 360);
+
+        if (angle > 0 && angle < 60) {
+            return 'sharp right';
+        }
+        if (angle >= 60 && angle < 140) {
+            return 'right';
+        }
+        if (angle >= 140 && angle < 160) {
+            return 'slight right';
+        }
+        if (angle >= 160 && angle <= 200) {
+            return 'straight';
+        }
+        if (angle > 200 && angle <= 220) {
+            return 'slight left';
+        }
+        if (angle > 220 && angle <= 300) {
+            return 'left';
+        }
+        if (angle > 300 && angle < 360) {
+            return 'sharp left';
+        }
+        return 'u turn';
+    }
+
+
+    noRouteFoundJson(message) {
+        return {
+            'code': 'NoRoute',
+            message
+        };
+    }
+
+    /**
+     * @param {Itinerary} itinerary
+     * @returns {object}
+     */
+    itineraryToOsrmJson(itinerary) {
+
+        const lastLegId = itinerary.legs.length - 1;
+
+        const jsonLegs = itinerary.legs.map(({ distance, duration, coords, steps }, idLeg) => {
+
+            const lastStepId = steps.length - 1;
+
+            return {
+                distance,
+                duration,
+                steps: steps.map((step, idStep, arr) => {
+
+                    let type = idStep === 0 && idLeg === 0 ? 'depart' : 'turn';
+                    type = idStep === lastStepId && idLeg === lastLegId ? 'arrive' : type;
+
+                    const stepCoordsIdx = coords.findIndex(p => p.equalsTo(step.coords));
+                    const nextStepCoordsIdx = idStep === lastStepId
+                        ? stepCoordsIdx
+                        : coords.findIndex(p => p.equalsTo(arr[idStep + 1].coords));
+
+                    const jsonStep = {
+                        geometry: {
+                            type: 'LineString',
+                            coordinates: coords.slice(stepCoordsIdx, nextStepCoordsIdx + 1).map(this.coordinatesToJson)
+                        },
+                        distance: step.distance,
+                        duration: step.duration,
+                        name: step.name,
+                        maneuver: {
+                            bearing_before: rad2deg(step.previousBearing),
+                            bearing_after: rad2deg(step.nextBearing),
+                            location: this.coordinatesToJson(step.coords),
+                            modifier: this.getModifierFromAngle(step.angle),
+                            type
+                        }
+                    };
+                    if (step.levelChange !== null) {
+                        jsonStep.levelChange = step.levelChange.toJson();
+                    }
+                    if (typeof step.extras === 'object' && Object.keys(step.extras).length !== 0) {
+                        jsonStep.extras = step.extras;
+                    }
+
+                    return jsonStep;
+                })
+            };
+        });
+
+        return {
+            'code': 'Ok',
+            'routes': [
+                {
+                    'geometry': {
+                        'type': 'LineString',
+                        'coordinates': itinerary.coords.map(this.coordinatesToJson)
+                    },
+                    'legs': jsonLegs,
+                    'distance': itinerary.distance,
+                    'duration': itinerary.duration,
+                    'weight_name': 'routability',
+                    'weight': 0
+                }
+            ],
+            'waypoints': []
+        };
+    }
+
+    /**
+     * @param {object} jsonSteps
+     * @param {Coordinates[]} legCoords
+     * @returns {Step[]}
+     */
+    parseJsonSteps(jsonSteps, legCoords) {
+
+        if (!jsonSteps) {
+            return [];
+        }
+
+        return jsonSteps.map(jsonStep => {
+
+            const step = new Step();
+            step.coords = this.jsonToCoordinates(jsonStep.maneuver.location);
+
+            // Sometimes, OSRM step does not have the same coordinates than a point in legCoords.
+            // ex: first step of https://routing.getwemap.com/route/v1/walking/2.33222164147,48.87084765712;2.3320734,48.8730212?geometries=geojson&overview=full&steps=true
+            // That is why we look for the closest point.
+            const distances = legCoords.map(coords => coords.distanceTo(step.coords));
+            const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+            if (idStepCoordsInLeg < 0) {
+                throw new Error('Osrm Parser: Cannot find step coords in leg coordinates');
+            }
+            step._idCoordsInLeg = idStepCoordsInLeg;
+
+            step.name = jsonStep.name;
+            step.levelChange = jsonStep.levelChange ? LevelChange.fromJson(jsonStep.levelChange) : null;
+
+            step.distance = jsonStep.distance;
+            step.duration = jsonStep.duration;
+
+            if (jsonStep.extras && jsonStep.extras.subwayEntrance) {
+                step.extras.subwayEntrance = true;
+                if (jsonStep.extras.subwayEntranceRef) {
+                    step.extras.subwayEntranceRef = jsonStep.extras.subwayEntranceRef;
+                }
+            }
+
+            return step;
+        });
+    }
+
+    /**
+     * Generate multi itineraries from OSRM JSON
+     * @param {object} json JSON file provided by OSRM.
+     * @param {Coordinates} from itinerary start
+     * @param {Coordinates} to itinerary end
+     * @param {?string} routingMode [walking|driving|bicycle]
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json, from, to, routingMode = 'walking') {
+        const { routes: jsonRoutes } = json;
+
+        if (!jsonRoutes) {
+            return null;
+        }
+
+        const routingModeCorrespondance = new Map();
+        routingModeCorrespondance.set('walking', 'WALK');
+        routingModeCorrespondance.set('driving', 'CAR');
+        routingModeCorrespondance.set('bicycle', 'BIKE');
+        const mode = routingModeCorrespondance.get(routingMode) || null;
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = from;
+        routerResponse.to = to;
+
+        for (const jsonItinerary of jsonRoutes) {
+
+            const itinerary = new Itinerary();
+
+            // itinerary.coords = jsonItinerary.geometry.coordinates.map(jsonToCoordinates);
+            itinerary.distance = jsonItinerary.distance;
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.from = from;
+            itinerary.to = to;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonLeg of jsonItinerary.legs) {
+
+                const leg = new Leg();
+
+                leg.mode = mode;
+                leg.distance = jsonLeg.distance;
+                leg.duration = jsonLeg.duration;
+
+                leg.coords = jsonLeg.steps
+                    .map(step => step.geometry.coordinates.map(this.jsonToCoordinates))
+                    .flat()
+                    // Remove duplicates
+                    .filter((coords, idx, arr) => idx === 0 || !arr[idx - 1].equalsTo(coords));
+
+                leg.from = {
+                    name: null,
+                    coords: leg.coords[0]
+                };
+                leg.to = {
+                    name: null,
+                    coords: leg.coords[leg.coords.length - 1]
+                };
+
+                leg.steps = this.parseJsonSteps(jsonLeg.steps, leg.coords);
+
+                itinerary.legs.push(leg);
+            }
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+
+        }
+
+        return routerResponse;
+    }
+}
+
+export default new OsrmRemoteRouter();

package/src/{osrm/OsrmUtils.spec.js → remote/osrm/OsrmRemoteRouter.spec.js}

@@ -10,21 +10,15 @@ import { Coordinates } from '@wemap/geo';
 
 // import OsmParser from '../../model/OsmParser.js';
 // import OsmNetworkUtils from '../../network/OsmNetworkUtils.js';
-import {
-    // itineraryToOsrmJson,
-    // jsonToCoordinates,
-    // createItineraryFromJson,
-    // getModifierFromAngle,
-    // noRouteFoundJson,
-    createRouterResponseFromJson
-} from './OsrmUtils.js';
+import OsrmRemoteRouter from './OsrmRemoteRouter.js';
 
-import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+import checkRouterResponseType from '../../model/RouterResponse.type.spec.js';
 
 const { expect } = chai;
 chai.use(chaiAlmost(0.1));
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
 
 
 // const load = fileName => {
@@ -392,14 +386,14 @@ describe('OsrmUtils - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 1', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-montpellier-outdoor.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-montpellier-outdoor.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
         const from = new Coordinates(43.6007871, 3.8757218000000004);
         const to = new Coordinates(43.598877, 3.873866);
-        const routerResponse = createRouterResponseFromJson(json, from, to);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = OsrmRemoteRouter.createRouterResponseFromJson(json, from, to);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('osrm');
         expect(routerResponse.itineraries.length).equal(1);
@@ -434,14 +428,14 @@ describe('OsrmUtils - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 2', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-montpellier-osrm-3.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-montpellier-osrm-3.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
         const from = new Coordinates(43.605663, 3.887244);
         const to = new Coordinates(43.6054106, 3.8878106);
-        const routerResponse = createRouterResponseFromJson(json, from, to);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = OsrmRemoteRouter.createRouterResponseFromJson(json, from, to);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('osrm');
         expect(routerResponse.itineraries.length).equal(1);

package/src/remote/otp/OtpRemoteRouter.js

@@ -0,0 +1,222 @@
+/* eslint-disable max-statements */
+import Polyline from '@mapbox/polyline';
+
+import { Coordinates } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import Itinerary from '../../model/Itinerary.js';
+import Leg from '../../model/Leg.js';
+import RouterResponse from '../../model/RouterResponse.js';
+import Step from '../../model/Step.js';
+import { generateStepsMetadata } from '../RemoteRouterUtils.js';
+import Constants from '../../Constants.js';
+import RemoteRouter from '../RemoteRouter.js';
+import RoutingModeCorrespondanceNotFound from '../RoutingModeCorrespondanceNotFound.js';
+import RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance = new Map();
+inputModeCorrespondance.set(Constants.ROUTING_MODE.CAR, 'CAR');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.WALK, 'WALK');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BIKE, 'BICYCLE');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BUS, 'WALK,TRANSIT');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.MULTI, 'WALK,TRANSIT');
+
+/**
+ * Singleton.
+ */
+class OtpRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'otp';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        const otpMode = inputModeCorrespondance.get(mode);
+        if (!otpMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+        }
+
+        if (waypoints.length > 2) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+
+        const fromPlace = `fromPlace=${waypoints[0].latitude},${waypoints[0].longitude}`;
+        const toPlace = `toPlace=${waypoints[1].latitude},${waypoints[1].longitude}`;
+        const queryMode = `mode=${otpMode}`;
+
+        const url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}&${queryMode}`;
+
+        return `${url.origin}${url.pathname}${search}`;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(json.lat, json.lon);
+    }
+
+    /**
+     * @param {object} jsonSteps
+     * @param {Coordinates[]} legCoords
+     * @returns {Step[]}
+     */
+    parseJsonSteps(jsonSteps, legCoords) {
+
+        if (!jsonSteps) {
+            return [];
+        }
+
+        return jsonSteps.map(jsonStep => {
+
+            const step = new Step();
+            const stepCoords = this.jsonToCoordinates(jsonStep);
+
+            // OTP step does not have the same coordinates than a point in legCoords.
+            // That is why we look for the closest point.
+            const distances = legCoords.map(coords => coords.distanceTo(stepCoords));
+            const idStepCoordsInLeg = distances.indexOf(Math.min(...distances));
+            if (idStepCoordsInLeg < 0) {
+                throw new Error('OTP Parser: Cannot find closest step');
+            }
+            step.coords = legCoords[idStepCoordsInLeg];
+            step._idCoordsInLeg = idStepCoordsInLeg;
+
+            step.name = jsonStep.streetName;
+            step.levelChange = null;
+
+            step.distance = jsonStep.distance;
+
+            return step;
+        });
+    }
+
+    /**
+     * Generate multi itineraries from OTP JSON
+     * @param {object} json JSON file provided by OTP.
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json) {
+
+        const { plan: jsonPlan } = json;
+
+        if (!jsonPlan) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = this.jsonToCoordinates(jsonPlan.from);
+        routerResponse.to = this.jsonToCoordinates(jsonPlan.to);
+
+        for (const jsonItinerary of jsonPlan.itineraries) {
+
+            const itinerary = new Itinerary();
+
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.startTime = jsonItinerary.startTime;
+            itinerary.endTime = jsonItinerary.endTime;
+            itinerary.from = routerResponse.from;
+            itinerary.to = routerResponse.to;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonLeg of jsonItinerary.legs) {
+
+                const leg = new Leg();
+
+                leg.mode = jsonLeg.mode;
+                leg.duration = jsonLeg.duration;
+                leg.startTime = jsonLeg.startTime;
+                leg.endTime = jsonLeg.endTime;
+                leg.from = {
+                    name: jsonLeg.from.name,
+                    coords: this.jsonToCoordinates(jsonLeg.from)
+                };
+                leg.to = {
+                    name: jsonLeg.to.name,
+                    coords: this.jsonToCoordinates(jsonLeg.to)
+                };
+                leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+
+                leg.steps = this.parseJsonSteps(jsonLeg.steps, leg.coords);
+
+                if (leg.mode === 'BUS' || leg.mode === 'TRAM') {
+                    leg.transportInfo = {
+                        name: jsonLeg.route,
+                        routeColor: jsonLeg.routeColor,
+                        routeTextColor: jsonLeg.routeTextColor,
+                        directionName: jsonLeg.headsign
+                    };
+
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = jsonLeg.headsign;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonLeg.distance;
+                    leg.steps = [legStep];
+                }
+
+                // jsonLeg.distance is not reliable when compared to the array of leg coords.
+                // leg.distance = jsonLeg.distance;
+                leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                    if (idx === 0) {
+                        return acc;
+                    }
+                    return acc + arr[idx - 1].distanceTo(coords);
+                }, 0);
+
+                itinerary.legs.push(leg);
+
+            }
+
+            itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
+
+        return routerResponse;
+    }
+}
+
+export default new OtpRemoteRouter();
+

package/src/{otp/OtpUtils.spec.js → remote/otp/OtpRemoteRouter.spec.js}

@@ -7,26 +7,27 @@ import { fileURLToPath } from 'url';
 
 import { Coordinates } from '@wemap/geo';
 
-import { createRouterResponseFromJson } from './OtpUtils.js';
+import OtpRemoteRouter from './OtpRemoteRouter.js';
 
-import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+import checkRouterResponseType from '../../model/RouterResponse.type.spec.js';
 
 
 const { expect } = chai;
 chai.use(chaiAlmost(0.1));
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
 
-describe('OtpUtils - createRouterResponseFromJson', () => {
+describe('OtpRouter - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 1', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-grenoble-otp-1.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-grenoble-otp-1.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = OtpRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('otp');
         expect(routerResponse.itineraries.length).equal(2);
@@ -65,12 +66,12 @@ describe('OtpUtils - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 2', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-grenoble-otp-2.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-grenoble-otp-2.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = OtpRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.itineraries.length).equal(2);
         expect(routerResponse.from.equalsTo(new Coordinates(45.192514856662456, 5.731452541397871))).true;