@wemap/routers 6.2.2 → 7.0.0

package/src/remote/wemap-meta/WemapMetaRemoteRouter.js

@@ -0,0 +1,57 @@
+/* eslint-disable max-statements */
+
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from '../../model/RouterResponse.js';
+import RemoteRouter from '../RemoteRouter.js';
+import RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+import WemapMetaRemoteRouterOptions from './WemapMetaRemoteRouterOptions.js';
+import WemapMetaRemoteRouterPayload from './WemapMetaRemoteRouterPayload.js';
+
+
+/**
+ * Singleton.
+ */
+class WemapMetaRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'wemap-meta';
+    }
+
+    /**
+     * @param {!string} endpointUrl
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {?WemapMetaRemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints, options) {
+
+        const payload = new WemapMetaRemoteRouterPayload();
+        payload.waypoints = waypoints;
+        payload.mode = mode;
+        payload.options = options;
+
+        const res = await fetch(endpointUrl, {
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload.toJson())
+        });
+
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, endpointUrl);
+        }
+        const response = await res.json();
+        return RouterResponse.fromJson(response);
+    }
+
+}
+
+export default new WemapMetaRemoteRouter();

package/src/remote/wemap-meta/WemapMetaRemoteRouter.spec.js

@@ -0,0 +1,22 @@
+/* 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 CitywayUtils from './CitywayUtils.js';
+
+// import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+
+
+// const { expect } = chai;
+
+// const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// describe('CitywayUtils - createRouterResponseFromJson', () => {
+
+
+// });
+

package/src/remote/wemap-meta/WemapMetaRemoteRouterOptions.js

@@ -0,0 +1,36 @@
+import RemoteRouterOptions from '../RemoteRouterOptions.js';
+
+class WemapMetaRemoteRouterOptions extends RemoteRouterOptions {
+
+    /** @type {!{name: string, endpointUrl: string}[]} */
+    remoteRouters = [];
+
+    /** @type {?(string[])} */
+    targetMaps = null;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = super.toJson();
+        json.remoteRouters = this.remoteRouters;
+        if (this.targetMaps) {
+            json.targetMaps = this.targetMaps;
+        }
+        return json;
+    }
+
+    /**
+     * @param {object}
+     * @returns {WemapMetaRemoteRouterOptions}
+     */
+    static fromJson(json) {
+        const obj = new WemapMetaRemoteRouterOptions();
+        obj.useStairs = json.useStairs;
+        obj.remoteRouters = json.remoteRouters;
+        obj.targetMaps = json.targetMaps ? json.targetMaps : null;
+        return obj;
+    }
+}
+
+export default WemapMetaRemoteRouterOptions;

package/src/remote/wemap-meta/WemapMetaRemoteRouterPayload.js

@@ -0,0 +1,44 @@
+import { Coordinates } from '@wemap/geo';
+import WemapMetaRemoteRouterOptions from './WemapMetaRemoteRouterOptions.js';
+
+class WemapMetaRemoteRouterPayload {
+
+    /** @type {!(Coordinates[])} */
+    waypoints;
+
+    /** @type {!string} */
+    mode;
+
+    /** @type {!WemapMetaRemoteRouterOptions} */
+    options = null;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = {
+            waypoints: this.waypoints.map(coords => coords.toCompressedJson()),
+            mode: this.mode
+        };
+        if (this.options) {
+            json.options = this.options.toJson();
+        }
+        return json;
+    }
+
+    /**
+     * @param {object}
+     * @returns {WemapMetaRemoteRouterPayload}
+     */
+    static fromJson(json) {
+        const obj = new WemapMetaRemoteRouterPayload();
+        obj.waypoints = json.waypoints.map(coords => Coordinates.fromCompressedJson(coords));
+        obj.mode = json.mode;
+        if (json.options) {
+            obj.options = WemapMetaRemoteRouterOptions.fromJson(json.options);
+        }
+        return obj;
+    }
+}
+
+export default WemapMetaRemoteRouterPayload;

package/src/wemap/WemapRouter.js

@@ -12,6 +12,12 @@ class WemapRouter extends GraphRouter {
         super(network);
     }
 
+
+    /** @type {string} */
+    static get rname() {
+        return 'wemap';
+    }
+
     /**
      * @param {Coordinates} start
      * @param {Coordinates} end

package/src/wemap/WemapRouterUtils.js

@@ -1,6 +1,7 @@
 import { GraphItinerary } from '@wemap/geo';
 import { OsmElement } from '@wemap/osm';
 
+import Constants from '../Constants.js';
 import Itinerary from '../model/Itinerary.js';
 import Leg from '../model/Leg.js';
 import WemapStepsGeneration from './WemapStepsGeneration.js';
@@ -10,17 +11,21 @@ import WemapStepsGeneration from './WemapStepsGeneration.js';
  * @param {string} mode
  * @returns {Leg}
  */
-export function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
+export function createLegFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
 
     const leg = new Leg();
 
-    leg.from = { coords: graphItinerary.start };
-    leg.to = { coords: graphItinerary.end };
+    leg.from = { coords: graphItinerary.start, name: null };
+    leg.to = { coords: graphItinerary.end, name: null };
     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);
