@wemap/osm 4.0.15 → 5.0.2

package/src/routers/osrm/OsrmUtils.spec.js

@@ -0,0 +1,431 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Coordinates } from '@wemap/geo';
+// import { verifyCoherence } from '@wemap/geo/tests/CommonTest.js';
+
+// import OsmParser from '../../model/OsmParser.js';
+// import OsmNetworkUtils from '../../network/OsmNetworkUtils.js';
+import {
+    // itineraryToOsrmJson,
+    // jsonToCoordinates,
+    // createItineraryFromJson,
+    // getModifierFromAngle,
+    // noRouteFoundJson,
+    createRouterResponseFromJson
+} from './OsrmUtils.js';
+
+import { verifyRouterResponseData } from '../RouterResponse.type.spec.js';
+
+const { expect } = chai;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+
+// const load = fileName => {
+//     const filePath = path.resolve(__dirname, '../../../assets/' + fileName);
+//     const osmXmlString = fs.readFileSync(filePath, 'utf8');
+//     const model = OsmParser.parseOsmXmlString(osmXmlString);
+//     const network = OsmNetworkUtils.createNetworkFromOsmModel(model);
+//     const router = new GraphRouter(network);
+//     return {
+//         network,
+//         router
+//     };
+// };
+
+// let wemapIndoorItinerary, wemapIndoorJsonItinerary, wemapIndoorStart, wemapIndoorEnd;
+// let wemapOutdoorItinerary, wemapOutdoorJsonItinerary, wemapOutdoorStart, wemapOutdoorEnd;
+
+// describe('OsrmUtils - itineraryToOsrmJson', () => {
+
+//     it('With levels (Bureaux Wemap)', () => {
+
+//         const {
+//             network, router
+//         } = load('bureaux-wemap-montpellier-network.osm');
+
+//         wemapIndoorStart = new Coordinates(43.6092754, 3.8842306, null, new Level(2));
+//         wemapIndoorEnd = new Coordinates(43.6092602, 3.8842669, null, new Level(1));
+//         const itinerary = router.getShortestPath(wemapIndoorStart, wemapIndoorEnd);
+//         wemapIndoorItinerary = itinerary;
+
+//         const osrmJson = itineraryToOsrmJson(itinerary);
+//         wemapIndoorJsonItinerary = osrmJson;
+//         const itinerarySteps = itinerary.steps;
+
+//         const {
+//             geometry, legs
+//         } = osrmJson.routes[0];
+
+//         /**
+//          * Verify if JSON geometry corresponds to Itinerary points
+//          */
+//         const { coordinates } = geometry;
+//         expect(coordinates.length).equal(11);
+//         for (let i = 1; i < 11; i++) {
+//             expect(
+//                 network.getNodeByName('p' + (i + 6)).coords.equalsTo(
+//                     jsonToCoordinates(coordinates[i]))
+//             ).true;
+//         }
+
+//         /**
+//          * Verify location, type and modifier of each step
+//          */
+//         const { steps } = legs[0];
+//         for (let i = 0; i < steps.length; i++) {
+//             const {
+//                 location, type
+//             } = steps[i].maneuver;
+//             expect(itinerarySteps[i].node.coords.equalsTo(jsonToCoordinates(location))).true;
+
+//             let expectedType;
+//             switch (i) {
+//             case 0:
+//                 expectedType = 'depart';
+//                 break;
+//             case steps.length - 1:
+//                 expectedType = 'arrive';
+//                 break;
+//             default:
+//                 expectedType = 'turn';
+//             }
+//             expect(type).equals(expectedType);
+//         }
+
+//         // The first modifier is not mandatory by OSRM.
+//         expect(steps[0].maneuver.modifier).equals('left');
+//         expect(steps[0].distance).be.closeTo(2.33, 0.01);
+//         expect(steps[0].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+//         expect(steps[1].maneuver.modifier).equals('right');
+//         expect(steps[1].distance).be.closeTo(1.76, 0.01);
+//         expect(steps[1].maneuver.bearing_after).be.closeTo(56.90, 0.01);
+
+//         expect(steps[2].maneuver.modifier).equals('left');
+//         expect(steps[2].distance).be.closeTo(1.15, 0.01);
+//         expect(steps[2].maneuver.bearing_after).be.closeTo(11.90, 0.01);
+
+//         expect(steps[3].maneuver.modifier).equals('left');
+//         expect(steps[3].distance).be.closeTo(5.95, 0.01);
+//         expect(steps[3].maneuver.bearing_after).be.closeTo(281.93, 0.01);
+
+//         expect(steps[4].maneuver.modifier).equals('right');
+//         expect(steps[4].distance).be.closeTo(10.71, 0.01);
+//         expect(steps[4].maneuver.bearing_after).be.closeTo(12.22, 0.01);
+//         expect(steps[4].levelChange).is.not.null;
+//         expect(steps[4].levelChange.direction).equals('down');
+//         expect(steps[4].levelChange.difference).equals(-1);
+//         expect(steps[4].levelChange.type).equals('stairs');
+
+//         expect(steps[5].maneuver.modifier).equals('left');
+//         expect(steps[5].distance).be.closeTo(4.23, 0.01);
+//         expect(steps[5].maneuver.bearing_after).be.closeTo(102.00, 0.01);
+
+//         expect(steps[6].maneuver.modifier).equals('right');
+//         expect(steps[6].distance).be.closeTo(5.03, 0.01);
+//         expect(steps[6].maneuver.bearing_after).be.closeTo(191.75, 0.01);
+
+//         expect(steps[7].maneuver.modifier).equals('left');
+//         expect(steps[7].distance).be.closeTo(0, 0.01);
+//         expect(steps[7].maneuver.bearing_after).be.closeTo(0, 0.01);
+
+//     });
+
+//     it('Without levels', () => {
+
+//         const {
+//             network, router
+//         } = load('network-simple.osm');
+
+//         const start = network.getNodeByName('p1');
+//         const end = network.getNodeByName('p3');
+
+//         const itinerary = router.getShortestPath(start, end);
+
+//         wemapOutdoorJsonItinerary = itineraryToOsrmJson(itinerary);
+
+//         wemapOutdoorStart = start.coords;
+//         wemapOutdoorEnd = end.coords;
+//         wemapOutdoorItinerary = itinerary;
+//     });
+
+//     it('Itinerary with modifiers', () => {
+
+//         const {
+//             network, router
+//         } = load('network-with-modifiers.osm');
+
+//         const start = network.getNodeByName('start');
+//         const end = network.getNodeByName('end');
+
+//         const itinerary = router.getShortestPath(start, end);
+//         expect(() => itineraryToOsrmJson(itinerary)).not.throw(Error);
+
+//     });
+
+// });
+
+
+// describe('OsrmUtils - createItineraryFromJson', () => {
+
+
+//     it('Without levels (Montpellier outdoor)', () => {
+
+//         const filePath = path.resolve(__dirname, '../../../assets/itinerary-montpellier-outdoor.json');
+//         const fileString = fs.readFileSync(filePath, 'utf8');
+
+//         const json = JSON.parse(fileString);
+
+//         const start = new Coordinates(43.6007871, 3.8757218000000004);
+//         const end = new Coordinates(43.598877, 3.873866);
+
+//         const itinerary = createItineraryFromJson(json, start, end);
+
+//         expect(json.routes[0].geometry.coordinates.length).equal(itinerary.nodes.length);
+//         expect(itinerary.nodes.length).equal(itinerary.edges.length + 1);
+//         expect(itinerary.nodes.length).equal(19);
+
+//         const { steps } = itinerary;
+//         expect(steps.length).equal(5);
+
+//         let step;
+//         step = steps[0];
+//         expect(Coordinates.equalsTo(step.location, new Coordinates(43.600777, 3.875607))).true;
+//         expect(getModifierFromAngle(step.angle)).equals('left');
+//         expect(step.nodes.length).equals(6);
+//         expect(step.edges.length).equals(5);
+//         expect(step.firstStep).true;
+//         expect(step.lastStep).false;
+//         expect(step.name).equals('');
+
+//         step = steps[1];
+//         expect(Coordinates.equalsTo(step.location, new Coordinates(43.599881, 3.876396))).true;
+//         expect(getModifierFromAngle(step.angle)).equals('right');
+//         expect(step.nodes.length).equals(12);
+//         expect(step.edges.length).equals(11);
+//         expect(step.firstStep).false;
+//         expect(step.lastStep).false;
+//         expect(step.name).equals('Boulevard Vieussens');
+
+//         step = steps[2];
+//         expect(Coordinates.equalsTo(step.location, new Coordinates(43.599577, 3.874655))).true;
+//         expect(getModifierFromAngle(step.angle)).equals('left');
+//         expect(step.nodes.length).equals(2);
+//         expect(step.edges.length).equals(1);
+//         expect(step.firstStep).false;
+//         expect(step.lastStep).false;
+//         expect(step.name).equals('Impasse Bizeray');
+
+//         step = steps[3];
+//         expect(Coordinates.equalsTo(step.location, new Coordinates(43.599063, 3.874623))).true;
+//         expect(getModifierFromAngle(step.angle)).equals('right');
+//         expect(step.nodes.length).equals(2);
+//         expect(step.edges.length).equals(1);
+//         expect(step.firstStep).false;
+//         expect(step.lastStep).false;
+//         expect(step.name).equals('Rue du Docteur Louis Perrier');
+
+//         step = steps[4];
+//         expect(Coordinates.equalsTo(step.location, new Coordinates(43.59906, 3.873865))).true;
+//         expect(getModifierFromAngle(step.angle)).equals('left');
+//         expect(step.nodes.length).equals(1);
+//         expect(step.edges.length).equals(0);
+//         expect(step.firstStep).false;
+//         expect(step.lastStep).true;
+//         expect(step.name).equals('Rue du Docteur Louis Perrier');
+
+//         expect(itinerary._nextStepsIndexes.length).equals(itinerary.nodes.length);
+//         expect(itinerary._nextStepsIndexes[0]).equals(0);
+//         for (let i = 1; i <= 5; i++) {
+//             expect(itinerary._nextStepsIndexes[i]).equals(1);
+//         }
+//         for (let i = 6; i <= 16; i++) {
+//             expect(itinerary._nextStepsIndexes[i]).equals(2);
+//         }
+//         expect(itinerary._nextStepsIndexes[17]).equals(3);
+//         expect(itinerary._nextStepsIndexes[18]).equals(4);
+//     });
+
+
+//     it('Without levels (from itineraryToOsrmJson)', () => {
+
+//         const itinerary = createItineraryFromJson(wemapOutdoorJsonItinerary,
+//             wemapOutdoorStart, wemapOutdoorEnd);
+
+//         expect(itinerary.nodes.length).equal(wemapOutdoorItinerary.nodes.length);
+//         for (let i = 0; i < itinerary.nodes.length; i++) {
+//             const itineraryNode = itinerary.nodes[i];
+//             const wemapItineraryNode = wemapOutdoorItinerary.nodes[i];
+//             expect(itineraryNode.coords.equalsTo(wemapItineraryNode.coords)).true;
+//         }
+
+//         expect(itinerary.edges.length).equal(wemapOutdoorItinerary.edges.length);
+//         for (let i = 0; i < itinerary.edges.length; i++) {
+//             const itineraryEdge = itinerary.edges[i];
+//             const wemapItineraryEdge = wemapOutdoorItinerary.edges[i];
+//             const firstNode = wemapItineraryEdge[wemapOutdoorItinerary._edgesDirectionReversed[i] ? 'node2' : 'node1'];
+//             const secondNode = wemapItineraryEdge[wemapOutdoorItinerary._edgesDirectionReversed[i] ? 'node1' : 'node2'];
+//             expect(itineraryEdge.node1.coords.equalsTo(firstNode.coords)).true;
+//             expect(itineraryEdge.node2.coords.equalsTo(secondNode.coords)).true;
+//             expect(Level.equalsTo(itineraryEdge.level, wemapItineraryEdge.level)).true;
+//         }
+
+//     });
+
+//     it('Without steps (Montpellier outdoor)', () => {
+
+//         const filePath = path.resolve(__dirname,
+//             '../../../assets/itinerary-montpellier-outdoor-without-steps.json');
+//         const fileString = fs.readFileSync(filePath, 'utf8');
+
+//         const json = JSON.parse(fileString);
+
+//         const start = new Coordinates(43.6007871, 3.8757218000000004);
+//         const end = new Coordinates(43.598877, 3.873866);
+
+//         const itinerary = createItineraryFromJson(json, start, end);
+
+//         expect(json.routes[0].geometry.coordinates.length).equal(itinerary.nodes.length);
+//         expect(itinerary.nodes.length).equal(itinerary.edges.length + 1);
+//         expect(itinerary.nodes.length).equal(19);
+
+//         const { steps } = itinerary;
+//         expect(steps.length).equal(7);
+//     });
+
+
+//     it('With levels (from itineraryToOsrmJson)', () => {
+
+//         const itinerary = createItineraryFromJson(wemapIndoorJsonItinerary,
+//             wemapIndoorStart, wemapIndoorEnd);
+
+//         expect(itinerary.nodes.length).equal(wemapIndoorItinerary.nodes.length);
+//         for (let i = 0; i < itinerary.nodes.length; i++) {
+//             const itineraryNode = itinerary.nodes[i];
+//             const wemapItineraryNode = wemapIndoorItinerary.nodes[i];
+//             expect(itineraryNode.coords.equalsTo(wemapItineraryNode.coords)).true;
+//         }
+
+//         expect(itinerary.edges.length).equal(wemapIndoorItinerary.edges.length);
+//         for (let i = 0; i < itinerary.edges.length; i++) {
+//             const itineraryEdge = itinerary.edges[i];
+//             const wemapItineraryEdge = wemapIndoorItinerary.edges[i];
+//             const firstNode = wemapItineraryEdge[wemapIndoorItinerary._edgesDirectionReversed[i] ? 'node2' : 'node1'];
+//             const secondNode = wemapItineraryEdge[wemapIndoorItinerary._edgesDirectionReversed[i] ? 'node1' : 'node2'];
+//             expect(itineraryEdge.node1.coords.equalsTo(firstNode.coords)).true;
+//             expect(itineraryEdge.node2.coords.equalsTo(secondNode.coords)).true;
+//             expect(Level.equalsTo(itineraryEdge.level, wemapItineraryEdge.level)).true;
+//         }
+
+//     });
+
+//     it('Errored (Montpellier outdoor)', () => {
+
+//         const filePath = path.resolve(__dirname,
+//             '../../../assets/itinerary-with-duplicate-nodes.json');
+//         const fileString = fs.readFileSync(filePath, 'utf8');
+
+//         const json = JSON.parse(fileString);
+
+//         const start = new Coordinates(44.810569099999995, 4.9503924999999995);
+//         const end = new Coordinates(44.302673, 4.556377);
+
+//         const itinerary = createItineraryFromJson(json, start, end);
+//         itinerary.edges.forEach(edge => {
+//             expect(edge).instanceOf(Edge);
+//         });
+//         itinerary.steps.forEach(step => {
+//             step.edges.forEach(edge => {
+//                 expect(edge).instanceOf(Edge);
+//             });
+//         });
+//     });
+
+// });
+
+// describe('OsrmUtils - itineraryToOsrmJson - createItineraryFromJson - way/node', () => {
+
+//     it('With levels (Bureaux Wemap)', () => {
+
+//         const { router } = load('bureaux-wemap-montpellier-network.osm');
+
+//         const start = new Coordinates(43.6092754, 3.8842306, null, new Level(2));
+//         const end = new Coordinates(43.60949854, 3.88452048, null, new Level(0));
+//         const itinerary = router.getShortestPath(start, end);
+
+//         const osrmJson = itineraryToOsrmJson(itinerary);
+//         const jsonSteps = osrmJson.routes[0].legs[0].steps;
+
+//         expect(jsonSteps[0].name).equals('w2');
+//         expect(jsonSteps[4].name).equals('p19');
+//         expect(jsonSteps[6].name).equals('p21');
+
+//         const itineraryBis = createItineraryFromJson(osrmJson, start, end);
+//         verifyCoherence(itineraryBis);
+
+//         expect(itineraryBis.nodes.length).equals(itinerary.nodes.length);
+//         expect(itineraryBis.edges.length).equals(itinerary.edges.length);
+//         expect(itineraryBis.steps.length).equals(itinerary.steps.length);
+//     });
+// });
+
+// describe('OsrmUtils - Output JSON', () => {
+
+//     it('noRouteFoundJson', () => {
+//         expect(noRouteFoundJson('foo')).deep.equals({
+//             'code': 'NoRoute',
+//             'message': 'foo'
+//         });
+//     });
+
+// });
+
+
+describe('OsrmUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../../assets/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);
+
+        expect(routerResponse.routerName).equal('osrm');
+        expect(routerResponse.itineraries.length).equal(1);
+        expect(routerResponse.from.equalsTo(from)).true;
+        expect(routerResponse.to.equalsTo(to)).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.distance).equal(399.7);
+        expect(itinerary1.duration).equal(287.8);
+        expect(itinerary1.startTime).is.null;
+        expect(itinerary1.endTime).is.null;
+        expect(itinerary1.legs.length).equal(1);
+        expect(itinerary1.coords.length).equal(19);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        expect(itinerary1leg1.startTime).is.null;
+        expect(itinerary1leg1.endTime).is.null;
+        expect(itinerary1leg1.distance).equal(399.7);
+        expect(itinerary1leg1.duration).equal(287.8);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).is.null;
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(43.600777, 3.875607))).true;
+        expect(itinerary1leg1.to.name).is.null;
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(43.59906, 3.873865))).true;
+        expect(itinerary1leg1.coords.length).equal(19);
+        expect(itinerary1leg1.coords).deep.equal(itinerary1.coords);
+
+    });
+
+});
+

