@wemap/routers 6.2.2 → 7.0.0

package/src/wemap-meta/WemapMetaRouter.js

@@ -0,0 +1,314 @@
+/* eslint-disable complexity */
+/* eslint-disable max-statements */
+
+import { Coordinates } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import IOMap from './IOMap.js';
+import WemapMetaRouterOptions from './WemapMetaRouterOptions.js';
+import RemoteRouterManager from '../remote/RemoteRouterManager.js';
+import WemapMetaRemoteRouterOptions from '../remote/wemap-meta/WemapMetaRemoteRouterOptions.js';
+import WemapRouterOptions from '../wemap/WemapRouterOptions.js';
+import RouterResponse from '../model/RouterResponse.js';
+import WemapRouter from '../wemap/WemapRouter.js';
+import Itinerary from '../model/Itinerary.js';
+
+
+class WemapMetaRouter {
+
+    /** @type {!(IOMap[])} */
+    maps = [];
+
+
+    /** @type {string} */
+    get rname() {
+        return 'wemap-meta';
+    }
+
+    /**
+     * @param {!IOMap} ioMap
+     */
+    addIOMap(ioMap) {
+        this.maps.push(ioMap);
+    }
+
+    /**
+     * @param {!IOMap} ioMap
+     */
+    removeIOMap(ioMap) {
+        this.maps = this.maps.filter(map => map !== ioMap);
+    }
+
+    /**
+     * @param {string} mode see Constants.ROUTING_MODE
+     * @param {Coordinates[]} waypoints
+     * @param {WemapMetaRouterOptions} options
+     * @returns {RouterResponse}
+     */
+    async getItineraries(mode, waypoints, options) {
+
+        /*
+         * Here, we try to get the shortest path using io maps networks and a remote router server.
+         */
+
+        /**
+         * ----- 1 -----
+         * Parse function params
+         * -------------
+         */
+
+        if (waypoints.length > 2) {
+            Logger.warn(`WemapMetaRouter uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+        const start = waypoints[0];
+        const end = waypoints[1];
+
+        // Avoid cycles on remoteRouters
+        const remoteRouters = options.remoteRouters.filter(
+            ({ name }) => name !== WemapMetaRemoteRouterOptions.rname
+        );
+
+        /*
+         * ----- 2 -----
+         * Retrieve the IO maps to consider for this itinerary
+         * -------------
+         *
+         * By default, all maps in this.maps are considered
+         * If options.targetMaps is defined, only use this subset
+         */
+        let ioMapsToTest = this.maps;
+
+        const { targetMaps } = options;
+        if (targetMaps) {
+
+            ioMapsToTest = this.maps.filter(map => targetMaps.includes(map));
+
+            // Send a warning if one of the request ioMap (from targetMaps) is not present in this.maps
+            if (ioMapsToTest.length !== targetMaps.length) {
+                targetMaps.forEach(map => {
+                    if (!ioMapsToTest.includes(map)) {
+                        Logger.warn(`IOMap "${map.name}" not found in WemapMetaRouter`);
+                    }
+                });
+            }
+        }
+
+        /*
+         * If there is no local map to test, use remote router directly.
+         * This should happen:
+         * 1 - this.maps is empty
+         * 2 - options.targetMaps is defined but empty
+         * 3 - intersection of this.maps and options.targetMaps is empty
+         */
+        if (!ioMapsToTest.length) {
+            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        }
+
+
+        /**
+         * ----- 3 -----
+         * Run the IO Maps - Remote Routers logic
+         * -------------
+         *
+         * For this purpose we have to consider 5 use cases
+         *
+         */
+
+        const routerResponse = new RouterResponse();
+        routerResponse.from = start;
+        routerResponse.to = end;
+
+
+        // Find the first map where the "start" is inside.
+        const mapWithStart = ioMapsToTest.find(map => map.isPointInside(start));
+
+        // Create WemapRouterOptions from WemapMetaRouterOptions
+        const wemapRouterOptions = options.useStairs
+            ? WemapRouterOptions.DEFAULT
+            : WemapRouterOptions.WITHOUT_STAIRS;
+
+        /*
+         * Case 1
+         *
+         * If "start" and "end" are in the same map, use the local router.
+         */
+        if (mapWithStart && mapWithStart.isPointInside(end)) {
+
+            const itinerary = mapWithStart.getItineraryInsideMap(start, end, wemapRouterOptions);
+
+            routerResponse.itineraries.push(itinerary);
+            routerResponse.routerName = [this.rname, WemapRouter.rname];
+
+            return routerResponse;
+        }
+
+        // Find the first map where the "end" is inside.
+        // Note: At this step, mapWithEnd is necessarily different from mapWithStart
+        const mapWithEnd = ioMapsToTest.find(map => map.isPointInside(end));
+
+        /*
+         * Case 2
+         *
+         * If no io map have been found for "start" and "end", therefore use remote router.
+         */
+        if (!mapWithStart && !mapWithEnd) {
+            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+        }
+
+        /** @type {RouterResponse} */
+        let remoteRouterResponse;
+
+        /** @type {Itinerary} */
+        let ioMapItinerary;
+
+        /**
+         * Case 3
+         *
+         * If a map has been found for the "start"  but not for the "end", so:
+         * - A first itinerary (firstRoute) is calculated from "start" to an "entrypoint"
+         *  of the IO map network using the wemap router.
+         * - A second itinerary (secondRoute) is calculated from an "entrypoint" to the
+         * "end" using remote routers.
+         * Itinerary returned is the concatenation of the both itineraries.
+         *
+         * Note: Check the mapWithEnd.getBestItineraryFromEntryPointsToEnd to understand
+         * which "entrypoint" is chosen by the algorithm
+         */
+        if (mapWithStart && !mapWithEnd) {
+
+            if (!mapWithStart.entryPoints.length) {
+                routerResponse.error = `A map including the "start" but the "end" has been 
+                    found (${mapWithStart.name}), however, no "entrypoints" have been found to go out`;
+                return routerResponse;
+            }
+
+            ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                remoteRouters, mode, [ioMapItinerary.to, end]
+            );
+
+
+            if (!remoteRouterResponse.itineraries.length) {
+                routerResponse.error = `Tried to calculate an itinerary from "start" 
+                    to "entrypoints" using wemap router on local map "${mapWithStart.name}" and
+                    an itinerary from  "entrypoints" to "end" using remote routers 
+                    (${remoteRouters.map(r => r.name).join(', ')}), but failed.`;
+                return routerResponse;
+            }
+
+            // Concat the the IO map itinerary with the remote router response (for each itinerary)
+            routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+                remoteRouterItinerary => Itinerary.fromItineraries(ioMapItinerary, remoteRouterItinerary)
+            );
+            routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+            return routerResponse;
+        }
+
+        /*
+         * Case 4
+         *
+         * If a map has been found for the "end" but not for the "start", so:
+         * - A first itinerary (remoteRouterResponse) is calculated from "start" to an "entrypoint"
+         *  of the IO map network using remote routers.
+         * - A second itinerary (ioMapItinerary) is calculated from an "entrypoint" to the
+         *  "end" using the wemap router.
+         * Itinerary returned is the concatenation of the both itineraries.
+         *
+         * Note: Check the mapWithEnd.getBestItineraryFromEntryPointsToEnd to understand
+         * which "entrypoint" is chosen by the algorithm
+         */
+        if (!mapWithStart && mapWithEnd) {
+
+            if (!mapWithEnd.entryPoints.length) {
+                routerResponse.error = `A map including the "end" but the "start" has been 
+                    found (${mapWithEnd.name}), however, no "entrypoints" have been found to go in`;
+                return routerResponse;
+            }
+
+            /*
+             * ioMapItinerary is computed before the remoteRouterResponse because it is less expensive to
+             * calculate all the routes to entrypoints using local router than all the routes with the
+             * remote router.
+             */
+            ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                remoteRouters, mode, [start, ioMapItinerary.from]
+            );
+
+            if (!remoteRouterResponse.itineraries.length) {
+                routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" 
+                    using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an
+                    itinerary from "entrypoints" to "end" using wemap router on local map
+                    "${mapWithEnd.name}", but failed.`;
+                return routerResponse;
+            }
+
+            // Concat the remote router response (for each itinerary) with the IO map itinerary
+            routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+                remoteRouterItinerary => Itinerary.fromItineraries(remoteRouterItinerary, ioMapItinerary)
+            );
+            routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+            return routerResponse;
+        }
+
+        /**
+         * Case 5
+         *
+         * If maps have been found for the "start" and the "end" but they are different, so:
+         * - A first itinerary (ioMapItinerary1) is calculated from "start" to an "entrypoint" of
+         *  the mapWithStart using the wemap router.
+         * - A second itinerary (remoteRouterResponse) is calculated from an "entrypoint" of the
+         *  mapWithStart to an "entrypoint" of the endWithMap using remote routers.
+         * - A third itinerary (ioMapItinerary2) is calculated from an "entrypoint" of the mapWithEnd
+         *  to the "end" using the wemap router.
+         * Itinerary returned is the concatenation of the three itineraries.
+         */
+        // if (startMap && endMap) {
+
+        if (!mapWithStart.entryPoints.length) {
+            routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go out of the start map`;
+            return routerResponse;
+        }
+
+        if (!mapWithEnd.entryPoints.length) {
+            routerResponse.error = `One map including the "start" (${mapWithStart.name}) and another 
+                including the "end" (${mapWithEnd.name}) has been found, however, no "entrypoints" have 
+                been found to go in the second map`;
+            return routerResponse;
+        }
+
+        const ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+        const ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+        remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+            remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
+        );
+
+        if (!remoteRouterResponse.itineraries.length) {
+            routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" 
+                using wemap router on local map  "${mapWithStart.name}", an itinerary from
+                "entrypoints1" to "entrypoints2" using remote routers 
+                (${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" 
+                to "end" using wemap router on local map "${mapWithEnd.name}", but failed.`;
+            return routerResponse;
+        }
+
+        // Concat the IO map itinerary 2 with the remote router response (for each itinerary)
+        // and the IO map itinerary 2
+        routerResponse.itineraries = remoteRouterResponse.itineraries.map(
+            remoteRouterItinerary => Itinerary.fromItineraries(
+                ioMapItinerary1,
+                remoteRouterItinerary,
+                ioMapItinerary2
+            )
+        );
+        routerResponse.routerName = [this.rname, remoteRouterResponse.routerName, WemapRouter.rname];
+        return routerResponse;
+
+        // }
+    }
+
+}
+
+export default WemapMetaRouter;