+    leg.steps.forEach(step => {
+        step._idCoordsInLeg = leg.coords.findIndex(coords => coords === step.coords);
+    });
 
     return leg;
 }
@@ -30,7 +35,8 @@ export function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
  * @param {string} mode
  * @returns {Itinerary}
  */
-export function createItineraryFromGraphItinerary(graphItinerary, mode = 'WALK') {
+export function createItineraryFromGraphItinerary(graphItinerary,
+    mode = Constants.ROUTING_MODE.WALK) {
 
     const leg = createLegFromGraphItinerary(graphItinerary, mode);
 

package/src/wemap/WemapStepsGeneration.js

@@ -1,6 +1,6 @@
 /* eslint-disable complexity */
 /* eslint-disable max-statements */
-import { Coordinates, GraphItinerary } from '@wemap/geo';
+import { Coordinates, Level, GraphItinerary, GraphNode, GraphUtils } from '@wemap/geo';
 import { diffAngle, deg2rad } from '@wemap/maths';
 import { OsmElement } from '@wemap/osm';
 
@@ -69,7 +69,7 @@ class WemapStepsGeneration {
                 }
 
                 if (splitByLevel) {
-                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
+                    currentStep.levelChange = WemapStepsGeneration.levelChangefromTwoNodes(node, nextNode);
                 }
 
                 steps.push(currentStep);
@@ -85,20 +85,47 @@ class WemapStepsGeneration {
         }
 
         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);
+
+        // Create a last step if end is not on the network
         if (!Coordinates.equalsTo(lastNode.coords, end)) {
+            const lastStep = new Step();
+            lastStep.coords = lastNode.coords;
+            lastStep.number = steps.length + 1;
+            lastStep.previousBearing = previousBearing;
+            lastStep.distance = lastNode.coords.distanceTo(end);
             lastStep.nextBearing = lastNode.coords.bearingTo(end);
             lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
+            steps.push(lastStep);
         }
-        lastStep.lastStep = true;
-        steps.push(lastStep);
+
+        steps[steps.length - 1].lastStep = true;
 
         return steps;
     }
 
+    /**
+     * @param {GraphNode<OsmElement>} firstNode
+     * @param {GraphNode<OsmElement>} secondNode
+     * @returns {LevelChange}
+     */
+    static levelChangefromTwoNodes(firstNode, secondNode) {
+
+        const levelChange = new LevelChange();
+
+        const edge = GraphUtils.getEdgeByNodes(firstNode.edges, firstNode, secondNode);
+
+        if (edge.builtFrom.isElevator) {
+            levelChange.type = 'elevator';
+        } else if (edge.builtFrom.isConveying) {
+            levelChange.type = 'conveyor';
+        } else if (edge.builtFrom.areStairs) {
+            levelChange.type = 'stairs';
+        }
+
+        levelChange.difference = Level.diff(firstNode.coords.level, secondNode.coords.level);
+        levelChange.direction = levelChange.difference > 0 ? 'up' : 'down';
+
+        return levelChange;
+    }
 }
 export default WemapStepsGeneration;

package/src/wemap-meta/IOMap.js

