@wemap/geo 11.7.0 → 11.8.0

package/dist/index.js

@@ -1725,6 +1725,9 @@ class NoRouteFoundError extends Error {
     if (this.end instanceof GeoGraphVertex) {
       return `GeoGraphVertex ${this.end.coords.toString()}`;
     }
+    if (Array.isArray(this.end)) {
+      return this.end.map((p) => p instanceof GeoGraphVertex ? p.coords.toString() : p.toString()).join(",");
+    }
     return this.end.toString();
   }
   get message() {
@@ -1747,7 +1750,7 @@ const _GeoGraphRouter = class _GeoGraphRouter {
     const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
     this._mapMatching.maxDistance = projectionMaxDistance;
     const createdVertices = [];
-    const retrieveOrCreateNearestVertex = (point) => {
+    const retrieveOrCreateNearestVertex = (point, options2 = _GeoGraphRouter.DEFAULT_OPTIONS) => {
       if (point instanceof GeoGraphVertex) {
         return point;
       }
@@ -1755,7 +1758,7 @@ const _GeoGraphRouter = class _GeoGraphRouter {
       if (closeVertex) {
         return closeVertex;
       }
-      const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
+      const proj = this._mapMatching.getProjection(point, true, false, false, options2.acceptEdgeFn);
       if (!proj) {
         let message = `Point ${point.toString()} is too far from the graph > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
         if (point.level !== null) {
@@ -1806,6 +1809,71 @@ const _GeoGraphRouter = class _GeoGraphRouter {
     }
     return graphItinerary;
   }
+  getShortestPaths(start, ends, options = _GeoGraphRouter.DEFAULT_OPTIONS) {
+    const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
+    this._mapMatching.maxDistance = projectionMaxDistance;
+    const createdVertices = [];
+    const retrieveOrCreateNearestVertex = (point, options2 = _GeoGraphRouter.DEFAULT_OPTIONS) => {
+      if (point instanceof GeoGraphVertex) {
+        return point;
+      }
+      const closeVertex = this._graph.getVertexByCoords(point);
+      if (closeVertex) {
+        return closeVertex;
+      }
+      const proj = this._mapMatching.getProjection(point, true, false, false, options2.acceptEdgeFn);
+      if (!proj) {
+        return null;
+      }
+      if (proj.nearestElement instanceof GeoGraphVertex) {
+        return proj.nearestElement;
+      }
+      const vertexCreated = this.createVertexInsideEdge(
+        proj.nearestElement,
+        proj.coords
+      );
+      createdVertices.push(vertexCreated);
+      return vertexCreated;
+    };
+    const removeCreatedVertices = () => {
+      while (createdVertices.length) {
+        this.removeVertexFromPreviouslyCreatedEdge(createdVertices.pop());
+      }
+    };
+    const startVertex = retrieveOrCreateNearestVertex(start);
+    const endsStruct = ends.map((e) => ({
+      input: e,
+      vertex: retrieveOrCreateNearestVertex(e),
+      itinerary: null
+    }));
+    const startCoords = start instanceof GeoGraphVertex ? start.coords : start;
+    if (!startVertex) {
+      let message = `Point ${startCoords.toString()} is too far from the graph > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
+      if (startCoords.level !== null) {
+        message += ` If it is a multi-level map, please verify if you have a graph at level ${Level.toString(startCoords.level)}.`;
+      }
+      throw new NoRouteFoundError(start, ends, message);
+    }
+    const endsStructFiltered = endsStruct.filter((v) => v.vertex != null);
+    const graphItineraries = this.getShortestPathsBetweenGeoGraphVertices(
+      startVertex,
+      endsStructFiltered.map((v) => v.vertex),
+      weightEdgeFn,
+      acceptEdgeFn
+    );
+    graphItineraries.forEach((itinerary, idx) => {
+      itinerary.start = startCoords;
+      const endStructFiltered = endsStructFiltered[idx];
+      endStructFiltered.itinerary = itinerary;
+    });
+    removeCreatedVertices();
+    endsStructFiltered.forEach((e) => {
+      if (e.itinerary !== null) {
+        e.itinerary.end = e.input instanceof GeoGraphVertex ? e.input.coords : e.input;
+      }
+    });
+    return endsStructFiltered.map((e) => e.itinerary);
+  }
   createVertexInsideEdge(edge, point) {
     const a = edge.vertex1;
     const b = edge.vertex2;
@@ -1893,6 +1961,65 @@ const _GeoGraphRouter = class _GeoGraphRouter {
     }
     return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
   }
+  getShortestPathsBetweenGeoGraphVertices(start, ends, weightFn, acceptEdgeFn) {
+    const distanceMap = {}, checking = {}, vertexList = {}, vertices = {}, parentVertices = {};
+    this._graph.vertices.forEach((vertex) => {
+      vertices[vertex.id] = vertex;
+      distanceMap[vertex.id] = Infinity;
+      checking[vertex.id] = null;
+      vertexList[vertex.id] = true;
+    });
+    distanceMap[start.id] = 0;
+    while (Object.keys(vertexList).length > 0) {
+      const keys = Object.keys(vertexList).map(Number);
+      const current = Number(
+        keys.reduce((_checking, vertexId) => {
+          return distanceMap[_checking] > distanceMap[vertexId] ? vertexId : _checking;
+        }, keys[0])
+      );
+      this._graph.edges.filter((edge) => {
+        if (acceptEdgeFn && !acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
+          return false;
+        }
+        const from = edge.vertex1.id, to = edge.vertex2.id;
+        return from === current || to === current;
+      }).forEach((edge) => {
+        let to, from, reversed = false;
+        if (edge.vertex1.id === current) {
+          to = edge.vertex2.id;
+          from = edge.vertex1.id;
+        } else {
+          to = edge.vertex1.id;
+          from = edge.vertex2.id;
+          reversed = true;
+        }
+        if (edge.isOneway && reversed) {
+          return;
+        }
+        const distance = distanceMap[current] + weightFn(edge);
+        if (distanceMap[to] > distance) {
+          distanceMap[to] = distance;
+          checking[to] = current;
+          parentVertices[to] = from;
+        }
+      });
+      delete vertexList[current];
+    }
+    return ends.map((end) => {
+      const edgesWeights = [];
+      const path = [];
+      let endId = end.id;
+      while (typeof parentVertices[endId] !== "undefined") {
+        path.unshift(vertices[endId]);
+        edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
+        endId = parentVertices[endId];
+      }
+      if (path.length !== 0) {
+        path.unshift(start);
+      }
+      return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
+    });
+  }
 };
 __publicField(_GeoGraphRouter, "DEFAULT_OPTIONS", {
   projectionMaxDistance: 50,