@wemap/routers 11.4.0 → 11.5.0

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "11.4.0",
+    "version": "11.5.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.3.3",
+        "@wemap/geo": "^11.5.0",
         "@wemap/logger": "^11.0.1",
         "@wemap/maths": "^11.0.1",
-        "@wemap/osm": "^11.3.3",
+        "@wemap/osm": "^11.5.0",
         "@wemap/salesman.js": "^2.1.0"
     },
     "devDependencies": {
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "c55a6535964fc5298b4855d1e058ab86c367fd6a"
+    "gitHead": "e3b51be235497315bfc799f70e01f08e0cadbcb4"
 }

package/src/wemap-osm/OsmGraph.spec.ts

@@ -72,12 +72,12 @@ describe('OsmGraph - simple', () => {
         expect(() => OsmGraph.fromOsmModel(osmModel2)).throw(Error);
     });
 
-    it('getNodeByName', () => {
-        let node = graph.getVertexByName('p1');
-        expect(node).not.undefined;
+    it('getVertexByName', () => {
+        let vertex = graph.getVertexByName('p1');
+        expect(vertex).not.undefined;
 
-        node = graph.getVertexByName('p5');
-        expect(node).is.undefined;
+        vertex = graph.getVertexByName('p5');
+        expect(vertex).is.undefined;
     });
 });
 

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,62 @@ 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; }
+
+            const otherVertex = vertices.find(v => v.data.id === osmNode.id)
+            if (otherVertex) {
+                if (otherVertex && otherVertex.coords.level !== null) {
+                    throw new Error(`An error occured because repeat_on as not been set on node ${osmNode.coords} for level ${forceLevel}`);
+                }
+                otherVertex.coords.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 (!vertex) {
+                throw new Error(`Unable to parse vertex {id: ${osmNode.id}, coords: ${osmNode.coords.lat}, ${osmNode.coords.lng}}. Please check "level" tag.`)
+            }
+
+            if (osmNode.tags.highway === 'elevator' && vertex) {
+                elevatorVertices.push(vertex);
             }
-            return node;
+            return vertex! as OsmVertex;
         };
 
         osmModel.ways.forEach(way => {
@@ -66,39 +104,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 +187,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');
+                throw new Error(`Cannot handle this elevator edge due to ambiguity (vertex: ${edge.vertex1.coords})`);
             }
 
             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 = (vertexName: string) => graph.getVertexByName(vertexName)!.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)
+    });
+
+});

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

@@ -17,7 +17,7 @@ chai.use(chaiAlmost(0.01));
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 
-const getNodesNames = (_itinerary: OsmItinerary) => {
+const getVerticesNames = (_itinerary: OsmItinerary) => {
     return _itinerary.vertices.map(vertex => vertex.name || null);
 };
 
@@ -33,7 +33,7 @@ const loadGraph = (fileName: string) => {
     return OsmGraph.fromOsmModel(osmModel);
 };
 
-const generateNodeNames = (start: number, end: number) =>
+const generateVertexNames = (start: number, end: number) =>
     new Array(end - start + 1).fill(null).map((_, idx) => 'p' + (idx + start));
 
 describe('OsmRouter - Multi-level itinerary', () => {
@@ -46,7 +46,7 @@ describe('OsmRouter - Multi-level itinerary', () => {
 
     const p: OsmVertex[] = [];
 
-    it('Search for nodes', () => {
+    it('Search for vertices', () => {
         for (let i = 1; i <= 16; i++) {
             p[i] = graph.getVertexByName('p' + i) as OsmVertex;
             expect(p[i]).instanceOf(GeoGraphVertex);
@@ -54,8 +54,8 @@ describe('OsmRouter - Multi-level itinerary', () => {
     });
 
     it('Router return shortest path', () => {
-        expect(getNodesNames(graphItinerary)).deep.equals(
-            ['proj on w2 (tmp)', ...generateNodeNames(7, 16)]
+        expect(getVerticesNames(graphItinerary)).deep.equals(
+            ['proj on w2 (tmp)', ...generateVertexNames(7, 16)]
         );
     });
 
@@ -115,7 +115,7 @@ describe('OsmRouter - Multi-level itinerary', () => {
         const end = new Coordinates(43.60917216742, 3.8842355275, null, 2);
         const itinerary2 = router.getShortestPath(start, end);
 
-        expect(getNodesNames(itinerary2)).deep.equals(['proj on w1 (tmp)', 'p6', 'p5']);
+        expect(getVerticesNames(itinerary2)).deep.equals(['proj on w1 (tmp)', 'p6', 'p5']);
     });
 
     it('do not use stairs', () => {
@@ -136,8 +136,8 @@ describe('OsmRouter - Multi-level itinerary', () => {
 
     //     const itineraryBis = Itinerary.fromJson(json);
     //     verifyCoherence(itineraryBis);
-    //     expect(itineraryBis.nodes.length).equal(11);
-    //     verifyNodesOrder(itineraryBis.nodes, ['w2', ...generateNodeNames(7, 16)]);
+    //     expect(itineraryBis.vertices.length).equal(11);
+    //     verifyVerticesOrder(itineraryBis.vertices, ['w2', ...generateVertexNames(7, 16)]);
     // });
 
 });
@@ -154,11 +154,11 @@ describe('OsmRouter - One Way itinerary', () => {
 
         const itinerary = router.getShortestPath(start, end);
         expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p0', 'p1', 'p2', 'p3']);
+        expect(getVerticesNames(itinerary)).deep.equals(['p0', 'p1', 'p2', 'p3']);
 
         const itineraryOtherWay = router.getShortestPath(end, start);
         expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p3', 'p2', 'p5', 'p4', 'p1', 'p0']);
+        expect(getVerticesNames(itineraryOtherWay)).deep.equals(['p3', 'p2', 'p5', 'p4', 'p1', 'p0']);
     });
 });
 
@@ -175,11 +175,11 @@ describe('OsmRouter - Conveying', () => {
 
         const itinerary = router.getShortestPath(start, end);
         expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p11', 'p12', 'p9', 'p8', 'p6', 'proj on null (tmp)']);
+        expect(getVerticesNames(itinerary)).deep.equals(['p11', 'p12', 'p9', 'p8', 'p6', 'proj on null (tmp)']);
 
         const itineraryOtherWay = router.getShortestPath(end, start);
         expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals(['proj on null (tmp)', 'p7', 'p10', 'p11']);
+        expect(getVerticesNames(itineraryOtherWay)).deep.equals(['proj on null (tmp)', 'p7', 'p10', 'p11']);
     });
 });
 
@@ -196,11 +196,11 @@ describe('OsmRouter - Conveying - backward', () => {
 
         const itinerary = router.getShortestPath(start, end);
         expect(itinerary).is.not.undefined;
-        expect(getNodesNames(itinerary)).deep.equals(['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
+        expect(getVerticesNames(itinerary)).deep.equals(['p6', 'p7', 'p10', 'p11', 'p12', 'p13']);
 
         const itineraryOtherWay = router.getShortestPath(end, start);
         expect(itineraryOtherWay).is.not.undefined;
-        expect(getNodesNames(itineraryOtherWay)).deep.equals(['p13', 'p12', 'p9', 'p8', 'p6']);
+        expect(getVerticesNames(itineraryOtherWay)).deep.equals(['p13', 'p12', 'p9', 'p8', 'p6']);
     });
 });