@wemap/routers 11.2.4 → 11.3.0

package/index.ts

@@ -12,6 +12,7 @@ export type { RoutingMode } from './src/model/RoutingMode.js';
 /* Wemap Router */
 export { default as OsmGraph, type OsmVertex, type OsmEdge, type OsmVertexData, type OsmEdgeData } from './src/wemap-osm/OsmGraph.js';
 export { default as OsmRouter, type OsmItinerary } from './src/wemap-osm/OsmRouter.js';
+export {type OsmRouterOptions } from './src/wemap-osm/OsmRouterOptions.js';
 
 export { default as WemapMultiRouter } from './src/wemap-multi/WemapMultiRouter.js';
 export { default as CustomNetworkMap } from './src/wemap-multi/CustomNetworkMap.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "11.2.4",
+    "version": "11.3.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -34,10 +34,10 @@
         "@turf/convex": "^6.5.0",
         "@turf/helpers": "^6.5.0",
         "@types/mapbox__polyline": "^1.0.2",
-        "@wemap/geo": "^11.0.2",
+        "@wemap/geo": "^11.3.0",
         "@wemap/logger": "^11.0.1",
         "@wemap/maths": "^11.0.1",
-        "@wemap/osm": "^11.0.2",
+        "@wemap/osm": "^11.3.0",
         "@wemap/salesman.js": "^2.1.0"
     },
     "devDependencies": {
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "07aa72961281f31b4c71d97e2afab2e512e76332"
+    "gitHead": "61e38edddc0dc58fa32750b69939a580b204442e"
 }

package/src/model/LevelChange.spec.ts

