@wemap/osm 3.2.16 → 4.0.0

package/src/osrm/OsrmUtils.js

@@ -1,318 +1,286 @@
 /* eslint-disable max-statements */
 import {
-    Level, Coordinates
+    Level, Coordinates, Edge, Node, Itinerary, Step, Network
 } from '@wemap/geo';
 import {
-    Edge, Node, Itinerary, Step, Network
-} from '@wemap/graph';
-import {
-    rad2deg, Utils as MathUtils, diffAngle, deg2rad
+    rad2deg, positiveMod, diffAngle, deg2rad
 } from '@wemap/maths';
 
-import OsmNode from '../model/OsmNode.js';
-import OsmWay from '../model/OsmWay.js';
 
+export function coordinatesToJson(coordinates) {
+    const output = [coordinates.lng, coordinates.lat];
+    if (coordinates.level) {
+        output.push(coordinates.level.toString());
+    }
+    return output;
+}
 
-class OsrmUtils {
+export function jsonToCoordinates(json) {
+    const output = new Coordinates(json[1], json[0]);
+    if (json.length > 2) {
+        output.level = Level.fromString(json[2]);
+    }
+    return output;
+}
 
-    /**
-     * @param {Itinerary} itinerary
-     * @returns {object}
-     */
-    static itineraryToOsrmJson(itinerary) {
+export function nodesToJsonCoords(nodes) {
+    return nodes.map(node => coordinatesToJson(node.coords));
+}
 
-        const itinerarySteps = itinerary.steps;
-        const osrmSteps = [];
 
-        const lastStepId = itinerarySteps.length - 1;
-        for (let i = 0; i <= lastStepId; i++) {
+export function getModifierFromAngle(_angle) {
 
-            const {
-                nodes, length, nextEdgeData, nextBearing, previousBearing, angle, node,
-                duration, levelChange, edges
-            } = itinerarySteps[i];
+    const angle = positiveMod(rad2deg(_angle), 360);
 
-            const edgeData = i !== lastStepId ? nextEdgeData : itinerary.edges[lastStepId];
-            const name = edgeData && edgeData.tags ? nextEdgeData.tags.name : '';
+    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';
+}
 
-            let type = i === 0 ? 'depart' : 'turn';
-            type = i === lastStepId ? 'arrive' : type;
 
-            const bearingBefore = MathUtils.positiveMod(i === 0 ? 0 : previousBearing, 2 * Math.PI);
-            const bearingAfter = MathUtils.positiveMod(i === lastStepId ? 0 : nextBearing, 2 * Math.PI);
+export function noRouteFoundJson(message) {
+    return {
+        'code': 'NoRoute',
+        message
+    };
+}
 
-            const osrmStep = {
-                geometry: {
-                    type: 'LineString',
-                    coordinates: OsrmUtils.nodesToJsonCoords(nodes)
-                },
-                distance: length,
-                duration,
-                name,
-                maneuver: {
-                    bearing_before: rad2deg(bearingBefore),
-                    bearing_after: rad2deg(bearingAfter),
-                    location: OsrmUtils.coordinatesToJson(node.coords),
-                    type
-                },
-                wemap: {}
-            };
+/**
+ * @param {Itinerary} itinerary
+ * @returns {object}
+ */
+export function itineraryToOsrmJson(itinerary) {
 
-            if (levelChange !== null) {
-                osrmStep.levelChange = levelChange;
-            }
+    const itinerarySteps = itinerary.steps;
+    const osrmSteps = [];
 
-            if (node.data && node.data.tags) {
-                osrmStep.wemap.node = {
-                    id: node.data.id,
-                    tags: node.data.tags
-                };
-            }
+    const lastStepId = itinerarySteps.length - 1;
+    for (let i = 0; i <= lastStepId; i++) {
 
-            if (i !== lastStepId && nextEdgeData) {
-                osrmStep.wemap.nextEdgeData = {
-                    id: nextEdgeData.id,
-                    tags: nextEdgeData.tags
-                };
-                if (edges[0].data instanceof OsmNode) {
-                    osrmStep.wemap.nextEdgeData.type = 'node';
-                    osrmStep.wemap.nextEdgeData.coords = OsrmUtils.coordinatesToJson(edges[0].data.coords);
-                }
-                if (edges[0].data instanceof OsmWay) {
-                    osrmStep.wemap.nextEdgeData.type = 'way';
-                }
-            }
-
-            // The first modifier is not mandatory by OSRM.
-            // if (i !== 0) {
-            osrmStep.maneuver.modifier = OsrmUtils.getModifierFromAngle(angle);
-            // }
+        const {
+            nodes, length, nextEdge, nextBearing, previousBearing, angle, node,
+            duration, levelChange
+        } = itinerarySteps[i];
+
+        const name = (i === lastStepId ? node.name : nextEdge.name) || '';
+
+        let type = i === 0 ? 'depart' : 'turn';
+        type = i === lastStepId ? 'arrive' : type;
+
+        const bearingBefore = positiveMod(i === 0 ? 0 : previousBearing, 2 * Math.PI);
+        const bearingAfter = positiveMod(i === lastStepId ? 0 : nextBearing, 2 * Math.PI);
+
+        const osrmStep = {
+            geometry: {
+                type: 'LineString',
+                coordinates: nodesToJsonCoords(nodes)
+            },
+            distance: length,
+            duration,
+            name,
+            maneuver: {
+                bearing_before: rad2deg(bearingBefore),
+                bearing_after: rad2deg(bearingAfter),
+                location: coordinatesToJson(node.coords),
+                type
+            },
+            wemap: {}
+        };
 
-            osrmSteps.push(osrmStep);
+        if (levelChange !== null) {
+            osrmStep.levelChange = levelChange;
         }
 
-        return {
-            'code': 'Ok',
-            'routes': [
-                {
-                    'geometry': {
-                        'type': 'LineString',
-                        'coordinates': OsrmUtils.nodesToJsonCoords(itinerary.nodes)
-                    },
-                    'legs': [
-                        {
-                            'duration': itinerary.duration,
-                            'distance': itinerary.length,
-                            'steps': osrmSteps
-                        }
-                    ],
-                    'distance': itinerary.length,
-                    'duration': itinerary.duration,
-                    'weight_name': 'routability',
-                    'weight': 0
-                }
-            ],
-            'waypoints': []
-        };
-    }
-
-    /**
-     * Generate Itinerary from OSRM JSON, start and end.
-     * @param {object} json JSON file provided by OSRM.
-     * @param {Coordinates} start itinerary start
-     * @param {Coordinates} end itinerary end
-     */
-    static createItineraryFromJson(json, start, end) {
-        const itinerary = new Itinerary();
+        const nodeProperties = node.extractProperties();
+        if (Object.keys(nodeProperties).length !== 0) {
+            osrmStep.wemap.nodeProperties = nodeProperties;
+        }
 
-        itinerary.start = start;
-        itinerary.end = end;
+        if (i !== lastStepId && nextEdge) {
+            const nextEdgeProperties = nextEdge.extractProperties();
+            if (Object.keys(nextEdgeProperties).length !== 0) {
+                osrmStep.wemap.nextEdgeProperties = nextEdgeProperties;
+            }
+        }
 
-        const {
-            legs, geometry
-        } = json.routes[0];
+        // The first modifier is not mandatory by OSRM.
+        // if (i !== 0) {
+        osrmStep.maneuver.modifier = getModifierFromAngle(angle);
+        // }
 
-        /**
-         * Create nodes and edges from geometry
-         */
-        let previousNode;
-        const { coordinates } = geometry;
-        for (let i = 0; i < coordinates.length; i++) {
-            const node = new Node(OsrmUtils.jsonToCoordinates(coordinates[i]));
-            itinerary.nodes.push(node);
+        osrmSteps.push(osrmStep);
+    }
 
-            if (previousNode) {
-                const edge = new Edge(previousNode, node);
-                edge.level = Level.union(previousNode.coords.level, node.coords.level);
-                itinerary.edges.push(edge);
+    return {
+        'code': 'Ok',
+        'routes': [
+            {
+                'geometry': {
+                    'type': 'LineString',
+                    'coordinates': nodesToJsonCoords(itinerary.nodes)
+                },
+                'legs': [
+                    {
+                        'duration': itinerary.duration,
+                        'distance': itinerary.length,
+                        'steps': osrmSteps
+                    }
+                ],
+                'distance': itinerary.length,
+                'duration': itinerary.duration,
+                'weight_name': 'routability',
+                'weight': 0
             }
+        ],
+        'waypoints': []
+    };
+}
 
-            previousNode = node;
-        }
+function _parseSteps(itinerary, jsonSteps) {
 
-        if (legs && legs[0]) {
-            const { steps } = legs[0];
-            OsrmUtils._parseSteps(itinerary, steps);
-        }
+    itinerary._steps = [];
+    itinerary._nextStepsIndexes = [];
 
-        return itinerary;
-    }
+    let currentNodeIndex = 0;
 
-    static _parseSteps(itinerary, jsonSteps) {
+    for (let i = 0; i < jsonSteps.length; i++) {
+        const jsonStep = jsonSteps[i];
 
-        itinerary._steps = [];
-        itinerary._nextStepsIndexes = [];
+        const step = new Step();
+        step.number = i + 1;
+        step.firstStep = i === 0;
+        step.lastStep = i === jsonSteps.length - 1;
 
-        let currentNodeIndex = 0;
 
-        for (let i = 0; i < jsonSteps.length; i++) {
-            const jsonStep = jsonSteps[i];
+        /**
+         * Add nodes and edges to step
+         */
+        step.nodes = [];
+        step.edges = [];
 
-            const step = new Step();
-            step.number = i + 1;
-            step.firstStep = i === 0;
-            step.lastStep = i === jsonSteps.length - 1;
+        let previousNode;
+        let { coordinates } = jsonStep.geometry;
 
+        // The OSRM last step is twice the last node. So, remove the second.
+        if (step.lastStep) {
+            coordinates = [coordinates[0]];
+        }
 
-            /**
-             * Add nodes and edges to step
-             */
-            step.nodes = [];
-            step.edges = [];
+        for (const coords of coordinates) {
 
-            let previousNode;
-            let { coordinates } = jsonStep.geometry;
+            const node = itinerary.nodes[currentNodeIndex];
+            step.nodes.push(node);
 
-            // The OSRM last step is twice the last node. So, remove the second.
-            if (step.lastStep) {
-                coordinates = [coordinates[0]];
+            const isFirstNode = coordinates[0] === coords;
+            const isLastNode = coordinates[coordinates.length - 1] === coords;
+            if (isFirstNode) {
+                itinerary._nextStepsIndexes.push(i);
+            } else if (!isLastNode) {
+                itinerary._nextStepsIndexes.push(i + 1);
             }
 
-            for (const coords of coordinates) {
-
-                const node = itinerary.nodes[currentNodeIndex];
-                step.nodes.push(node);
+            if (previousNode) {
+                const edge = Network.getEdgeByNodes(previousNode.edges, previousNode, node);
+                step.edges.push(edge);
+            }
 
-                const isFirstNode = coordinates[0] === coords;
-                const isLastNode = coordinates[coordinates.length - 1] === coords;
-                if (isFirstNode) {
-                    itinerary._nextStepsIndexes.push(i);
-                } else if (!isLastNode) {
-                    itinerary._nextStepsIndexes.push(i + 1);
-                }
+            previousNode = node;
+            currentNodeIndex++;
+        }
 
-                if (previousNode) {
-                    const edge = Network.getEdgeByNodes(previousNode.edges, previousNode, node);
-                    step.edges.push(edge);
-                }
+        /**
+         * Add common fields
+         */
+        step.previousBearing = step.firstStep
+            ? itinerary.start.bearingTo(itinerary.nodes[0].coords)
+            : deg2rad(jsonStep.maneuver.bearing_before);
+        step.nextBearing = step.lastStep
+            ? previousNode.coords.bearingTo(itinerary.end)
+            : deg2rad(jsonStep.maneuver.bearing_after);
+        step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+        step.name = jsonStep.name;
+        step.levelChange = jsonStep.levelChange ? jsonStep.levelChange : null;
 
-                previousNode = node;
-                currentNodeIndex++;
+        /**
+         * Wemap fields
+         */
+        if (jsonStep.wemap) {
+            const firstNode = step.nodes[0];
+            if (jsonStep.wemap.nodeProperties && firstNode) {
+                firstNode.applyProperties(jsonStep.wemap.nodeProperties);
             }
 
-            /**
-             * Add common fields
-             */
-            step.previousBearing = step.firstStep
-                ? itinerary.start.bearingTo(itinerary.nodes[0].coords)
-                : deg2rad(jsonStep.maneuver.bearing_before);
-            step.nextBearing = step.lastStep
-                ? previousNode.coords.bearingTo(itinerary.end)
-                : deg2rad(jsonStep.maneuver.bearing_after);
-            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
-            step.name = jsonStep.name;
-            step.levelChange = jsonStep.levelChange ? jsonStep.levelChange : null;
-
-            /**
-             * Wemap fields
-             */
-            if (jsonStep.wemap) {
-                const firstNode = step.nodes[0];
-                if (jsonStep.wemap.node && firstNode) {
-                    const {
-                        id, tags
-                    } = jsonStep.wemap.node;
-                    firstNode.data = new OsmNode(id, step.nodes[0].coords, tags);
-                }
-
-                const firstEdge = step.edges[0];
-                if (jsonStep.wemap.nextEdgeData && firstEdge) {
-                    const {
-                        coords, id, tags, type
-                    } = jsonStep.wemap.nextEdgeData;
-                    if (type === 'node') {
-                        firstEdge.data = new OsmNode(id, OsrmUtils.jsonToCoordinates(coords), tags);
-                    } else {
-                        // if (type === 'way')
-                        firstEdge.data = new OsmWay(id, tags);
-                    }
-
-                    firstEdge.data.level = firstEdge.level;
-                }
+            const firstEdge = step.edges[0];
+            if (jsonStep.wemap.nextEdgeProperties && firstEdge) {
+                firstEdge.applyProperties(jsonStep.wemap.nextEdgeProperties);
             }
+        }
 
-            itinerary._steps.push(step);
+        itinerary._steps.push(step);
 
-            currentNodeIndex--;
-        }
+        currentNodeIndex--;
     }
+}
 
-    static getModifierFromAngle(_angle) {
-
-        const angle = MathUtils.positiveMod(rad2deg(_angle), 360);
+/**
+ * Generate Itinerary from OSRM JSON, start and end.
+ * @param {object} json JSON file provided by OSRM.
+ * @param {Coordinates} start itinerary start
+ * @param {Coordinates} end itinerary end
+ */
+export function createItineraryFromJson(json, start, end) {
+    const itinerary = new Itinerary();
 
-        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';
-    }
+    itinerary.start = start;
+    itinerary.end = end;
 
-    static coordinatesToJson(coordinates) {
-        const output = [coordinates.lng, coordinates.lat];
-        if (coordinates.level) {
-            output.push(coordinates.level.toString());
-        }
-        return output;
-    }
+    const {
+        legs, geometry
+    } = json.routes[0];
 
-    static jsonToCoordinates(json) {
-        const output = new Coordinates(json[1], json[0]);
-        if (json.length > 2) {
-            output.level = Level.fromString(json[2]);
+    /**
+     * Create nodes and edges from geometry
+     */
+    let previousNode;
+    const { coordinates } = geometry;
+    for (let i = 0; i < coordinates.length; i++) {
+        const node = new Node(jsonToCoordinates(coordinates[i]));
+        itinerary.nodes.push(node);
+
+        if (previousNode) {
+            const edge = new Edge(previousNode, node);
+            edge.level = Level.union(previousNode.coords.level, node.coords.level);
+            itinerary.edges.push(edge);
         }
-        return output;
-    }
 
-    static nodesToJsonCoords(nodes) {
-        return nodes.map(node => OsrmUtils.coordinatesToJson(node.coords));
+        previousNode = node;
     }
 
-
-    static noRouteFoundJson(message) {
-        return {
-            'code': 'NoRoute',
-            message
-        };
+    if (legs && legs[0]) {
+        const { steps } = legs[0];
+        _parseSteps(itinerary, steps);
     }
 
+    return itinerary;
 }
 
-export default OsrmUtils;
+