@wemap/routers 12.8.10 → 12.9.0

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.8.10",
+    "version": "12.9.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "a9ac02840374bc97ddf8322f4f35d737ff49a379"
+    "gitHead": "3a52e658a5933592bcc44488f936c150638532b2"
 }

package/src/ItineraryInfoManager.spec.ts

@@ -4,7 +4,7 @@ import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-import { Coordinates } from '@wemap/geo';
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
 import { OsmParser } from '@wemap/osm';
 
 import ItineraryInfoManager, { ItineraryInfo } from './ItineraryInfoManager.js';
@@ -28,8 +28,8 @@ const load = (fileName: string) => {
     const graph = OsmGraphUtils.createGraphFromOsmModel(model);
     const osmRouter = new GraphRouter(graph);
 
-    const from = model.getNodeByName('start')?.coords as Coordinates;
-    const to = model.getNodeByName('end')?.coords as Coordinates;
+    const from = model.getNodeByName('origin')?.coords as Coordinates;
+    const to = model.getNodeByName('destination')?.coords as Coordinates;
 
     const itinerary = Itinerary.fromGraphRoute(osmRouter.calculateShortestPath(from, to).route());
     const iim = new ItineraryInfoManager();
@@ -47,7 +47,7 @@ describe('ItineraryInfoManager', () => {
 
         const { from, to, iim, model, itinerary } = load('itinerary-info-two-points.osm');
 
-        // Projection on start
+        // Projection on origin
         const position1 = model.getNodeByName('position 1')?.coords as Coordinates;
         resItineraryInfo = iim.getInfo(position1);
         expect(resItineraryInfo).is.not.null;
@@ -56,7 +56,7 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.coords.equals(from)).is.true;
         expect(itineraryInfo.previousStep).is.null;
         expect(itineraryInfo.nextStep?.number).equals(1);
-        expect(itineraryInfo.remainingDistance).almost.equals(itinerary.distance);
+        expect(itineraryInfo.remainingDistance).closeTo(8.29, 0.1);
         expect(itineraryInfo.remainingPercentage).almost.equals(1);
         expect(itineraryInfo.traveledDistance).almost.equals(0);
         expect(itineraryInfo.traveledPercentage).almost.equals(0);
@@ -70,13 +70,13 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
         expect(itineraryInfo.previousStep?.number).equals(1);
         expect(itineraryInfo.nextStep).is.null;
-        expect(itineraryInfo.remainingDistance).closeTo(itinerary.distance / 2, 0.1);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0.5);
-        expect(itineraryInfo.traveledDistance).closeTo(itinerary.distance / 2, 0.1);
-        expect(itineraryInfo.traveledPercentage).almost.equals(0.5);
+        expect(itineraryInfo.remainingDistance).closeTo(4.3, 0.1);
+        expect(itineraryInfo.remainingPercentage).closeTo(0.59, 0.01);
+        expect(itineraryInfo.traveledDistance).closeTo(3, 0.1);
+        expect(itineraryInfo.traveledPercentage).closeTo(0.41, 0.01);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
 
-        // Projection on end
+        // Projection on destination
         const position3 = model.getNodeByName('position 3')?.coords as Coordinates;
         resItineraryInfo = iim.getInfo(position3);
         expect(resItineraryInfo).is.not.null;
@@ -85,19 +85,21 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.coords.equals(to)).is.true;
         expect(itineraryInfo.previousStep?.number).equals(1);
         expect(itineraryInfo.nextStep).is.null;
