@wemap/routers 6.0.0

package/src/wemap/WemapRouterUtils.js

@@ -0,0 +1,46 @@
+import { GraphItinerary } from '@wemap/geo';
+import { OsmElement } from '@wemap/osm';
+
+import Itinerary from '../model/Itinerary.js';
+import Leg from '../model/Leg.js';
+import WemapStepsGeneration from './WemapStepsGeneration.js';
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Leg}
+ */
+export function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
+
+    const leg = new Leg();
+
+    leg.from = { coords: graphItinerary.start };
+    leg.to = { coords: graphItinerary.end };
+    leg.coords = graphItinerary.nodes.map(node => node.coords);
+    leg.distance = graphItinerary.edges.reduce((acc, edge) => acc + edge.length, 0);
+    leg.duration = graphItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0);
+    leg.mode = mode;
+    leg.steps = WemapStepsGeneration.fromGraphItinerary(graphItinerary);
+
+    return leg;
+}
+
+/**
+ * @param {GraphItinerary<OsmElement>} graphItinerary
+ * @param {string} mode
+ * @returns {Itinerary}
+ */
+export function createItineraryFromGraphItinerary(graphItinerary, mode = 'WALK') {
+
+    const leg = createLegFromGraphItinerary(graphItinerary, mode);
+
+    const itinerary = new Itinerary();
+
+    itinerary.from = graphItinerary.start;
+    itinerary.to = graphItinerary.end;
+    itinerary.distance = leg.distance;
+    itinerary.duration = leg.duration;
+    itinerary.legs.push(leg);
+
+    return itinerary;
+}

package/src/wemap/WemapStepsGeneration.js

@@ -0,0 +1,104 @@
+/* eslint-disable complexity */
+/* eslint-disable max-statements */
+import { Coordinates, GraphItinerary } from '@wemap/geo';
+import { diffAngle, deg2rad } from '@wemap/maths';
+import { OsmElement } from '@wemap/osm';
+
+import LevelChange from '../model/LevelChange.js';
+import Step from '../model/Step.js';
+
+const SKIP_STEP_ANGLE_MAX = deg2rad(20);
+
+class WemapStepsGeneration {
+
+    /**
+     * @param {GraphItinerary<OsmElement>} itinerary
+     * @returns {Step[]}
+     */
+    static fromGraphItinerary(itinerary) {
+
+        const steps = [];
+
+        const { start, end, nodes, edges } = itinerary;
+
+        let currentStep, previousStep;
+        let previousBearing = start.bearingTo(nodes[0].coords);
+
+        for (let i = 0; i < nodes.length - 1; i++) {
+
+            const isFirstStep = !currentStep;
+
+            const node = nodes[i];
+            const nextNode = nodes[i + 1];
+            const edge = edges[i];
+
+            const bearing = edge.bearing;
+            const angle = diffAngle(previousBearing, bearing + Math.PI);
+
+            let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
+
+            const splitByLevel = edge.level && edge.level.isRange
+                && node.coords.level && !node.coords.level.isRange;
+            splitByAngle = splitByAngle && !(node.coords.level && node.coords.level.isRange);
+
+            const splitStepCondition = splitByAngle || splitByLevel;
+
+            const isSubwayEntrance = node ? node.builtFrom.tags.railway === 'subway_entrance' : false;
+
+            // New step creation
+            if (isFirstStep || splitStepCondition || isSubwayEntrance) {
+
+                previousStep = currentStep;
+
+                currentStep = new Step();
+                currentStep.coords = node.coords;
+                currentStep.number = steps.length + 1;
+                currentStep.angle = angle;
+                currentStep.previousBearing = previousBearing;
+                currentStep.nextBearing = bearing;
+                currentStep.name = edge.builtFrom.tags.name || null;
+                currentStep.distance = 0;
+                currentStep.duration = 0;
+
+                if (isSubwayEntrance) {
+                    currentStep.extras.subwayEntrance = true;
+                    currentStep.name = node.builtFrom.tags.name;
+                    if (node.builtFrom.tags.ref) {
+                        currentStep.extras.subwayEntranceRef = node.builtFrom.tags.ref;
+                    }
+                }
+
+                if (splitByLevel) {
+                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
+                }
+
+                steps.push(currentStep);
+
+                if (!previousStep) {
+                    currentStep.firstStep = true;
+                }
+            }
+
+            currentStep.distance += edge.length;
+            currentStep.duration += itinerary.edgesWeights[i];
+            previousBearing = bearing;
+        }
+
+        const lastNode = nodes[nodes.length - 1];
+        const lastStep = new Step();
+        lastStep.coords = lastNode.coords;
+        lastStep.number = steps.length + 1;
+        lastStep.previousBearing = previousBearing;
+        lastStep.distance = lastNode.coords.distanceTo(end);
+        if (!Coordinates.equalsTo(lastNode.coords, end)) {
+            lastStep.nextBearing = lastNode.coords.bearingTo(end);
+            lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
+        }
+        lastStep.lastStep = true;
+        steps.push(lastStep);
+
+        return steps;
+    }
+
+}
+export default WemapStepsGeneration;