package/src/wemap-meta/WemapMetaRouter.spec.js

@@ -0,0 +1,119 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fetch, { Headers } from 'node-fetch';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Level, Coordinates } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import IOMap from './IOMap.js';
+import WemapMetaRouter from './WemapMetaRouter.js';
+import Constants from '../Constants.js';
+import WemapMetaRouterOptions from './WemapMetaRouterOptions.js';
+import { OsrmRemoteRouter } from '../../index.js';
+import checkRouterResponseType from '../model/RouterResponse.type.spec.js';
+
+const { expect } = chai;
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// TODO: Remove with node 18
+global.fetch = fetch;
+global.Headers = Headers;
+
+function createIOMapFromAsset(assetName) {
+    const filePath = path.resolve(__dirname, '../../assets/' + assetName);
+    const osmXmlString = fs.readFileSync(filePath, 'utf8');
+    const mapName = path.parse(assetName).name;
+    return IOMap.fromOsmXml(osmXmlString, mapName);
+}
+
+describe('WemapMetaRouter', () => {
+
+    const router = new WemapMetaRouter();
+
+    const biocbonMap = createIOMapFromAsset('biocbon-bergere-rdc-network.osm');
+    router.addIOMap(biocbonMap);
+    const garedelestMap = createIOMapFromAsset('gare-de-lest-network-pp-bounds.osm');
+    router.addIOMap(garedelestMap);
+
+    const mode = Constants.ROUTING_MODE.WALK;
+    const options = new WemapMetaRouterOptions();
+    options.targetMaps = [biocbonMap];
+    options.remoteRouters.push({
+        name: OsrmRemoteRouter.rname,
+        endpointUrl: 'https://routing.getwemap.com'
+    });
+
+    before(async () => {
+        Logger.ENABLED = false;
+    });
+
+    after(() => {
+        Logger.ENABLED = true;
+    });
+
+
+    it('indoor to indoor', async () => {
+        const start = new Coordinates(48.8725992, 2.343431);
+        const end = new Coordinates(48.8725694, 2.3433);
+
+        const routerResponse = await router.getItineraries(mode, [start, end], options);
+        checkRouterResponseType(routerResponse);
+
+        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(routerResponse.itineraries[0]);
+        expect(osrmResponse).is.not.null;
+        const routes = osrmResponse.routes;
+        expect(routes.length).equals(1);
+        expect(routes[0].geometry.coordinates.length).equals(6);
+        expect(routes[0].legs).not.empty;
+    });
+
+    it('outdoor to outdoor', async () => {
+        const start = new Coordinates(48.8726513, 2.343449);
+        const end = new Coordinates(48.8726397, 2.3431657);
+
+        const routerResponse = await router.getItineraries(mode, [start, end], options);
+        checkRouterResponseType(routerResponse);
+
+        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(routerResponse.itineraries[0]);
+        expect(osrmResponse.routes[0].geometry.coordinates.length).equals(4);
+    });
+
+    it('outdoor to indoor', async () => {
+        const start = new Coordinates(48.8726085, 2.3434289);
+        const end = new Coordinates(48.8725694, 2.3433);
+
+        const routerResponse = await router.getItineraries(mode, [start, end], options);
+        checkRouterResponseType(routerResponse);
+
+        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(routerResponse.itineraries[0]);
+        expect(osrmResponse.routes[0].geometry.coordinates.length).equals(6);
+    });
+
+    it('indoor to outdoor', async () => {
+        const start = new Coordinates(48.8725992, 2.343431);
+        const end = new Coordinates(48.8726513, 2.343449);
+
+        const routerResponse = await router.getItineraries(mode, [start, end], options);
+        checkRouterResponseType(routerResponse);
+
+        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(routerResponse.itineraries[0]);
+        expect(osrmResponse.routes[0].geometry.coordinates.length).equals(6);
+    });
+
+    it('indoor to outdoor to indoor', async () => {
+
+        options.targetMaps.push(garedelestMap);
+        const start = new Coordinates(48.8725992, 2.343431);
+        const end = new Coordinates(48.8772962, 2.3584458, null, new Level(0));
+
+        const routerResponse = await router.getItineraries(mode, [start, end], options);
+        checkRouterResponseType(routerResponse);
+
+        const osrmResponse = OsrmRemoteRouter.itineraryToOsrmJson(routerResponse.itineraries[0]);
+        expect(osrmResponse.routes[0].geometry.coordinates.length).equals(77);
+    });
+
+});

package/src/wemap-meta/WemapMetaRouterOptions.js

@@ -0,0 +1,20 @@
+import IOMap from './IOMap.js';
+
+class WemapMetaRouterOptions {
+
+    /** @type {!boolean} */
+    useStairs = true;
+
+    /** @type {?(IOMap[])} */
+    targetMaps = null;
+
+    /**
+     * List of ordered remote routers (first of the list, first tested)
+     * Algorithm will try the first router and if it fails continue
+     * with the second, etc...
+     * @type {!({name: string, endpointUrl: string}[])}
+     */
+    remoteRouters = [];
+}
+
+export default WemapMetaRouterOptions;