-        expect(itineraryInfo.remainingDistance).almost.equals(0);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0);
-        expect(itineraryInfo.traveledDistance).almost.equals(itinerary.distance);
-        expect(itineraryInfo.traveledPercentage).almost.equals(1);
+        expect(itineraryInfo.remainingDistance).closeTo(1.65, 0.1);
+        expect(itineraryInfo.remainingPercentage).closeTo(0.21, 0.01);
+        expect(itineraryInfo.traveledDistance).closeTo(itinerary.distance, 0.1);
+        expect(itineraryInfo.traveledPercentage).closeTo(0.78, 0.01);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
 
     });
 
     it('Itinerary 2 points - from & to projection', () => {
 
-        const { iim, model, itinerary } = load('itinerary-info-two-points-proj.osm');
+        const { iim, model, itinerary, to } = load('itinerary-info-two-points-proj.osm');
+        const porigin = model.getNodeByName('porigin')?.coords as Coordinates;
+        const pdest = model.getNodeByName('pdest')?.coords as Coordinates;
 
-        // Projection on start
+        // Projection on origin
         const position1 = model.getNodeByName('position 1')?.coords as Coordinates;
         resItineraryInfo = iim.getInfo(position1);
         expect(resItineraryInfo).is.not.null;
@@ -105,7 +107,7 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
         expect(itineraryInfo.previousStep).is.null;
         expect(itineraryInfo.nextStep?.number).equals(1);
-        expect(itineraryInfo.remainingDistance).almost.equals(itinerary.distance);
+        expect(itineraryInfo.remainingDistance).almost.equals(GeoUtils.calcDistance([position1, porigin, pdest]));
         expect(itineraryInfo.remainingPercentage).almost.equals(1);
         expect(itineraryInfo.traveledDistance).almost.equals(0);
         expect(itineraryInfo.traveledPercentage).almost.equals(0);
@@ -113,15 +115,16 @@ describe('ItineraryInfoManager', () => {
 
         // Projection on middle
         const position2 = model.getNodeByName('position 2')?.coords as Coordinates;
+        const p2 = model.getNodeByName('p2')?.coords as Coordinates;
         resItineraryInfo = iim.getInfo(position2);
         expect(resItineraryInfo).is.not.null;
         itineraryInfo = resItineraryInfo as ItineraryInfo;
         expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
         expect(itineraryInfo.previousStep?.number).equals(1);
         expect(itineraryInfo.nextStep?.number).equals(2);
-        expect(itineraryInfo.remainingDistance).closeTo(3.4, 0.1);
+        expect(itineraryInfo.remainingDistance).closeTo(GeoUtils.calcDistance([position2, p2, pdest]), 0.1);
         expect(itineraryInfo.remainingPercentage).closeTo(3.4 / 4.78, 0.1);
-        expect(itineraryInfo.traveledDistance).closeTo(1.38, 0.1);
+        expect(itineraryInfo.traveledDistance).closeTo(GeoUtils.calcDistance([porigin, p2]), 0.1);
         expect(itineraryInfo.traveledPercentage).closeTo(1.38 / 4.78, 0.1);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
 
@@ -133,10 +136,10 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
         expect(itineraryInfo.previousStep?.number).equals(1);
         expect(itineraryInfo.nextStep?.number).equals(2);
-        expect(itineraryInfo.remainingDistance).almost.equals(0);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0);
-        expect(itineraryInfo.traveledDistance).almost.equals(itinerary.distance);
-        expect(itineraryInfo.traveledPercentage).almost.equals(1);
+        expect(itineraryInfo.remainingDistance).almost.equals(GeoUtils.calcDistance([position3, pdest]));
+        expect(itineraryInfo.remainingPercentage).closeTo(0.25, 0.01);
+        expect(itineraryInfo.traveledDistance).almost.equals(GeoUtils.calcDistance([porigin, pdest]));
+        expect(itineraryInfo.traveledPercentage).closeTo(0.75, 0.01);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
 
     });
@@ -162,8 +165,8 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
         expect(itineraryInfo.previousStep?.number).equals(14);
         expect(itineraryInfo.nextStep?.number).equals(15);
-        expect(itineraryInfo.remainingDistance).almost.equals(56.095);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0.0155);
+        expect(itineraryInfo.remainingDistance).closeTo(56.9, 0.1);
+        expect(itineraryInfo.remainingPercentage).closeTo(0.0155, 0.01);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
 
         position = new Coordinates(45.1641691, 5.7413891);