@@ -0,0 +1,191 @@
+import pointInPolygon from '@turf/boolean-point-in-polygon';
+import convexHullFn from '@turf/convex';
+import { polygon as turfPolygon } from '@turf/helpers';
+
+import { Coordinates, GraphNode, GraphRouter, Network, NoRouteFoundError } from '@wemap/geo';
+import { OsmParser } from '@wemap/osm';
+import { Itinerary, WemapNetworkUtils, WemapRouterOptions, WemapRouterUtils } from '@wemap/routers';
+
+import Constants from '../Constants.js';
+
+class IOMap {
+
+    /** @type {?string} */
+    name;
+
+    /** @type {!GraphRouter} */
+    router;
+
+    /** @type {!([number, number][])} */
+    bounds;
+
+
+    /** @type {!(GraphNode[])} */
+    entryPoints;
+
+    /**
+     * @param {Network} network The network of the map
+     * @param {GraphNode[]} entryPoints The map vertex that can be used to go inside / outside a IOMap
+     * @param {Coordinates[]} bounds The bounds
+     * @param {string} name The name of the map
+     * @returns {IOMap}
+     */
+    constructor(network, entryPoints, bounds = null, name = null) {
+
+        this.name = name;
+        this.router = new GraphRouter(network);
+
+        // Entry points
+        entryPoints.forEach(entryPoint => {
+            if (!network.nodes.includes(entryPoint)) {
+                throw new Error(`Cannot find entry point ${entryPoint.coords.toString()} in network "${name}"`);
+            }
+        });
+        this.entryPoints = entryPoints;
+
+        // Bounds
+        if (bounds) {
+            this.bounds = turfPolygon([bounds.map(coords => [coords.lng, coords.lat])]);
+        } else {
+            const polygon = [network.nodes.map(node => [node.coords.lng, node.coords.lat])];
+            const convexHull = convexHullFn(polygon);
+            if (!convexHull) {
+                throw new Error(`Cannot calculate convexHull of network "${name}"`);
+            }
+            this.bounds = convexHull;
+        }
+    }
+
+    /**
+     * @param {string} osmXmlString
+     * @param {string} name
+     * @returns {IOMap}
+     */
+    static fromOsmXml(osmXmlString, name = null) {
+
+        const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+        const network = WemapNetworkUtils.createNetworkFromOsmModel(osmModel);
+
+        const entryPoints = osmModel.nodes
+            .filter(({ tags }) => tags && tags['wemap:routing-io'])
+            .map(osmNode => network.getNodeByCoords(osmNode.coords));
+        if (entryPoints.some(el => el === null)
+            || new Set(entryPoints).size !== entryPoints.length
+        ) {
+            throw new Error('Cannot parse wemap:routing-io correctly');
+        }
+
+        const wayBounds = osmModel.ways.find(({ tags }) => tags['wemap:routing-bounds']);
+        if (!wayBounds) {
+            throw new Error('Search bounds is undefined. Please use OSM tag : "wemap:routing-bounds=yes"');
+        }
+        const bounds = wayBounds.nodes.map(node => node.coords);
+        return new IOMap(network, entryPoints, bounds, name);
+    }
+
+    /**
+     * @param {Coordinates} coordinates
+     * @returns {boolean}
+     */
+    isPointInside(coordinates) {
+        return pointInPolygon([coordinates.lng, coordinates.lat], this.bounds);
+    }
+
+    /**
+     * Get the list of entry points sorted by the lowest distance between:
+     * start -> entry point -> end
+     * (as the crow flies)
+     *
+     * @param {Coordinates} start
+     * @param {Coordinates} end
+     * @returns {GraphNode[]}
+     */
+    getOrderedEntryPointsSortedByDistance(start, end) {
+        const entryPointsCopy = [...this.entryPoints];
+        return entryPointsCopy.sort((ep1, ep2) =>
+            + ep1.coords.distanceTo(start) + ep1.coords.distanceTo(end)
+            - ep2.coords.distanceTo(start) - ep2.coords.distanceTo(end)
+        );
+    }
+
+    /**
+     * Get the best itinerary from any entry point to an end coordinates.
+     *
+     * The algorithm works as following:
+     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+     * 2 - Try to calculate an itinerary from the first entry point to the end coordinates.
+     * 3 - If an itinerary is found, it is returned. Otherwise it tries from the next entry point.
+     *
+     * /!\ start is only used to sort the entry points (step 1).
+     *
+     * @param {Coordinates} start The start coordinates (which is outside the network)
+     * @param {Coordinates} end Then end coordinates (which is inside the network)
+     * @param {WemapRouterOptions} options
+     * @returns {Itinerary}
+     */
+    getBestItineraryFromEntryPointsToEnd(start, end, options) {
+
+        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+        for (const entryPoint of sortedEntryPoints) {
+            const itinerary = this.getItineraryInsideMap(entryPoint, end, options);
+            if (itinerary) {
+                return itinerary;
+            }
+            // no route found
+        }
+        throw new NoRouteFoundError(start, end,
+            `No route found from entry points to ${end.toString()} in map: ${this.name}`
+        );
+    }
+
+
+    /**
+     * Get the best itinerary from start coordinates to any entry point.
+     *
+     * The algorithm works as following:
+     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
+     * 2 - Try to calculate an itinerary from the start coordinates to the first entry point.
+     * 3 - If an itinerary is found, it is returned. Otherwise it tries to the next entry point.
+     *
+     * /!\ end is only used to sort the entry points (step 1).
+     *
+     * @param {Coordinates} start The start coordinates (which is inside the network)
+     * @param {Coordinates} end Then end coordinates (which is outside the network)
+     * @param {WemapRouterOptions} options
+     * @returns {Itinerary}
+     */
+    getBestItineraryFromStartToEntryPoints(start, end, options) {
+
+        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
+        for (const entryPoint of sortedEntryPoints) {
+            const itinerary = this.getItineraryInsideMap(start, entryPoint, options);
+            if (itinerary) {
+                return itinerary;
+            }
+            // no route found
+        }
+        throw new NoRouteFoundError(start, end,
+            `No route found from ${start.toString()} to entry points in map: ${this.name}`
+        );
+    }
+
+    /**
+     * @param {Coordinates} start the start coordinates
+     * @param {Coordinates} end the end coordinates
+     * @param {WemapRouterOptions} options
+     * @returns {?Itinerary}
+     */
+    getItineraryInsideMap(start, end, options) {
+
+        // Call the Wemap router to get the shortest path
+        const graphItinerary = this.router.getShortestPath(start, end, options);
+        if (graphItinerary === null) {
+            return null;
+        }
+
+        // Transform a network itinerary (nodes, edges...) to a router itinerary (legs, steps...)
+        return WemapRouterUtils.createItineraryFromGraphItinerary(graphItinerary, Constants.ROUTING_MODE.WALK);
+    }
+}
+
+export default IOMap;