@wemap/routers 11.3.0 → 11.3.1

package/dist/index.js

@@ -590,91 +590,53 @@ const _OsmGraph = class extends geo.GeoGraph {
     return super.getEdgeByName(name);
   }
   static fromOsmModel(osmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
-    const vertices = [];
+    const nodes = [];
     const edges = [];
-    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;
-      }
-      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 = [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));
+    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);
         }
-      } 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 (osmNode.tags.highway === "elevator" && vertex) {
-        elevatorVertices.push(vertex);
-      }
-      return vertex;
+      return node;
     };
     osmModel.ways.forEach((way) => {
       if (!waySelectionFilter(way)) {
         return;
       }
-      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));
-        }
+      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;
       }
-      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) => {
-      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);
+      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);
+        }
       });
-      elevatorVertices.push(elevatorCenterVertex);
     });
-    elevatorVertices.forEach((node) => {
-      _OsmGraph.createNodesAndEdgesFromElevator(vertices, edges, node);
+    elevatorNodes.forEach((node) => {
+      _OsmGraph.createNodesAndEdgesFromElevator(nodes, edges, node);
     });
-    return new _OsmGraph(vertices, edges, true);
+    return new _OsmGraph(nodes, edges, true);
   }
   static manageOneWay(edge, way) {
     const { highway, oneway, conveying } = way.tags;
@@ -685,52 +647,53 @@ const _OsmGraph = class extends geo.GeoGraph {
       edge.vertex2 = tmpNode;
     }
   }
-  static createNodesAndEdgesFromElevator(vertices, edges, elevatorVertex) {
-    const createdVertices = [];
+  static createNodesAndEdgesFromElevator(nodes, edges, elevatorNode) {
+    const createdNodes = [];
     const getOrCreateLevelVertex = (level) => {
-      let levelVertex = createdVertices.find(({ coords }) => geo.Level.equals(level, coords.level));
+      let levelVertex = createdNodes.find(({ coords }) => geo.Level.equals(level, coords.level));
       if (!levelVertex) {
-        levelVertex = new geo.GeoGraphVertex(elevatorVertex.coords.clone(), {
-          data: elevatorVertex.data,
-          name: `${elevatorVertex.name} (elevator lvl: ${level})`
+        levelVertex = new geo.GeoGraphVertex(elevatorNode.coords.clone(), {
+          data: elevatorNode.data,
+          name: `${elevatorNode.name} (elevator lvl: ${level})`
         });
         levelVertex.coords.level = level;
-        createdVertices.push(levelVertex);
-        vertices.push(levelVertex);
+        createdNodes.push(levelVertex);
+        nodes.push(levelVertex);
       }
       return levelVertex;
     };
-    elevatorVertex.edges.forEach((edge) => {
+    elevatorNode.edges.forEach((edge) => {
       if (geo.Level.isRange(edge.level)) {
         throw new Error("Cannot handle this elevator edge due to ambiguity");
       }
       const levelVertex = getOrCreateLevelVertex(edge.level);
-      if (edge.vertex1 === elevatorVertex) {
+      if (edge.vertex1 === elevatorNode) {
         edge.vertex1 = levelVertex;
       } else {
         edge.vertex2 = levelVertex;
       }
+      levelVertex.edges.push(edge);
     });
-    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) {
+    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) {
           continue;
         }
-        const minLevel = Math.min(createdVertex1.coords.level, createdVertex2.coords.level);
-        const maxLevel = Math.max(createdVertex1.coords.level, createdVertex2.coords.level);
+        const minLevel = Math.min(createdNode1.coords.level, createdNode2.coords.level);
+        const maxLevel = Math.max(createdNode1.coords.level, createdNode2.coords.level);
         const newEdge = new geo.GeoGraphEdge(
-          createdVertex1,
-          createdVertex2,
-          { data: elevatorVertex.data, name: elevatorVertex.name, level: [minLevel, maxLevel] }
+          createdNode1,
+          createdNode2,
+          { data: elevatorNode.data, name: elevatorNode.name, level: [minLevel, maxLevel] }
         );
         edges.push(newEdge);
       }
     }
-    const elevatorNodeIndex = vertices.indexOf(elevatorVertex);
+    const elevatorNodeIndex = nodes.indexOf(elevatorNode);
     if (elevatorNodeIndex > -1) {
-      vertices.splice(elevatorNodeIndex, 1);
+      nodes.splice(elevatorNodeIndex, 1);
     }
   }
 };