@wemap/routers 11.2.3 → 11.3.0

package/src/wemap-osm/OsmRouter.ts

@@ -11,39 +11,14 @@ import { getDurationFromLength } from '../Utils.js';
 import OsmGraph, { OsmEdge, OsmEdgeData, OsmVertex, OsmVertexData } from './OsmGraph.js';
 import Leg from '../model/Leg.js';
 import { MinStepInfo } from '../model/Step.js';
+import { OsmRouterOptions } from './OsmRouterOptions.js';
 
 
-const DEFAULT_OPTIONS = Object.assign({}, GeoGraphRouter.DEFAULT_OPTIONS, {
-    weightEdgeFn: (edge: OsmEdge) => {
-        if (edge.data.isElevator) {
-            return 90;
-        }
-        let duration = getDurationFromLength(edge.length, 4);
-        if (edge.data instanceof OsmWay && edge.data.areStairs) {
-            duration *= 3;
-        }
-        return duration;
-    },
-    acceptEdgeFn: (edge: GeoGraphEdge) => {
-        const accessTag = (edge as OsmEdge).data.tags.access;
-        return typeof accessTag === 'undefined' || accessTag === 'yes';
-    }
-});
-
-const WITHOUT_STAIRS_OPTIONS = Object.assign({}, DEFAULT_OPTIONS, {
-    acceptEdgeFn: (edge: GeoGraphEdge) => (edge as OsmEdge).data.tags.highway !== 'steps'
-});
-
 export type GeoGraphTripRouterOptions<VertexData = unknown, EdgeData = unknown> =
     GeoGraphRouterOptions<VertexData, EdgeData> & {
         tspTempCoeff?: number; // https://github.com/wemap/salesman.js/blob/master/salesman.js#L164
     };
 
