@wemap/routers 11.2.4 → 11.3.0

package/dist/index.js

@@ -590,53 +590,91 @@ 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;
+      }
+      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));
+        }
+      } 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 node;
+      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,81 +685,58 @@ 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");
       }
       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);
     }
   }
 };
 let OsmGraph = _OsmGraph;
 __publicField(OsmGraph, "HIGHWAYS_PEDESTRIANS", HIGHWAYS_PEDESTRIANS);
 __publicField(OsmGraph, "DEFAULT_WAY_SELECTOR", DEFAULT_WAY_SELECTOR);
-const DEFAULT_OPTIONS = Object.assign({}, geo.GeoGraphRouter.DEFAULT_OPTIONS, {
-  weightEdgeFn: (edge) => {
-    if (edge.data.isElevator) {
-      return 90;
-    }
-    let duration = getDurationFromLength(edge.length, 4);
-    if (edge.data instanceof osm.OsmWay && edge.data.areStairs) {
-      duration *= 3;
-    }
-    return duration;
-  },
-  acceptEdgeFn: (edge) => {
-    const accessTag = edge.data.tags.access;
-    return typeof accessTag === "undefined" || accessTag === "yes";
-  }
-});
-const WITHOUT_STAIRS_OPTIONS = Object.assign({}, DEFAULT_OPTIONS, {
-  acceptEdgeFn: (edge) => edge.data.tags.highway !== "steps"
-});
-const DEFAULT_TRIP_OPTIONS = Object.assign({}, {
-  tspTempCoeff: 0.99
-}, geo.GeoGraphRouter.DEFAULT_OPTIONS);
 const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previousStep) => {
   var _a, _b, _c, _d, _e;
   const edges = graphItinerary.edges;
@@ -739,10 +754,12 @@ const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previous
   let levelChangeType = null;
   if (edge.data.isElevator) {
     levelChangeType = "elevator";
-  } else if (edge.data.isConveying) {
+  } else if (edge.data instanceof osm.OsmWay && edge.data.isConveying && edge.data.areStairs) {
     levelChangeType = "conveyor";
   } else if (edge.data instanceof osm.OsmWay && edge.data.areStairs) {
     levelChangeType = "stairs";
+  } else if (edge.data instanceof osm.OsmWay && edge.data.isConveying) {
+    levelChangeType = "moving walkway";
   }
   let forceLevelChange;
   const edgeTags = edge.data.tags || {};
@@ -782,17 +799,17 @@ const buildStepsRules = (graphItinerary) => (currentCoords, nextCoords, previous
     ...forceEndOfLevelChange && { forceEndOfLevelChange }
   };
 };