package/src/routers/otp/OtpUtils.js

@@ -0,0 +1,172 @@
+/* eslint-disable max-statements */
+import Polyline from '@mapbox/polyline';
+
+import { Coordinates } from '@wemap/geo';
+import { diffAngle } from '@wemap/maths';
+
+import Itinerary from '../Itinerary.js';
+import Leg from '../Leg.js';
+import RouterResponse from '../RouterResponse.js';
+import Step from '../Step.js';
+import { generateStepsNumbers } from '../Utils.js';
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    return new Coordinates(json.lat, json.lon);
+}
+
+/**
+ * @param {object} jsonSteps
+ * @param {Coordinates[]} legCoords
+ * @param {Coordinates} itineraryStart
+ * @param {Coordinates} itineraryEnd
+ * @returns {Step[]}
+ */
+function parseJsonSteps(jsonSteps, legCoords, itineraryStart) {
+
+    if (!jsonSteps) {
+        return [];
+    }
+
+    return jsonSteps.map(jsonStep => {
+
+        const step = new Step();
+        const stepCoords = 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.previousBearing = idStepCoordsInLeg === 0
+            ? itineraryStart.bearingTo(step.coords)
+            : legCoords[idStepCoordsInLeg - 1].bearingTo(legCoords[idStepCoordsInLeg]);
+        step.nextBearing = idStepCoordsInLeg === legCoords.length - 1
+            ? 0
+            : legCoords[idStepCoordsInLeg].bearingTo(legCoords[idStepCoordsInLeg + 1]);
+
+        step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+
+        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}
+ */
+export function createRouterResponseFromJson(json) {
+
+    const { plan: jsonPlan } = json;
+
+    if (!jsonPlan) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'otp';
+
+    routerResponse.from = jsonToCoordinates(jsonPlan.from);
+    routerResponse.to = 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: jsonToCoordinates(jsonLeg.from)
+            };
+            leg.to = {
+                name: jsonLeg.to.name,
+                coords: jsonToCoordinates(jsonLeg.to)
+            };
+            leg.coords = Polyline.decode(jsonLeg.legGeometry.points).map(([lat, lon]) => new Coordinates(lat, lon));
+
+            if (leg.mode === 'BUS' || leg.mode === 'TRAM') {
+                leg.transportInfo = {
+                    name: jsonLeg.route,
+                    routeColor: jsonLeg.routeColor,
+                    routeTextColor: jsonLeg.routeTextColor,
+                    directionName: jsonLeg.headsign
+                };
+            }
+
+            // 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);
+
+            let previousPoint;
+            if (itinerary.legs.length === 0) {
+                previousPoint = itinerary.from;
+            } else {
+                const lastLeg = itinerary.legs[itinerary.legs.length - 1];
+                previousPoint = lastLeg.coords[lastLeg.coords.length - 1];
+            }
+
+            leg.steps = parseJsonSteps(
+                jsonLeg.steps,
+                leg.coords,
+                previousPoint
+            );
+            // itinerary.coords.push(...leg.coords);
+            itinerary.legs.push(leg);
+
+        }
+
+        // Remove duplicates
+        // itinerary.coords = itinerary.coords.reduce((acc, val) => {
+        //     if (acc.length === 0 || !acc[acc.length - 1].equalsTo(val)) {
+        //         acc.push(val);
+        //     }
+        //     return acc;
+        // }, []);
+
+        itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+            if (idx === 0) {
+                return acc;
+            }
+            return acc + arr[idx - 1].distanceTo(coords);
+        }, 0);
+
+        generateStepsNumbers(itinerary);
+    }
+
+    return routerResponse;
+}
+
+