@wemap/routers 6.0.0

package/src/osrm/OsrmUtils.js

@@ -0,0 +1,269 @@
+/* eslint-disable max-statements */
+
+import { Level, Coordinates } from '@wemap/geo';
+import { rad2deg, positiveMod } from '@wemap/maths';
+
+import Itinerary from '../model/Itinerary.js';
+import Leg from '../model/Leg.js';
+import LevelChange from '../model/LevelChange.js';
+import RouterResponse from '../model/RouterResponse.js';
+import Step from '../model/Step.js';
+import { generateStepsMetadata } from '../Utils.js';
+
+/**
+ * @param {Coordinates} coordinates
+ * @returns {object}
+ */
+export function coordinatesToJson(coordinates) {
+    const output = [coordinates.lng, coordinates.lat];
+    if (coordinates.level) {
+        output.push(coordinates.level.toString());
+    }
+    return output;
+}
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    const output = new Coordinates(json[1], json[0]);
+    if (json.length > 2) {
+        output.level = Level.fromString(json[2]);
+    }
+    return output;
+}
+
+export function nodesToJsonCoords(nodes) {
+    return nodes.map(node => coordinatesToJson(node.coords));
+}
+
+
+export function 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';
+}
+
+
+export function noRouteFoundJson(message) {
+    return {
+        'code': 'NoRoute',
+        message
+    };
+}
+
+/**
+ * @param {Itinerary} itinerary
+ * @returns {object}
+ */
+export function 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(coordinatesToJson)
+                    },
+                    distance: step.distance,
+                    duration: step.duration,
+                    name: step.name,
+                    maneuver: {
+                        bearing_before: rad2deg(step.previousBearing),
+                        bearing_after: rad2deg(step.nextBearing),
+                        location: coordinatesToJson(step.coords),
+                        modifier: 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(coordinatesToJson)
+                },
+                'legs': jsonLegs,
+                'distance': itinerary.distance,
+                'duration': itinerary.duration,
+                'weight_name': 'routability',
+                'weight': 0
+            }
+        ],
+        'waypoints': []
+    };
+}
+
+
+/**
+ * @param {object} jsonSteps
+ * @param {Coordinates[]} legCoords
+ * @returns {Step[]}
+ */
+function parseJsonSteps(jsonSteps, legCoords) {
+
+    if (!jsonSteps) {
+        return [];
+    }
+
+    return jsonSteps.map(jsonStep => {
+
+        const step = new Step();
+        step.coords = 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}
+ */
+export function 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 = 'osrm';
+
+    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(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 = parseJsonSteps(jsonLeg.steps, leg.coords);
+
+            itinerary.legs.push(leg);
+        }
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+
+    }
+
+    return routerResponse;
+}