@@ -173,8 +176,8 @@ describe('ItineraryInfoManager', () => {
         expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
         expect(itineraryInfo.nextStep?.number).equals(15);
         expect(itineraryInfo.previousStep?.number).equals(14);
-        expect(itineraryInfo.remainingDistance).almost.equals(65.671);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0.018);
+        expect(itineraryInfo.remainingDistance).closeTo(66.4, 0.1);
+        expect(itineraryInfo.remainingPercentage).closeTo(0.018, 0.01);
         expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
     });
 });

package/src/ItineraryInfoManager.ts

@@ -29,6 +29,7 @@ class ItineraryInfoManager {
     _coordsPreviousStep: (Step | null)[] = [];
     _coordsDistanceTraveled: number[] = [];
     _coordsLeg: Leg[] = [];
+    _itineraryDistanceWithoutProjections = 0;
 
     constructor(itinerary: Itinerary | null = null) {
         this.itinerary = itinerary;
@@ -53,6 +54,11 @@ class ItineraryInfoManager {
         this._coordsPreviousStep = new Array(itinerary.coords.length);
         this._coordsDistanceTraveled = new Array(itinerary.coords.length);
         this._coordsLeg = new Array(itinerary.coords.length);
+        const originProjectionDistance = this._itinerary.origin.distanceTo(this._itinerary.coords[0]);
+        const destinationProjectionDistance = this._itinerary.destination.distanceTo(this._itinerary.coords[this._itinerary.coords.length - 1]);
+        this._itineraryDistanceWithoutProjections = itinerary.distance 
+            - originProjectionDistance
+            - destinationProjectionDistance;
 
         let stepId = 0;
         let previousStep: Step | null = null;
@@ -98,17 +104,31 @@ class ItineraryInfoManager {
                 throw new Error('ItineraryInfoManager: could not find projection in itinerary (Node)');
             }
 
-            const traveledDistance = this._coordsDistanceTraveled[idx];
-            const remainingDistance = this._itinerary.distance - traveledDistance;
+            const traveledDistanceOnItinerary = this._coordsDistanceTraveled[idx];
+
+            // Traveled distance takes into account:
+            // - projection of the origin
+            const traveledDistance = traveledDistanceOnItinerary;
+
+            // Remaining distance takes into account:
+            // - projection of the current position
+            // - distance remaining on the itinerary
+            const remainingDistanceOnItinerary = this._itineraryDistanceWithoutProjections - traveledDistanceOnItinerary;
+            const remainingDistance = projection.distanceFromNearestElement + remainingDistanceOnItinerary;
+
+            const distanceForPercentage = traveledDistance + remainingDistance
+            const traveledPercentage = traveledDistance / distanceForPercentage;
+            const remainingPercentage = 1 - traveledPercentage;
+
             itineraryInfo = {
                 nextStep: this._coordsNextStep[idx],
                 previousStep: this._coordsPreviousStep[idx],
                 projection: projection,
                 leg: this._coordsLeg[idx],
-                traveledDistance,
+                traveledDistance: traveledDistanceOnItinerary,
                 remainingDistance,
-                traveledPercentage: traveledDistance / this._itinerary.distance,
-                remainingPercentage: remainingDistance / this._itinerary.distance
+                traveledPercentage,
+                remainingPercentage
             };
 
         } else if (projection.nearestElement instanceof Edge) {
@@ -127,9 +147,23 @@ class ItineraryInfoManager {
                 idx--;
             }
 
-            const traveledDistance = this._coordsDistanceTraveled[idx]
+            const traveledDistanceOnItinerary = this._coordsDistanceTraveled[idx] 
                 + projection.coords.distanceTo(firstNode);
-            const remainingDistance = this._itinerary.distance - traveledDistance;
+            
+            // Traveled distance takes into account:
+            // - distance traveled on the itinerary
+            const traveledDistance = traveledDistanceOnItinerary;
+
+            // Remaining distance takes into account:
+            // - projection of the current position
+            // - distance remaining on the itinerary
+            const remainingDistanceOnItinerary = this._itineraryDistanceWithoutProjections - traveledDistanceOnItinerary;
+            const remainingDistance = projection.distanceFromNearestElement + remainingDistanceOnItinerary 
+
+            const distanceForPercentage = traveledDistance + remainingDistance
+            const traveledPercentage = traveledDistance / distanceForPercentage;
+            const remainingPercentage = 1 - traveledPercentage;
+
             itineraryInfo = {
                 nextStep: this._coordsNextStep[idx + 1],
                 previousStep: this._coordsPreviousStep[idx + 1],
@@ -137,8 +171,8 @@ class ItineraryInfoManager {
                 leg: this._coordsLeg[idx + 1],
                 traveledDistance,
                 remainingDistance,
-                traveledPercentage: traveledDistance / this._itinerary.distance,
-                remainingPercentage: remainingDistance / this._itinerary.distance
+                traveledPercentage,
+                remainingPercentage
             };
 
         }

package/src/RoutingError.ts

@@ -26,7 +26,7 @@ export class WemapMultiRoutingError extends RoutingError {
     }
 
     static notFound(mapName: string, details?: string) {
-        return new WemapMultiRoutingError(StatusCode.NOT_FOUND, mapName, `Cannot found an itinerary in map ${mapName}. Details: ${details}`)
+        return new WemapMultiRoutingError(StatusCode.NOT_FOUND, mapName, `Cannot found an itinerary in map ${mapName}. Details: ${details || 'No details'}`)
     }
 
 }
@@ -39,7 +39,7 @@ export class RemoteRoutingError extends RoutingError {
     }
 
     static notFound(routerName: string, details?: string) {
-        return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Cannot found an itinerary with ${routerName}. Details: ${details}`)
+        return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Cannot found an itinerary with ${routerName}. Details: ${details || 'No details'}`)
     }
 
     static missingApiKey(routerName: string, details?: string) {

package/src/graph/GraphRoute.ts

@@ -37,7 +37,7 @@ class GraphRoute extends Graph {
         return new GraphRoute(start, end, graph.vertices, graph.edges, edgesWeights);
     }
 
-    get hasRoute() { return Boolean(this.edges.length) }
+    get hasRoute() { return Boolean(this.vertices.length) }
 }
 
 export default GraphRoute;

package/src/model/Itinerary.ts

@@ -61,9 +61,17 @@ export default class Itinerary {
         this.origin = origin;
         this.destination = destination;
         this.legs = legs;
-        this.duration = typeof duration === 'number'
-            ? duration
-            : this.legs.reduce((dur, leg) => dur + leg.duration, 0);
+        if (typeof duration === 'number') {
+            this.duration = duration;
+        } else {
+            const firstCoords = this.legs[0].coords[0];
+            const lastLeg = this.legs[this.legs.length - 1];
+            const lastCoords = lastLeg.coords[lastLeg.coords.length - 1];
+            // Projection duration is calculated using walking mode 
+            const originProjectionDuration = getDurationFromLength(this.origin.distanceTo(firstCoords));
+            const destinationProjectionDuration = getDurationFromLength(this.destination.distanceTo(lastCoords));
+            this.duration = this.legs.reduce((dur, leg) => dur + leg.duration, originProjectionDuration + destinationProjectionDuration);
+        }
         this.startTime = typeof startTime === 'number' ? startTime : null;
         this.endTime = typeof endTime === 'number' ? endTime : null;
 
@@ -131,7 +139,7 @@ export default class Itinerary {
 
     get distance() {
         if (this._distance === null) {
-            this._distance = GeoUtils.calcDistance(this.coords);
+            this._distance = GeoUtils.calcDistance([this.origin, ...this.coords, this.destination]);
         }
         return this._distance;
 
@@ -144,19 +152,10 @@ export default class Itinerary {
     }
 
     static fromItineraries(...itineraries: Itinerary[]) {
-        let duration = 0;
-        const legs: Leg[] = [];
-
-        itineraries.forEach(_itinerary => {
-            duration += _itinerary.duration;
-            legs.push(..._itinerary.legs);
-        });
-
         return new Itinerary({
             origin: itineraries[0].origin,
             destination: itineraries[itineraries.length - 1].destination,
-            duration,
-            legs
+            legs: itineraries.map(itinerary => itinerary.legs).flat(),
         });
     }
 
@@ -257,7 +256,6 @@ export default class Itinerary {
         return new Itinerary({
             origin: graphRoute.start,
             destination: graphRoute.end,
-            duration: leg.duration,
             legs: [leg]
         });
     }

package/src/remote/cityway/CitywayRemoteRouter.spec.ts

@@ -31,7 +31,7 @@ describe('CitywayRemoteRouter - parseResponse', () => {
         const itinerary1 = itineraries[0];
         expect(itinerary1.origin.equals(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
         expect(itinerary1.destination.equals(new Coordinates(49.5067090188444, 0.16948421154178309))).true;
-        expect(itinerary1.distance).to.be.closeTo(6887, 1);
+        expect(itinerary1.distance).to.be.closeTo(6919, 1);
         expect(itinerary1.duration).equal(2379);
         expect(itinerary1.transitMode).equal('BUS');
         // Do not work because of the input time format

package/src/remote/deutsche-bahn/DeutscheBahnRemoteRouter.spec.ts

@@ -36,8 +36,8 @@ describe('DeutscheBahnRemoteRouter - parseResponse', () => {
         expect(itinerary1.origin.equals(origin)).true;
         expect(itinerary1.destination.equals(destination)).true;
         expect(itinerary1.coords.length).equal(77);
-        expect(itinerary1.distance).closeTo(129.6, 0.1);
-        expect(itinerary1.duration).almost.equal(93.305);
+        expect(itinerary1.distance).closeTo(130, 1);
+        expect(itinerary1.duration).closeTo(94, 1);
         expect(itinerary1.transitMode).equal('WALK');
 
         const itinerary1leg1 = itinerary1.legs[0];

package/src/remote/geovelo/GeoveloRemoteRouter.spec.ts

@@ -31,7 +31,7 @@ describe('GeoveloRouter - parseResponse', () => {
         const itinerary1 = itineraries[0];
         expect(itinerary1.origin.equals(new Coordinates(43.596949, 3.877772))).true;
         expect(itinerary1.destination.equals(new Coordinates(43.609609, 3.914684))).true;
-        expect(itinerary1.distance).to.be.closeTo(4029, 1);
+        expect(itinerary1.distance).to.be.closeTo(4031, 1);
         expect(itinerary1.duration).equal(1053);
         expect(itinerary1.transitMode).equal('BIKE');
         // Do not work because of the input time format

package/src/remote/osrm/OsrmRemoteRouter.spec.ts

@@ -37,7 +37,7 @@ describe('OsrmRemoteRouter - parseResponse', () => {
         const itinerary1 = itineraries[0];
         expect(itinerary1.origin.equals(origin)).true;
         expect(itinerary1.destination.equals(destination)).true;
-        expect(itinerary1.distance).closeTo(400, 1);
+        expect(itinerary1.distance).closeTo(429, 1);
         expect(itinerary1.duration).equal(287.8);
         expect(itinerary1.startTime).is.null;
         expect(itinerary1.endTime).is.null;

package/src/wemap-multi/CustomGraphMap.ts

@@ -196,7 +196,8 @@ export default class CustomGraphMap {
 
     getRouteInsideMap(start: Coordinates, end: Coordinates, options: GraphRouterOptions) {
         // Call the Wemap router to get the shortest path
-        return this.router.calculateShortestPath(start, end, options).route();
+        const route = this.router.calculateShortestPath(start, end, options).route();
+        return route.hasRoute ? route : null;
     }
 
     getTripInsideMap(waypoints: Coordinates[], options: GraphRouterOptions) {