-class WemapOsmRouter extends geo.GeoGraphRouter {
+const _WemapOsmRouter = class extends geo.GeoGraphRouter {
   constructor(graph) {
     super(graph);
   }
   static get rname() {
     return "wemap-osm";
   }
-  getShortestPath(start, end, options = DEFAULT_OPTIONS) {
+  getShortestPath(start, end, options = _WemapOsmRouter.DEFAULT_OPTIONS) {
     return super.getShortestPath(start, end, options);
   }
-  getItinerary(start, end, options = DEFAULT_OPTIONS) {
+  getItinerary(start, end, options = _WemapOsmRouter.DEFAULT_OPTIONS) {
     const graphItinerary = this.getShortestPath(start, end, options);
     return Itinerary.fromGraphItinerary(graphItinerary, "WALK", buildStepsRules(graphItinerary));
   }
@@ -812,7 +829,7 @@ class WemapOsmRouter extends geo.GeoGraphRouter {
     }
     return { direction, directionExtra };
   }
-  getShortestTrip(waypoints, options = DEFAULT_TRIP_OPTIONS) {
+  getShortestTrip(waypoints, options = _WemapOsmRouter.DEFAULT_TRIP_OPTIONS) {
     const points = waypoints.map((waypoint) => {
       const point = new salesman__default.default.Point(0, 0);
       point.coords = waypoint;
@@ -846,7 +863,7 @@ class WemapOsmRouter extends geo.GeoGraphRouter {
     }
     return orderedItineraries;
   }
-  getTripItinerary(waypoints, options = DEFAULT_TRIP_OPTIONS) {
+  getTripItinerary(waypoints, options = _WemapOsmRouter.DEFAULT_TRIP_OPTIONS) {
     const shortestTrip = this.getShortestTrip(waypoints, options);
     return new Itinerary({
       from: shortestTrip[0].start,
@@ -854,9 +871,49 @@ class WemapOsmRouter extends geo.GeoGraphRouter {
       legs: shortestTrip.map((graphItinerary) => Leg.fromGraphItinerary(graphItinerary))
     });
   }
-}
-__publicField(WemapOsmRouter, "DEFAULT_OPTIONS", DEFAULT_OPTIONS);
-__publicField(WemapOsmRouter, "WITHOUT_STAIRS_OPTIONS", WITHOUT_STAIRS_OPTIONS);
+  static buildOptions(options) {
+    const weightEdgeFn = (edge) => {
+      var _a;
+      if ((_a = edge.data) == null ? void 0 : _a.isElevator) {
+        return 90;
+      }
+      let duration = getDurationFromLength(edge.length, 4);
+      if (edge.data instanceof osm.OsmWay && edge.data.areStairs) {
+        duration *= 3;
+      }
+      return duration;
+    };
+    const acceptEdgeFn = (edge) => {
+      var _a, _b, _c;
+      const accessTag = (_b = (_a = edge.data) == null ? void 0 : _a.tags) == null ? void 0 : _b.access;
+      if (typeof accessTag !== "undefined" && accessTag !== "yes")
+        return false;
+      if (typeof (options == null ? void 0 : options.useStairs) !== "undefined" && !(options == null ? void 0 : options.useStairs) && edge.data instanceof osm.OsmWay && edge.data.areStairs && !edge.data.isConveying)
+        return false;
+      if (typeof (options == null ? void 0 : options.useEscalator) !== "undefined" && !(options == null ? void 0 : options.useEscalator) && edge.data instanceof osm.OsmWay && edge.data.areStairs && edge.data.isConveying)
+        return false;
+      if (typeof (options == null ? void 0 : options.useElevator) !== "undefined" && !(options == null ? void 0 : options.useElevator) && ((_c = edge.data) == null ? void 0 : _c.isElevator))
+        return false;
+      return true;
+    };
+    return {
+      weightEdgeFn,
+      acceptEdgeFn,
+      projectionMaxDistance: geo.GeoGraphRouter.DEFAULT_OPTIONS.projectionMaxDistance
+    };
+  }
+  static buildTripOptions(options) {
+    return Object.assign(
+      {},
+      _WemapOsmRouter.buildOptions(options),
+      { tspTempCoeff: 0.99 }
+    );
+  }
+};
+let WemapOsmRouter = _WemapOsmRouter;
+__publicField(WemapOsmRouter, "DEFAULT_OPTIONS", _WemapOsmRouter.buildOptions());
+__publicField(WemapOsmRouter, "WITHOUT_STAIRS_OPTIONS", _WemapOsmRouter.buildOptions({ useStairs: false }));
+__publicField(WemapOsmRouter, "DEFAULT_TRIP_OPTIONS", _WemapOsmRouter.buildTripOptions());
 class RemoteRouter {
 }
 class RemoteRouterServerUnreachable extends Error {
@@ -1858,8 +1915,8 @@ class WemapMultiRouter {
     }
     return ioMapsToTest;
   }
-  convertOptionsToWemapOsmOptions(options) {
-    const outputOptions = !options || !("useStairs" in options) || options.useStairs ? WemapOsmRouter.DEFAULT_OPTIONS : WemapOsmRouter.WITHOUT_STAIRS_OPTIONS;
+  convertOptionsToWemapOsmOptions(options = null) {
+    const outputOptions = WemapOsmRouter.buildOptions(options ? options : {});
     if (typeof (options == null ? void 0 : options.tspTempCoeff) !== "undefined") {
       outputOptions.tspTempCoeff = options.tspTempCoeff;
     }