-const DEFAULT_TRIP_OPTIONS = Object.assign({}, {
-    tspTempCoeff: 0.99
-}, GeoGraphRouter.DEFAULT_OPTIONS);
-
-
 const buildStepsRules = (graphItinerary: OsmItinerary): StepsGenerationRules => (
     currentCoords: Coordinates,
     nextCoords: Coordinates,
@@ -64,10 +39,14 @@ const buildStepsRules = (graphItinerary: OsmItinerary): StepsGenerationRules =>
     let levelChangeType: LevelChangeType | null = null;
     if (edge.data.isElevator) {
         levelChangeType = 'elevator';
-    } else if (edge.data.isConveying) {
+    } else if (edge.data instanceof OsmWay && edge.data.isConveying && edge.data.areStairs) {
+        // TODO: change to escalator
         levelChangeType = 'conveyor';
+        // levelChangeType = 'escalator';
     } else if (edge.data instanceof OsmWay && edge.data.areStairs) {
         levelChangeType = 'stairs';
+    } else if (edge.data instanceof OsmWay && edge.data.isConveying) {
+        levelChangeType = 'moving walkway';
     }
 
     // Handle stairs/elevator/conveyors without change in level coordinates
@@ -124,8 +103,9 @@ export class OsmItinerary extends GeoGraphItinerary<OsmVertexData, OsmEdgeData>
 
 class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
 
-    static DEFAULT_OPTIONS = DEFAULT_OPTIONS;
-    static WITHOUT_STAIRS_OPTIONS = WITHOUT_STAIRS_OPTIONS;
+    static DEFAULT_OPTIONS = WemapOsmRouter.buildOptions();
+    static WITHOUT_STAIRS_OPTIONS = WemapOsmRouter.buildOptions({ useStairs: false });
+    static DEFAULT_TRIP_OPTIONS = WemapOsmRouter.buildTripOptions();
 
     constructor(graph: OsmGraph) {
         super(graph);
@@ -138,7 +118,7 @@ class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
     getShortestPath(
         start: OsmVertex | Coordinates,
         end: OsmVertex | Coordinates,
-        options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData> = DEFAULT_OPTIONS
+        options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData> = WemapOsmRouter.DEFAULT_OPTIONS
     ) {
         return super.getShortestPath(start, end, options) as OsmItinerary;
     }
@@ -146,7 +126,7 @@ class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
     getItinerary(
         start: OsmVertex | Coordinates,
         end: OsmVertex | Coordinates,
-        options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData> = DEFAULT_OPTIONS
+        options: GeoGraphRouterOptions<OsmVertexData, OsmEdgeData> = WemapOsmRouter.DEFAULT_OPTIONS
     ) {
         const graphItinerary = this.getShortestPath(start, end, options);
 
@@ -177,7 +157,7 @@ class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
 
     getShortestTrip(
         waypoints: Coordinates[],
-        options: GeoGraphTripRouterOptions<OsmVertexData, OsmEdgeData> = DEFAULT_TRIP_OPTIONS
+        options: GeoGraphTripRouterOptions<OsmVertexData, OsmEdgeData> = WemapOsmRouter.DEFAULT_TRIP_OPTIONS
     ) {
         type CustomPoint = salesman.Point & { coords: Coordinates };
 
@@ -221,7 +201,7 @@ class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
 
     getTripItinerary(
         waypoints: Coordinates[],
-        options: GeoGraphTripRouterOptions<OsmVertexData, OsmEdgeData> = DEFAULT_TRIP_OPTIONS
+        options: GeoGraphTripRouterOptions<OsmVertexData, OsmEdgeData> = WemapOsmRouter.DEFAULT_TRIP_OPTIONS
     ) {
         const shortestTrip = this.getShortestTrip(waypoints, options);
         return new Itinerary({
@@ -230,6 +210,54 @@ class WemapOsmRouter extends GeoGraphRouter<OsmVertexData, OsmEdgeData> {
             legs: shortestTrip.map(graphItinerary => Leg.fromGraphItinerary(graphItinerary))
         });
     }
+
+    static buildOptions(options?: OsmRouterOptions): GeoGraphRouterOptions<OsmVertexData, OsmEdgeData> {
+
+        const weightEdgeFn = (edge: GeoGraphEdge<OsmVertexData, OsmEdgeData>) => {
+            if (edge.data?.isElevator) {
+                return 90;
+            }
+            let duration = getDurationFromLength(edge.length, 4);
+            if (edge.data instanceof OsmWay && edge.data.areStairs) {
+                duration *= 3;
+            }
+            return duration;
+        }
+
+        const acceptEdgeFn = (edge: GeoGraphEdge<OsmVertexData, OsmEdgeData>) => {
+
+            // Verify access
+            const accessTag = edge.data?.tags?.access;
+            if (typeof accessTag !== 'undefined' && accessTag !== 'yes') return false;
+
+            // Verify stairs
+            if (typeof options?.useStairs !== 'undefined' && !options?.useStairs
+                && edge.data instanceof OsmWay && edge.data.areStairs && !edge.data.isConveying) return false;
+
+            // Verify escalators
+            if (typeof options?.useEscalator !== 'undefined' && !options?.useEscalator
+                && edge.data instanceof OsmWay && edge.data.areStairs && edge.data.isConveying) return false;
+
+            // Verify elevator
+            if (typeof options?.useElevator !== 'undefined' && !options?.useElevator && edge.data?.isElevator) return false;
+
+            return true;
+        };
+
+        return {
+            weightEdgeFn,
+            acceptEdgeFn,
+            projectionMaxDistance: GeoGraphRouter.DEFAULT_OPTIONS.projectionMaxDistance
+        };
+    }
+
+    static buildTripOptions(options?: OsmRouterOptions): GeoGraphTripRouterOptions<OsmVertexData, OsmEdgeData> {
+        return Object.assign({},
+            WemapOsmRouter.buildOptions(options),
+            { tspTempCoeff: 0.99 }
+        );
+    }
+
 }
 
 export default WemapOsmRouter;

package/src/wemap-osm/OsmRouterOptions.ts

@@ -0,0 +1,12 @@
+export type OsmRouterOptions = {
+
+    useStairs?: boolean;
+
+    useEscalator?: boolean;
+
+    useElevator?: boolean;
+
+    isTrip?: boolean;
+
+    tspTempCoeff?: number;
+}