@@ -19,6 +19,7 @@ const levelChange2: LevelChange = {
 const levelChange3: LevelChange = {
     direction: 'up',
     difference: 3,
+    // TODO: change to 'escalator'
     type: 'conveyor'
 };
 

package/src/model/LevelChange.ts

@@ -1,4 +1,5 @@
-export type LevelChangeType = 'elevator' | 'conveyor' | 'stairs';
+// TODO: remove conveying
+export type LevelChangeType = 'elevator' | 'escalator' | 'stairs' | 'moving walkway' | 'conveyor';
 
 export type LevelChange = {
     direction: 'up' | 'down';

package/src/wemap-multi/CustomNetworkMap.ts

@@ -5,7 +5,7 @@ import { Position, MultiPolygon } from '@turf/helpers';
 import { Coordinates, GeoGraphRouterOptions, Level, NoRouteFoundError } from '@wemap/geo';
 import { OsmParser } from '@wemap/osm';
 
-import OsmGraph, { OsmVertex } from '../wemap-osm/OsmGraph.js';
+import OsmGraph, { OsmEdgeData, OsmVertex, OsmVertexData } from '../wemap-osm/OsmGraph.js';
 import WemapOsmRouter from '../wemap-osm/OsmRouter.js';
 
 class CustomNetworkMap {
@@ -129,7 +129,7 @@ class CustomNetworkMap {
      * /!\ start is only used to sort the entry points (step 1).
      *
      */
-    getBestItineraryFromEntryPointsToEnd(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions) {
+    getBestItineraryFromEntryPointsToEnd(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData>) {
 
         const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
         for (const entryPoint of sortedEntryPoints) {
@@ -156,7 +156,7 @@ class CustomNetworkMap {
      * /!\ end is only used to sort the entry points (step 1).
      *
      */
-    getBestItineraryFromStartToEntryPoints(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions) {
+    getBestItineraryFromStartToEntryPoints(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData>) {
 
         const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
         for (const entryPoint of sortedEntryPoints) {
@@ -171,12 +171,12 @@ class CustomNetworkMap {
         );
     }
 
-    getItineraryInsideMap(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions) {
+    getItineraryInsideMap(start: Coordinates, end: Coordinates, options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData>) {
         // Call the Wemap router to get the shortest path
         return this.router.getItinerary(start, end, options);
     }
 
-    getTripInsideMap(waypoints: Coordinates[], options: GeoGraphRouterOptions) {
+    getTripInsideMap(waypoints: Coordinates[], options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData>) {
         // Call the Wemap router to get the shortest trip itinerary
         return this.router.getTripItinerary(waypoints, options);
     }

package/src/wemap-multi/WemapMultiRouter.ts

@@ -1,7 +1,7 @@
 /* eslint-disable complexity */
 /* eslint-disable max-statements */
 
-import { Coordinates, NoRouteFoundError, GeoGraphRouterOptions } from '@wemap/geo';
+import { Coordinates, NoRouteFoundError } from '@wemap/geo';
 import Logger from '@wemap/logger';
 
 import CustomNetworkMap from './CustomNetworkMap.js';
@@ -9,7 +9,7 @@ import { WemapMultiRouterOptions } from './WemapMultiRouterOptions.js';
 import RemoteRouterManager from '../remote/RemoteRouterManager.js';
 import { isRoutingError } from '../remote/RemoteRouterUtils.js';
 import RouterResponse from '../model/RouterResponse.js';
-import WemapOsmRouter, { GeoGraphTripRouterOptions } from '../wemap-osm/OsmRouter.js';
+import WemapOsmRouter from '../wemap-osm/OsmRouter.js';
 import Itinerary from '../model/Itinerary.js';
 import { RoutingMode } from '../model/RoutingMode.js';
 import WemapMultiRemoteRouter from '../remote/wemap-multi/WemapMultiRemoteRouter.js';
@@ -57,14 +57,11 @@ class WemapMultiRouter {
         return ioMapsToTest;
     }
 
-    private convertOptionsToWemapOsmOptions(options: WemapMultiRouterOptions | null) {
+    private convertOptionsToWemapOsmOptions(options: WemapMultiRouterOptions | null = null) {
         // Create WemapOsmRouterOptions from WemapMultiRouterOptions
-        const outputOptions : GeoGraphRouterOptions | GeoGraphTripRouterOptions
-            = !options || !('useStairs' in options) || options.useStairs
-            ? WemapOsmRouter.DEFAULT_OPTIONS
-            : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
+        const outputOptions = WemapOsmRouter.buildOptions(options ? options : {});
 
-        if(typeof options?.tspTempCoeff !== 'undefined') {
+        if (typeof options?.tspTempCoeff !== 'undefined') {
             (outputOptions as any).tspTempCoeff = options.tspTempCoeff;
         }
         return outputOptions;

package/src/wemap-multi/WemapMultiRouterOptions.ts

@@ -1,15 +1,10 @@
 import { RemoteRouterName } from "../remote/RemoteRouterManager.js";
+import { OsmRouterOptions } from "../wemap-osm/OsmRouterOptions.js";
 
-export type WemapMultiRouterOptions = {
-
-    useStairs?: boolean;
+export type WemapMultiRouterOptions = OsmRouterOptions & {
 
     targetMaps?: string[] | null;
 
-    isTrip?: boolean;
-
-    tspTempCoeff?: number;
-
     /**
      * List of ordered remote routers (first of the list, first tested)
      * Algorithm will try the first router and if it fails continue

package/src/wemap-osm/OsmGraph.ts

@@ -1,19 +1,19 @@
-import { Coordinates, GeoGraph, GeoGraphEdge, GeoGraphVertex, Level } from '@wemap/geo';
+import { Coordinates, GeoGraph, GeoGraphEdge, GeoGraphVertex, Level, Level_t } from '@wemap/geo';
 import { OsmModel, OsmNode, OsmWay } from '@wemap/osm';
 
 const HIGHWAYS_PEDESTRIANS = ['footway', 'steps', 'pedestrian', 'living_street', 'path', 'track', 'sidewalk', 'elevator'];
 
 const DEFAULT_WAY_SELECTOR = (way: OsmWay) => {
     const isElevatorArea = way.tags.highway === 'elevator' && way.isArea
-    return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) 
-        && !isElevatorArea 
+    return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway)
+        && !isElevatorArea
         && !['no', 'private'].includes(way.tags.access)
         || way.tags.footway === 'sidewalk'
         || way.tags.public_transport === 'platform'
         || way.tags.railway === 'platform';
 };
 
-export type OsmVertexData = OsmNode;
+export type OsmVertexData = OsmNode | OsmWay;
 export type OsmEdgeData = OsmWay | OsmNode;
 
 export type OsmVertex = GeoGraphVertex<OsmVertexData, OsmEdgeData> & { data: OsmVertexData };
@@ -41,24 +41,54 @@ export default class OsmGraph extends GeoGraph<OsmVertexData, OsmEdgeData> {
 
     static fromOsmModel(osmModel: OsmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
 
-        const nodes: OsmVertex[] = [];
+        const vertices: OsmVertex[] = [];
         const edges: OsmEdge[] = [];
 
-        const nodesCreated: { [key: number]: OsmVertex } = {};
-        const elevatorNodes: OsmVertex[] = [];
+        const elevatorVertices: OsmVertex[] = [];
 
-        const getOrCreateNode = (osmNode: OsmNode) => {
-            let node = nodesCreated[osmNode.id];
-            if (!node) {
-                node = new GeoGraphVertex(osmNode.coords, { data: osmNode, name: osmNode.tags.name }) as OsmVertex;
-                nodesCreated[osmNode.id] = node;
-                nodes.push(node);
+        const getOrCreateVertex = (osmNode: OsmNode, forceLevel: Level_t = null) => {
 
-                if (osmNode.tags.highway === 'elevator') {
-                    elevatorNodes.push(node);
+            // Due to `repeat_on` tags in OSM model, it's not possible to compare osmIds to find corresponding vertex
+            let vertex: OsmVertex | null = vertices.find(vertex =>
+                vertex.data.id === osmNode.id
+                && (
+                    (forceLevel !== null)
+                        ? Level.intersect(vertex.coords.level, forceLevel)
+                        : true
+                )
+            ) || null;
+
+            if (vertex) { return vertex; }
+
+            if (vertices.find(v => v.data.id === osmNode.id)) {
+                throw `An error occured because repeat_on as not been set on node ${osmNode.coords} for level ${forceLevel}`;
+            }
+
+            let levelsToGenerate: Level_t[] = [null];
+            if ('level' in osmNode.tags) {
+                levelsToGenerate = [osmNode.coords.level];
+                if ('repeat_on' in osmNode.tags) {
+                    levelsToGenerate.push(...osmNode.tags.repeat_on.split(';').map(Level.fromString));
+                }
+            } else if (forceLevel !== null) {
+                levelsToGenerate = [forceLevel];
+            }
+
+            levelsToGenerate.forEach(level => {
+                const newVertex = new GeoGraphVertex(osmNode.coords.clone(), { data: osmNode, name: osmNode.tags.name }) as OsmVertex;
+                newVertex.coords.level = level;
+                vertices.push(newVertex);
+
+                if (Level.intersect(newVertex.coords.level, forceLevel)
+                    || forceLevel === null && 'level' in osmNode.tags) {
+                    vertex = newVertex;
                 }
+            })
+
+            if (osmNode.tags.highway === 'elevator' && vertex) {
+                elevatorVertices.push(vertex);
             }
-            return node;
+            return vertex! as OsmVertex;
         };
 
         osmModel.ways.forEach(way => {
@@ -66,39 +96,69 @@ export default class OsmGraph extends GeoGraph<OsmVertexData, OsmEdgeData> {
                 return;
             }
 
-            let firstNode = getOrCreateNode(way.nodes[0]);
-            for (let i = 1; i < way.nodes.length; i++) {
-                const secondNode = getOrCreateNode(way.nodes[i]);
-
-                const edge = new GeoGraphEdge(firstNode, secondNode,
-                    { data: way, name: way.tags.name, level: way.level }
-                ) as OsmEdge;
-                OsmGraph.manageOneWay(edge, way);
-                edges.push(edge);
-                firstNode = secondNode;
+            let levelsToGenerate: Level_t[] = [null];
+            if ('level' in way.tags) {
+                levelsToGenerate = [way.level];
+                if ('repeat_on' in way.tags) {
+                    levelsToGenerate.push(...way.tags.repeat_on.split(';').map(Level.fromString));
+                }
             }
 
+            levelsToGenerate.forEach(level => {
+
+                let firstVertex = getOrCreateVertex(way.nodes[0], level);
+
+                for (let i = 1; i < way.nodes.length; i++) {
+
+                    const secondVertex = getOrCreateVertex(way.nodes[i], level);
+
+                    const edge = new GeoGraphEdge(firstVertex, secondVertex,
+                        { data: way, name: way.tags.name, level }
+                    ) as OsmEdge;
+                    OsmGraph.manageOneWay(edge, way);
+                    edges.push(edge);
+                    firstVertex = secondVertex;
+                }
+            });
+
         });
 
+        // Manage elevators without explicit navigation graph inside.
         osmModel.ways
             .filter(way => way.isElevator)
             .forEach(way => {
-                way.nodes.forEach(node => {
-                    const connectedWays = node.ways.filter(otherWay => otherWay != way);
-                    if (connectedWays.length) {
-                        const graphVertex = getOrCreateNode(node);
-                        graphVertex.data.tags.highway = 'elevator';
-                        elevatorNodes.push(graphVertex);
-                    }
-                })
+                const entryVertices = way.nodes.map(node => vertices.filter(v => v.data.id === node.id)).flat();
+                const elevatorLevel = entryVertices.reduce((acc, v) => Level.union(acc, v.coords.level), null as Level_t);
+
+                // Horrible method but works for macro-problems
+                const elevatorCenter = way.nodes
+                    .reduce((acc, node) => [acc[0] + node.coords.lat, acc[1] + node.coords.lng], [0, 0])
+                    .map(val => val / way.nodes.length);
+
+                const elevatorCenterCoords = new Coordinates(elevatorCenter[0], elevatorCenter[1], null, elevatorLevel);
+                const elevatorCenterVertex = new GeoGraphVertex<OsmVertexData, OsmEdgeData>(elevatorCenterCoords, { data: way, name: way.tags.name }) as OsmVertex;
+                vertices.push(elevatorCenterVertex);
+
+                entryVertices.forEach(entryVertex => {
+                    const newEdge = new GeoGraphEdge(
+                        elevatorCenterVertex,
+                        entryVertex,
+                        {
+                            level: Level.intersection(elevatorCenterVertex.coords.level, entryVertex.coords.level),
+                            data: way
+                        }
+                    ) as OsmEdge;
+                    edges.push(newEdge);
+                });
+                elevatorVertices.push(elevatorCenterVertex);
             });
 
-        elevatorNodes.forEach(node => {
+        elevatorVertices.forEach(node => {
             // We have to clone this node for each connected edge
-            OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
+            OsmGraph.createNodesAndEdgesFromElevator(vertices, edges, node);
         });
 
-        return new OsmGraph(nodes, edges, true);
+        return new OsmGraph(vertices, edges, true);
     }
 
 
@@ -119,69 +179,68 @@ export default class OsmGraph extends GeoGraph<OsmVertexData, OsmEdgeData> {
 
 
     private static createNodesAndEdgesFromElevator(
-        nodes: OsmVertex[],
+        vertices: OsmVertex[],
         edges: OsmEdge[],
-        elevatorNode: OsmVertex
+        elevatorVertex: OsmVertex
     ) {
 
-        const createdNodes: OsmVertex[] = [];
+        const createdVertices: OsmVertex[] = [];
         const getOrCreateLevelVertex = (level: number | null) => {
-            let levelVertex = createdNodes.find(({ coords }) => Level.equals(level, coords.level));
+            let levelVertex = createdVertices.find(({ coords }) => Level.equals(level, coords.level));
             if (!levelVertex) {
-                levelVertex = new GeoGraphVertex(elevatorNode.coords.clone(), {
-                    data: elevatorNode.data,
-                    name: `${elevatorNode.name} (elevator lvl: ${level})`
+                levelVertex = new GeoGraphVertex(elevatorVertex.coords.clone(), {
+                    data: elevatorVertex.data,
+                    name: `${elevatorVertex.name} (elevator lvl: ${level})`
                 }) as OsmVertex;
                 levelVertex.coords.level = level;
-                createdNodes.push(levelVertex);
-                nodes.push(levelVertex);
+                createdVertices.push(levelVertex);
+                vertices.push(levelVertex);
             }
             return levelVertex;
         };
 
         // Create nodes from node.edges
-        elevatorNode.edges.forEach(edge => {
+        elevatorVertex.edges.forEach(edge => {
             if (Level.isRange(edge.level)) {
                 throw new Error('Cannot handle this elevator edge due to ambiguity');
             }
 
             const levelVertex = getOrCreateLevelVertex(edge.level);
-            if (edge.vertex1 === elevatorNode) {
+            if (edge.vertex1 === elevatorVertex) {
                 edge.vertex1 = levelVertex;
             } else {
                 edge.vertex2 = levelVertex;
             }
-            levelVertex.edges.push(edge);
         });
 
         // Create edges from createdNodes
-        for (let i = 0; i < createdNodes.length; i++) {
-            for (let j = i + 1; j < createdNodes.length; j++) {
+        for (let i = 0; i < createdVertices.length; i++) {
+            for (let j = i + 1; j < createdVertices.length; j++) {
 
-                const createdNode1 = createdNodes[i];
-                const createdNode2 = createdNodes[j];
+                const createdVertex1 = createdVertices[i];
+                const createdVertex2 = createdVertices[j];
 
-                if (createdNode1.coords.level === null || createdNode2.coords.level === null) {
+                if (createdVertex1.coords.level === null || createdVertex2.coords.level === null) {
                     // TODO: not the best approach... but cannot do better with [number, number] range for levels
                     continue;
                 }
 
-                const minLevel = Math.min(createdNode1.coords.level as number, createdNode2.coords.level as number);
-                const maxLevel = Math.max(createdNode1.coords.level as number, createdNode2.coords.level as number);
+                const minLevel = Math.min(createdVertex1.coords.level as number, createdVertex2.coords.level as number);
+                const maxLevel = Math.max(createdVertex1.coords.level as number, createdVertex2.coords.level as number);
 
                 const newEdge = new GeoGraphEdge<OsmVertexData, OsmEdgeData>(
-                    createdNode1,
-                    createdNode2,
-                    { data: elevatorNode.data, name: elevatorNode.name, level: [minLevel, maxLevel] }
+                    createdVertex1,
+                    createdVertex2,
+                    { data: elevatorVertex.data, name: elevatorVertex.name, level: [minLevel, maxLevel] }
                 ) as OsmEdge;
                 edges.push(newEdge);
             }
         }
 
         // Remove the historical elevator node from the network
-        const elevatorNodeIndex = nodes.indexOf(elevatorNode);
+        const elevatorNodeIndex = vertices.indexOf(elevatorVertex);
         if (elevatorNodeIndex > -1) {
-            nodes.splice(elevatorNodeIndex, 1);
+            vertices.splice(elevatorNodeIndex, 1);
         }
     }
 

package/src/wemap-osm/OsmRouter.elevators.spec.ts

@@ -0,0 +1,105 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { OsmParser } from '@wemap/osm';
+
+import OsmRouter from './OsmRouter.js';
+import OsmGraph from './OsmGraph.js';
+
+const { expect } = chai;
+chai.use(chaiAlmost(0.01));
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+
+const filePath = path.resolve(__dirname, '../../../osm/assets/elevator-models.osm');
+const osmXmlString = fs.readFileSync(filePath, 'utf8');
+const osmModel = OsmParser.parseOsmXmlString(osmXmlString);
+const graph =  OsmGraph.fromOsmModel(osmModel);
+const router = new OsmRouter(graph);
+
+const n = (nodeName: string) => graph.getVertexByName(nodeName)!.coords
+
+describe('OsmRouter Elevators - Case 1', () => {
+
+    it('Itinerary 1', () => {
+        expect(router.getShortestPath(n('s1'), n('f1a')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 2', () => {
+        expect(router.getShortestPath(n('s1'), n('f1b')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 3', () => {
+        expect(router.getShortestPath(n('s1'), n('f1c')).edges.length).not.equals(0)
+    });
+
+});
+
+
+describe('OsmRouter Elevators - Case 2', () => {
+
+    it('Itinerary 1', () => {
+        expect(router.getShortestPath(n('s2'), n('f2a')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 2', () => {
+        expect(router.getShortestPath(n('s2'), n('f2b')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 3', () => {
+        expect(router.getShortestPath(n('s2'), n('f2c')).edges.length).not.equals(0)
+    });
+
+});
+
+
+describe('OsmRouter Elevators - Case 3', () => {
+
+    it('Itinerary 1', () => {
+        expect(router.getShortestPath(n('s3'), n('f3a')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 2', () => {
+        expect(router.getShortestPath(n('s3'), n('f3b')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 3', () => {
+        expect(router.getShortestPath(n('s3'), n('f3c')).edges.length).not.equals(0)
+    });
+
+});
+
+describe('OsmRouter Elevators - Case 4', () => {
+
+    it('Itinerary 1', () => {
+        expect(router.getShortestPath(n('s4'), n('f4a')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 2', () => {
+        expect(router.getShortestPath(n('s4'), n('f4b')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 3', () => {
+        expect(router.getShortestPath(n('s4'), n('f4c')).edges.length).not.equals(0)
+    });
+
+});
+
+describe('OsmRouter Elevators - Case 5', () => {
+
+    it('Itinerary 1', () => {
+        expect(router.getShortestPath(n('s5'), n('f5a')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 2', () => {
+        expect(router.getShortestPath(n('s5'), n('f5b')).edges.length).not.equals(0)
+    });
+
+    it('Itinerary 3', () => {
+        expect(router.getShortestPath(n('s5'), n('f5c')).edges.length).not.equals(0)
+    });
+
+});