@wemap/geo 11.7.0 → 11.8.1

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "11.7.0",
+    "version": "11.8.1",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -45,5 +45,5 @@
         },
         "./tests/*": "./tests/*"
     },
-    "gitHead": "e06f16f4114b6e8da0c0f6bbda65c1ad1a3f45ce"
+    "gitHead": "7d7d2a3e1988e60a28121b557b6aa1eab1308f13"
 }

package/src/graph/GeoGraphRouter.ts

@@ -42,17 +42,23 @@ class GeoGraphRouter<VertexData = unknown, EdgeData = unknown> {
 
         const createdVertices: GeoGraphVertex<VertexData, EdgeData>[] = [];
 
-        const retrieveOrCreateNearestVertex = (point: GeoGraphVertex<VertexData, EdgeData> | Coordinates) => {
-            if (point instanceof GeoGraphVertex) {
-                return point;
-            }
+        const retrieveOrCreateNearestVertex = (
+            point: Coordinates | GeoGraphVertex<VertexData, EdgeData>
+        ): GeoGraphVertex<VertexData, EdgeData> => {
+
+            if (point instanceof GeoGraphVertex) { return point; }
 
             const closeVertex = this._graph.getVertexByCoords(point);
+            // Case 1. Vertex is close enough to an existing one (some centimeters)
             if (closeVertex) {
                 return closeVertex;
             }
 
-            const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
+            const proj = this._mapMatching.getProjection(point, true, false, false, options.acceptEdgeFn);
+
+            // Case 2. We cannot find a projection of the coordinates on the graph.
+            // This can happens if it's a multi level graph and the input coordinates have a level which is not covered by the graph.
+            // It can also happens because the input coordinates are too far from the graph.
             if (!proj) {
                 let message = `Point ${point.toString()} is too far from the graph `
                     + `> ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
@@ -62,10 +68,13 @@ class GeoGraphRouter<VertexData = unknown, EdgeData = unknown> {
                 }
                 throw new NoRouteFoundError(start, end, message);
             }
+
+            // Case 3. Nearest element is a vertex, so it is not necessary to create a new vertex 
             if (proj.nearestElement instanceof GeoGraphVertex) {
                 return proj.nearestElement;
             }
-            // if (proj.nearestElement instanceof Edge)
+
+            // Case 4. Nearest element is an edge, so a new vertex is created
             const vertexCreated = this.createVertexInsideEdge(
                 proj.nearestElement,
                 proj.coords
@@ -83,7 +92,6 @@ class GeoGraphRouter<VertexData = unknown, EdgeData = unknown> {
         const startVertex = retrieveOrCreateNearestVertex(start);
         const endVertex = retrieveOrCreateNearestVertex(end);
 
-
         const startCoords = start instanceof GeoGraphVertex ? start.coords : start;
         const endCoords = end instanceof GeoGraphVertex ? end.coords : end;
 
@@ -116,6 +124,116 @@ class GeoGraphRouter<VertexData = unknown, EdgeData = unknown> {
 
     }
 
+
+    getShortestPaths(
+        start: GeoGraphVertex<VertexData, EdgeData> | Coordinates,
+        ends: (GeoGraphVertex<VertexData, EdgeData> | Coordinates)[],
+        options: GeoGraphRouterOptions<VertexData, EdgeData> = GeoGraphRouter.DEFAULT_OPTIONS
+    ) {
+
+        const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
+        this._mapMatching.maxDistance = projectionMaxDistance;
+
+        const createdVertices: GeoGraphVertex<VertexData, EdgeData>[] = [];
+
+        const retrieveOrCreateNearestVertex = (
+            point: Coordinates | GeoGraphVertex<VertexData, EdgeData>,
+            options: GeoGraphRouterOptions<VertexData, EdgeData> = GeoGraphRouter.DEFAULT_OPTIONS
+        ): GeoGraphVertex<VertexData, EdgeData> | null => {
+
+            if (point instanceof GeoGraphVertex) { return point; }
+
+            const closeVertex = this._graph.getVertexByCoords(point);
+            // Case 1. Vertex is close enough to an existing one (some centimeters)
+            if (closeVertex) {
+                return closeVertex;
+            }
+
+            const proj = this._mapMatching.getProjection(point, true, false, false, options.acceptEdgeFn);
+
+            // Case 2. We cannot find a projection of the coordinates on the graph.
+            // This can happens if it's a multi level graph and the input coordinates have a level which is not covered by the graph.
+            // It can also happens because the input coordinates are too far from the graph.
+            if (!proj) {
+                return null;
+            }
+
+            // Case 3. Nearest element is a vertex, so it is not necessary to create a new vertex 
+            if (proj.nearestElement instanceof GeoGraphVertex) {
+                return proj.nearestElement;
+            }
+
+            // Case 4. Nearest element is an edge, so a new vertex is created
+            const vertexCreated = this.createVertexInsideEdge(
+                proj.nearestElement,
+                proj.coords
+            );
+            createdVertices.push(vertexCreated);
+            return vertexCreated;
+        };
+
+
+        const removeCreatedVertices = () => {
+            while (createdVertices.length) {
+                this.removeVertexFromPreviouslyCreatedEdge(createdVertices.pop() as GeoGraphVertex<VertexData, EdgeData>);
+            }
+        };
+
+        const startVertex = retrieveOrCreateNearestVertex(start);
+
+        const endsStruct: {
+            input: GeoGraphVertex<VertexData, EdgeData> | Coordinates,
+            vertex: GeoGraphVertex<VertexData, EdgeData> | null,
+            itinerary: GeoGraphItinerary<VertexData, EdgeData> | null
+        }[] = 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) as
+            {
+                input: GeoGraphVertex<VertexData, EdgeData> | Coordinates,
+                vertex: GeoGraphVertex<VertexData, EdgeData>,
+                itinerary: GeoGraphItinerary<VertexData, EdgeData> | null
+            }[];
+
+        const graphItineraries = this.getShortestPathsBetweenGeoGraphVertices(
+            startVertex,
+            endsStructFiltered.map(v => v.vertex),
+            weightEdgeFn,
+            acceptEdgeFn
+        );
+
+        // In the case of start or end are not a vertex, graphItinerary.start/end are first vertex or 
+        //  last vertex. We have to override their values.
+        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: GeoGraphEdge<VertexData, EdgeData>, point: Coordinates) {
         const a = edge.vertex1;
         const b = edge.vertex2;
@@ -261,5 +379,112 @@ class GeoGraphRouter<VertexData = unknown, EdgeData = unknown> {
         // This clone the itinerary and temporary vertices
         return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
     }
+
+    getShortestPathsBetweenGeoGraphVertices(
+        start: GeoGraphVertex<VertexData, EdgeData>,
+        ends: GeoGraphVertex<VertexData, EdgeData>[],
+        weightFn: (edge: GeoGraphEdge<VertexData, EdgeData>) => number,
+        acceptEdgeFn?: (edge: GeoGraphEdge<VertexData, EdgeData>) => boolean
+    ) {
+
+        const distanceMap: { [key: number]: number } = {},
+            checking: { [key: number]: null | number } = {},
+            vertexList: { [key: number]: boolean } = {},
+            vertices: { [key: number]: GeoGraphVertex<VertexData, EdgeData> } = {},
+            parentVertices: { [key: number]: number } = {};
+
+        // Initially, we assume each vertex is unreachable
+        this._graph.vertices.forEach(vertex => {
+
+            // Generate Unique Router Id
+            vertices[vertex.id] = vertex;
+            distanceMap[vertex.id] = Infinity;
+            checking[vertex.id] = null;
+            vertexList[vertex.id] = true;
+        });
+
+        // The cost from the starting vertex to the starting vertex is 0
+        distanceMap[start.id] = 0;
+
+        // check each vertex
+        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])
+            );
+
+            // all the vertices accessible from current vertex
+            this._graph.edges
+                .filter(edge => {
+
+                    if (acceptEdgeFn && !acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
+                        return false;
+                    }
+
+                    const from = edge.vertex1.id,
+                        to = edge.vertex2.id;
+                    // are these vertices joined?
+                    return from === current || to === current;
+                })
+                // for each vertex we can reach
+                .forEach(edge => {
+                    let to, from, reversed = false;
+                    // determine the direction of travel
+                    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;
+                    }
+
+                    // distance is how far we travelled to reach the
+                    // current vertex, plus cost of travel the next(to)
+                    const distance = distanceMap[current] + weightFn(edge);
+
+                    // if we have found a cheaper path
+                    // update the hash of costs
+                    // and record which vertex we came from
+                    if (distanceMap[to] > distance) {
+                        distanceMap[to] = distance;
+                        checking[to] = current;
+                        parentVertices[to] = from;
+                    }
+                });
+
+            // remove vertex so we don't revisit it
+            delete vertexList[current];
+        }
+
+
+        return ends.map(end => {
+            const edgesWeights = [];
+            const path: GeoGraphVertex<VertexData, EdgeData>[] = [];
+
+            // now we have the most efficient paths for all vertices
+            // build the path for the user specified vertex(end)
+            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);
+            }
+
+            // This clone the itinerary and temporary vertices
+            return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
+        });
+    }
 }
 export default GeoGraphRouter;

package/src/graph/NoRouteFoundError.ts

@@ -5,7 +5,7 @@ class NoRouteFoundError extends Error {
 
     constructor(
         public start: GeoGraphVertex | Coordinates,
-        public end: GeoGraphVertex | Coordinates,
+        public end: GeoGraphVertex | Coordinates | (Coordinates | GeoGraphVertex)[],
         public details: string | null = null
     ) { super(); }
 
@@ -13,8 +13,6 @@ class NoRouteFoundError extends Error {
         if (this.start instanceof GeoGraphVertex) {
             return `GeoGraphVertex ${this.start.coords.toString()}`;
         }
-
-        // if (this.start instanceof Coordinates) {
         return this.start.toString();
     }
 
@@ -22,8 +20,9 @@ class NoRouteFoundError extends Error {
         if (this.end instanceof GeoGraphVertex) {
             return `GeoGraphVertex ${this.end.coords.toString()}`;
         }
-
-        // if (this.end instanceof Coordinates) {
+        if (Array.isArray(this.end)) {
+            return this.end.map(p => p instanceof GeoGraphVertex ? p.coords.toString() : p.toString()).join(',');
+        }
         return this.end.toString();
     }