@wemap/routers 11.4.0 → 11.5.0

package/dist/index.js

@@ -590,53 +590,98 @@ const _OsmGraph = class extends geo.GeoGraph {
     return super.getEdgeByName(name);
   }
   static fromOsmModel(osmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
-    const nodes = [];
+    const vertices = [];
     const edges = [];
-    const nodesCreated = {};
-    const elevatorNodes = [];
-    const getOrCreateNode = (osmNode) => {
-      let node = nodesCreated[osmNode.id];
-      if (!node) {
-        node = new geo.GeoGraphVertex(osmNode.coords, { data: osmNode, name: osmNode.tags.name });
-        nodesCreated[osmNode.id] = node;
-        nodes.push(node);
-        if (osmNode.tags.highway === "elevator") {
-          elevatorNodes.push(node);
+    const elevatorVertices = [];
+    const getOrCreateVertex = (osmNode, forceLevel = null) => {
+      let vertex = vertices.find(
+        (vertex2) => vertex2.data.id === osmNode.id && (forceLevel !== null ? geo.Level.intersect(vertex2.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 = [null];
+      if ("level" in osmNode.tags) {
+        levelsToGenerate = [osmNode.coords.level];
+        if ("repeat_on" in osmNode.tags) {
+          levelsToGenerate.push(...osmNode.tags.repeat_on.split(";").map(geo.Level.fromString));
+        }
+      } else if (forceLevel !== null) {
+        levelsToGenerate = [forceLevel];
+      }
+      levelsToGenerate.forEach((level) => {
+        const newVertex = new geo.GeoGraphVertex(osmNode.coords.clone(), { data: osmNode, name: osmNode.tags.name });
+        newVertex.coords.level = level;
+        vertices.push(newVertex);
+        if (geo.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.`);
       }
-      return node;
+      if (osmNode.tags.highway === "elevator" && vertex) {
+        elevatorVertices.push(vertex);
+      }
+      return vertex;
     };
     osmModel.ways.forEach((way) => {
       if (!waySelectionFilter(way)) {
         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 geo.GeoGraphEdge(
-          firstNode,
-          secondNode,
-          { data: way, name: way.tags.name, level: way.level }
-        );
-        _OsmGraph.manageOneWay(edge, way);
-        edges.push(edge);
-        firstNode = secondNode;
+      let levelsToGenerate = [null];
+      if ("level" in way.tags) {
+        levelsToGenerate = [way.level];
+        if ("repeat_on" in way.tags) {
+          levelsToGenerate.push(...way.tags.repeat_on.split(";").map(geo.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 geo.GeoGraphEdge(
+            firstVertex,
+            secondVertex,
+            { data: way, name: way.tags.name, level }
+          );
+          _OsmGraph.manageOneWay(edge, way);
+          edges.push(edge);
+          firstVertex = secondVertex;
+        }
+      });
     });
     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) => geo.Level.union(acc, v.coords.level), null);
+      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 geo.Coordinates(elevatorCenter[0], elevatorCenter[1], null, elevatorLevel);
+      const elevatorCenterVertex = new geo.GeoGraphVertex(elevatorCenterCoords, { data: way, name: way.tags.name });
+      vertices.push(elevatorCenterVertex);
+      entryVertices.forEach((entryVertex) => {
+        const newEdge = new geo.GeoGraphEdge(
+          elevatorCenterVertex,
+          entryVertex,
+          {
+            level: geo.Level.intersection(elevatorCenterVertex.coords.level, entryVertex.coords.level),
+            data: way
+          }
+        );
+        edges.push(newEdge);
       });
+      elevatorVertices.push(elevatorCenterVertex);
     });
-    elevatorNodes.forEach((node) => {
-      _OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
+    elevatorVertices.forEach((node) => {
+      _OsmGraph.createNodesAndEdgesFromElevator(vertices, edges, node);
     });
-    return new _OsmGraph(nodes, edges, true);
+    return new _OsmGraph(vertices, edges, true);
   }
   static manageOneWay(edge, way) {
     const { highway, oneway, conveying } = way.tags;
@@ -647,53 +692,52 @@ const _OsmGraph = class extends geo.GeoGraph {
       edge.vertex2 = tmpNode;
     }
   }
-  static createNodesAndEdgesFromElevator(nodes, edges, elevatorNode) {
-    const createdNodes = [];
+  static createNodesAndEdgesFromElevator(vertices, edges, elevatorVertex) {
+    const createdVertices = [];
     const getOrCreateLevelVertex = (level) => {
-      let levelVertex = createdNodes.find(({ coords }) => geo.Level.equals(level, coords.level));
+      let levelVertex = createdVertices.find(({ coords }) => geo.Level.equals(level, coords.level));
       if (!levelVertex) {
-        levelVertex = new geo.GeoGraphVertex(elevatorNode.coords.clone(), {
-          data: elevatorNode.data,
-          name: `${elevatorNode.name} (elevator lvl: ${level})`
+        levelVertex = new geo.GeoGraphVertex(elevatorVertex.coords.clone(), {
+          data: elevatorVertex.data,
+          name: `${elevatorVertex.name} (elevator lvl: ${level})`
         });
         levelVertex.coords.level = level;
-        createdNodes.push(levelVertex);
-        nodes.push(levelVertex);
+        createdVertices.push(levelVertex);
+        vertices.push(levelVertex);
       }
       return levelVertex;
     };
-    elevatorNode.edges.forEach((edge) => {
+    elevatorVertex.edges.forEach((edge) => {
       if (geo.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);
     });
-    for (let i = 0; i < createdNodes.length; i++) {
-      for (let j = i + 1; j < createdNodes.length; j++) {
-        const createdNode1 = createdNodes[i];
-        const createdNode2 = createdNodes[j];
-        if (createdNode1.coords.level === null || createdNode2.coords.level === null) {
+    for (let i = 0; i < createdVertices.length; i++) {
+      for (let j = i + 1; j < createdVertices.length; j++) {
+        const createdVertex1 = createdVertices[i];
+        const createdVertex2 = createdVertices[j];
+        if (createdVertex1.coords.level === null || createdVertex2.coords.level === null) {
           continue;
         }
-        const minLevel = Math.min(createdNode1.coords.level, createdNode2.coords.level);
-        const maxLevel = Math.max(createdNode1.coords.level, createdNode2.coords.level);
+        const minLevel = Math.min(createdVertex1.coords.level, createdVertex2.coords.level);
+        const maxLevel = Math.max(createdVertex1.coords.level, createdVertex2.coords.level);
         const newEdge = new geo.GeoGraphEdge(
-          createdNode1,
-          createdNode2,
-          { data: elevatorNode.data, name: elevatorNode.name, level: [minLevel, maxLevel] }
+          createdVertex1,
+          createdVertex2,
+          { data: elevatorVertex.data, name: elevatorVertex.name, level: [minLevel, maxLevel] }
         );
         edges.push(newEdge);
       }
     }
-    const elevatorNodeIndex = nodes.indexOf(elevatorNode);
+    const elevatorNodeIndex = vertices.indexOf(elevatorVertex);
     if (elevatorNodeIndex > -1) {
-      nodes.splice(elevatorNodeIndex, 1);
+      vertices.splice(elevatorNodeIndex, 1);
     }
   }
 };