minotor 7.0.2 → 9.0.0

package/src/routing/plotter.ts

@@ -1,68 +1,299 @@
 import { StopId } from '../stops/stops.js';
 import { Result } from './result.js';
-import { TripLeg } from './router.js';
+import { RoutingEdge, TransferEdge, VehicleEdge } from './router.js';
 
 export class Plotter {
   private result: Result;
+  private readonly ROUND_COLORS = [
+    '#60a5fa', // Round 1
+    '#ff9800', // Round 2
+    '#14b8a6', // Round 3
+    '#fb7185', // Round 4
+    '#ffdf00', // Round 5
+    '#b600ff', // Round 6
+    '#ee82ee', // Round 7+
+  ];
 
   constructor(result: Result) {
     this.result = result;
   }
 
   /**
-   * Plots the path three as a DOT for debugging purposes.
-   *
-   * @returns A string representing the DOT graph of the path tree.
+   * Gets the color for a round based on the specified palette.
    */
-  plotDotGraph(): string {
-    const earliestArrivalsPerRound: Map<StopId, TripLeg>[] =
-      this.result.earliestArrivalsPerRound;
+  private getRoundColor(round: number): string {
+    if (round === 0) return '#888888';
+
+    const colorIndex = Math.min(round - 1, this.ROUND_COLORS.length - 1);
+    return this.ROUND_COLORS[colorIndex] ?? '#ee82ee';
+  }
+
+  /**
+   * Escapes special characters in DOT strings to prevent syntax errors.
+   */
+  private escapeDotString(str: string): string {
+    return str
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g, '\\"')
+      .replace(/\n/g, '\\n')
+      .replace(/\r/g, '\\r')
+      .replace(/\t/g, '\\t');
+  }
+
+  /**
+   * Determines station type (origin/destination) information.
+   */
+  private getStationInfo(stopId: StopId): {
+    isOrigin: boolean;
+    isDestination: boolean;
+  } {
+    const isOrigin = this.result.routingState.graph[0]?.has(stopId) ?? false;
+    const isDestination =
+      this.result.routingState.destinations.includes(stopId);
+    return { isOrigin, isDestination };
+  }
+
+  /**
+   * Formats a stop name for display, including platform information.
+   */
+  private formatStopName(stopId: StopId): string {
+    const stop = this.result.stopsIndex.findStopById(stopId);
+    if (!stop) return `Unknown Stop (${stopId})`;
+
+    const escapedName = this.escapeDotString(stop.name);
+    const escapedPlatform = stop.platform
+      ? this.escapeDotString(stop.platform)
+      : '';
+    return escapedPlatform
+      ? `${escapedName}\\nPl. ${escapedPlatform}`
+      : escapedName;
+  }
+
+  /**
+   * Gets the appropriate fill color for a station based on its type.
+   */
+  private getStationFillColor(
+    isOrigin: boolean,
+    isDestination: boolean,
+  ): string {
+    if (isOrigin) return '#60a5fa';
+    if (isDestination) return '#ee82ee';
+    return 'white';
+  }
 
-    const dotParts: string[] = [
-      'digraph PathTree {',
-      '  graph [overlap=false];',
-      '  node [shape=ellipse style=filled fillcolor=lightgrey];',
+  /**
+   * Creates a DOT node for a station.
+   */
+  private createStationNode(stopId: StopId): string {
+    const stop = this.result.stopsIndex.findStopById(stopId);
+    if (!stop) return '';
+
+    const displayName = this.formatStopName(stopId);
+    const stopIdStr = this.escapeDotString(String(stopId));
+    const nodeId = `s_${stopId}`;
+    const stationInfo = this.getStationInfo(stopId);
+    const fillColor = this.getStationFillColor(
+      stationInfo.isOrigin,
+      stationInfo.isDestination,
+    );
+
+    return `  "${nodeId}" [label="${displayName}\\n${stopIdStr}" shape=box style=filled fillcolor="${fillColor}"];`;
+  }
+
+  /**
+   * Creates a vehicle edge with route information oval in the middle.
+   */
+  private createVehicleEdge(edge: VehicleEdge, round: number): string[] {
+    const fromNodeId = `s_${edge.from}`;
+    const toNodeId = `s_${edge.to}`;
+    const roundColor = this.getRoundColor(round);
+    const routeOvalId = `e_${edge.from}_${edge.to}_${edge.routeId}_${round}`;
+
+    const route = this.result.timetable.getRoute(edge.routeId);
+    const serviceRouteInfo = route
+      ? this.result.timetable.getServiceRouteInfo(route)
+      : null;
+
+    const routeName = serviceRouteInfo?.name ?? `Route ${String(edge.routeId)}`;
+    const routeType = serviceRouteInfo?.type || 'UNKNOWN';
+
+    const departureTime = route
+      ? route.departureFrom(edge.from, edge.tripIndex).toString()
+      : 'N/A';
+    const arrivalTime = edge.arrival.toString();
+
+    const escapedRouteName = this.escapeDotString(routeName);
+    const escapedRouteType = this.escapeDotString(routeType);
+    const routeInfo = `${edge.routeId}:${edge.tripIndex}`;
+    const ovalLabel = `${escapedRouteType} ${escapedRouteName}\\n${routeInfo}\\n${departureTime} → ${arrivalTime}`;
+
+    return [
+      `  "${routeOvalId}" [label="${ovalLabel}" shape=oval style=filled fillcolor="white" color="${roundColor}"];`,
+      `  "${fromNodeId}" -> "${routeOvalId}" [color="${roundColor}"];`,
+      `  "${routeOvalId}" -> "${toNodeId}" [color="${roundColor}"];`,
     ];
-    earliestArrivalsPerRound.forEach((arrivalsInRound, round) => {
-      arrivalsInRound.forEach((tripLeg: TripLeg) => {
-        const { origin, leg } = tripLeg;
-        if (!leg) return; // Skip if leg is undefined
-        const fromStop = this.result['stopsIndex'].findStopById(leg.from.id);
-        const toStop = this.result['stopsIndex'].findStopById(leg.to.id);
-        const originStop = this.result['stopsIndex'].findStopById(origin);
-
-        if (fromStop && toStop && originStop) {
-          const fromName = fromStop.platform
-            ? `${fromStop.name} (Pl. ${fromStop.platform})`
-            : fromStop.name;
-          const toName = toStop.platform
-            ? `${toStop.name} (Pl. ${toStop.platform})`
-            : toStop.name;
-          const originName = originStop.platform
-            ? `${originStop.name} (Pl. ${originStop.platform})`
-            : originStop.name;
-          const isVehicle = 'route' in leg;
-          const routeLabelContent = isVehicle
-            ? `${leg.route.name}\n${leg.departureTime.toString()} - ${leg.arrivalTime.toString()}`
-            : leg.minTransferTime
-              ? leg.minTransferTime.toString()
-              : '';
-          const intermediateNode = `IntermediateNode${fromStop.id}_${toStop.id}`;
-          const lineColor = isVehicle ? '' : ', color="red", fontcolor="red"';
-          const labelColor = isVehicle ? '' : ' fontcolor="red"';
-
-          dotParts.push(
-            `  "${fromName} (Origin: ${originName}) [R${round}]\n(${fromStop.id})" -> "${intermediateNode}" [shape=point${lineColor}];`,
-          );
-          dotParts.push(
-            `  "${intermediateNode}" [label="${routeLabelContent}" shape=rect style=filled fillcolor=white${labelColor} border=0];`,
-          );
-          dotParts.push(
-            `  "${intermediateNode}" -> "${toName} (Origin: ${originName}) [R${round}]\n(${toStop.id})" [${lineColor.replace(', ', '')}];`,
-          );
+  }
+
+  /**
+   * Creates a transfer edge with transfer information oval in the middle.
+   */
+  private createTransferEdge(edge: TransferEdge, round: number): string[] {
+    const fromNodeId = `s_${edge.from}`;
+    const toNodeId = `s_${edge.to}`;
+    const roundColor = this.getRoundColor(round);
+    const transferOvalId = `e_${edge.from}_${edge.to}_${round}`;
+
+    const transferTime = edge.minTransferTime?.toString() || 'N/A';
+    const escapedTransferTime = this.escapeDotString(transferTime);
+    const ovalLabel = `Transfer\\n${escapedTransferTime}`;
+
+    return [
+      `  "${transferOvalId}" [label="${ovalLabel}" shape=oval style="dashed,filled" fillcolor="white" color="${roundColor}"];`,
+      `  "${fromNodeId}" -> "${transferOvalId}" [color="${roundColor}" style="dashed"];`,
+      `  "${transferOvalId}" -> "${toNodeId}" [color="${roundColor}" style="dashed"];`,
+    ];
+  }
+
+  /**
+   * Creates a continuation edge to visually link trip continuations.
+   */
+  private createContinuationEdge(
+    fromEdge: VehicleEdge,
+    toEdge: VehicleEdge,
+    round: number,
+  ): string[] {
+    const fromStationId = `s_${fromEdge.to}`;
+    const toStationId = `s_${toEdge.from}`;
+    const roundColor = this.getRoundColor(round);
+    const continuationOvalId = `continuation_${fromEdge.to}_${toEdge.from}_${round}`;
+
+    const fromRoute = this.result.timetable.getRoute(fromEdge.routeId);
+    const toRoute = this.result.timetable.getRoute(toEdge.routeId);
+
+    const fromServiceRouteInfo = fromRoute
+      ? this.result.timetable.getServiceRouteInfo(fromRoute)
+      : null;
+    const toServiceRouteInfo = toRoute
+      ? this.result.timetable.getServiceRouteInfo(toRoute)
+      : null;
+
+    const fromRouteName =
+      fromServiceRouteInfo?.name ?? `Route ${String(fromEdge.routeId)}`;
+    const toRouteName =
+      toServiceRouteInfo?.name ?? `Route ${String(toEdge.routeId)}`;
+
+    const fromRouteType = fromServiceRouteInfo?.type || 'UNKNOWN';
+    const toRouteType = toServiceRouteInfo?.type || 'UNKNOWN';
+
+    const fromArrivalTime = fromEdge.arrival.toString();
+    const toDepartureTime = toRoute
+      ? toRoute.departureFrom(toEdge.from, toEdge.tripIndex).toString()
+      : 'N/A';
+
+    const escapedFromRouteName = this.escapeDotString(fromRouteName);
+    const escapedToRouteName = this.escapeDotString(toRouteName);
+    const escapedFromRouteType = this.escapeDotString(fromRouteType);
+    const escapedToRouteType = this.escapeDotString(toRouteType);
+
+    const fromRouteInfo = `${fromEdge.routeId}:${fromEdge.tripIndex}`;
+    const toRouteInfo = `${toEdge.routeId}:${toEdge.tripIndex}`;
+
+    const ovalLabel = `${escapedFromRouteType} ${escapedFromRouteName} (${fromRouteInfo}) ${fromArrivalTime}\\n↓\\n${escapedToRouteType} ${escapedToRouteName} (${toRouteInfo}) ${toDepartureTime}`;
+
+    return [
+      `  "${continuationOvalId}" [label="${ovalLabel}" shape=oval style="filled,bold" fillcolor="#ffffcc" color="${roundColor}" penwidth="2"];`,
+      `  "${fromStationId}" -> "${continuationOvalId}" [color="${roundColor}" style="bold" penwidth="3"];`,
+      `  "${continuationOvalId}" -> "${toStationId}" [color="${roundColor}" style="bold" penwidth="3"];`,
+    ];
+  }
+
+  /**
+   * Collects all stations and edges for the graph.
+   */
+  private collectGraphData(): {
+    stations: Set<StopId>;
+    edges: string[];
+  } {
+    const stations = new Set<StopId>();
+    const edges: string[] = [];
+    const continuationEdges: string[] = [];
+    const graph: Map<StopId, RoutingEdge>[] = this.result.routingState.graph;
+
+    // Collect all stops that appear in the graph
+    graph.forEach((roundMap) => {
+      roundMap.forEach((edge, stopId) => {
+        stations.add(stopId);
+        if ('from' in edge && 'to' in edge) {
+          stations.add(edge.from);
+          stations.add(edge.to);
+        }
+      });
+    });
+
+    // Create edges for each round
+    graph.forEach((roundMap, round) => {
+      if (round === 0) {
+        // Skip round 0 as it contains only origin nodes
+        return;
+      }
+
+      roundMap.forEach((edge) => {
+        if ('from' in edge && 'to' in edge) {
+          if ('routeId' in edge) {
+            const vehicleEdgeParts = this.createVehicleEdge(edge, round);
+            edges.push(...vehicleEdgeParts);
+            if (edge.continuationOf) {
+              let currentEdge = edge;
+              let previousEdge: VehicleEdge | undefined = edge.continuationOf;
+
+              while (previousEdge) {
+                const continuationEdgeParts = this.createContinuationEdge(
+                  previousEdge,
+                  currentEdge,
+                  round,
+                );
+                continuationEdges.push(...continuationEdgeParts);
+
+                currentEdge = previousEdge;
+                previousEdge = previousEdge.continuationOf;
+              }
+            }
+          } else {
+            const transferEdgeParts = this.createTransferEdge(edge, round);
+            edges.push(...transferEdgeParts);
+          }
         }
       });
     });
+    edges.push(...continuationEdges);
+
+    return { stations, edges };
+  }
+
+  /**
+   * Plots the routing graph as a DOT graph for visualization.
+   */
+  plotDotGraph(): string {
+    const { stations, edges } = this.collectGraphData();
+
+    const dotParts = [
+      'digraph RoutingGraph {',
+      '  graph [overlap=false, splines=true, rankdir=TB, bgcolor=white, nodesep=0.8, ranksep=1.2, concentrate=true];',
+      '  node [fontname="Arial" margin=0.1];',
+      '  edge [fontname="Arial" fontsize=10];',
+      '',
+      '  // Stations',
+    ];
+
+    stations.forEach((stopId) => {
+      const stationNode = this.createStationNode(stopId);
+      if (stationNode) {
+        dotParts.push(stationNode);
+      }
+    });
+
+    dotParts.push('', '  // Edges');
+    dotParts.push(...edges);
 
     dotParts.push('}');
     return dotParts.join('\n');

package/src/routing/result.ts

@@ -1,25 +1,26 @@
+import { Timetable } from '../router.js';
 import { SourceStopId, StopId } from '../stops/stops.js';
 import { StopsIndex } from '../stops/stopsIndex.js';
 import { Query } from './query.js';
-import { Leg, Route } from './route.js';
-import { ReachingTime, TripLeg } from './router.js';
+import { Leg, Route, Transfer, VehicleLeg } from './route.js';
+import { Arrival, RoutingState, TransferEdge, VehicleEdge } from './router.js';
 
 export class Result {
   private readonly query: Query;
-  public readonly earliestArrivals: Map<StopId, ReachingTime>;
-  public readonly earliestArrivalsPerRound: Map<StopId, TripLeg>[];
-  private readonly stopsIndex: StopsIndex;
+  public readonly routingState: RoutingState;
+  public readonly stopsIndex: StopsIndex;
+  public readonly timetable: Timetable;
 
   constructor(
     query: Query,
-    earliestArrivals: Map<StopId, ReachingTime>,
-    earliestArrivalsPerRound: Map<StopId, TripLeg>[],
+    routingState: RoutingState,
     stopsIndex: StopsIndex,
+    timetable: Timetable,
   ) {
     this.query = query;
-    this.earliestArrivals = earliestArrivals;
-    this.earliestArrivalsPerRound = earliestArrivalsPerRound;
+    this.routingState = routingState;
     this.stopsIndex = stopsIndex;
+    this.timetable = timetable;
   }
 
   /**
@@ -39,11 +40,13 @@ export class Result {
     const destinations = destinationList.flatMap((destination) =>
       this.stopsIndex.equivalentStops(destination),
     );
-
+    // find the first reached destination
     let fastestDestination: StopId | undefined = undefined;
-    let fastestTime: ReachingTime | undefined = undefined;
+    let fastestTime: Arrival | undefined = undefined;
     for (const destination of destinations) {
-      const arrivalTime = this.earliestArrivals.get(destination.id);
+      const arrivalTime = this.routingState.earliestArrivals.get(
+        destination.id,
+      );
       if (arrivalTime !== undefined) {
         if (
           fastestTime === undefined ||
@@ -57,28 +60,96 @@ export class Result {
     if (!fastestDestination || !fastestTime) {
       return undefined;
     }
-
     const route: Leg[] = [];
     let currentStop = fastestDestination;
     let round = fastestTime.legNumber;
-    while (fastestTime.origin !== currentStop) {
-      const tripLeg = this.earliestArrivalsPerRound[round]?.get(currentStop);
-      if (!tripLeg?.leg) {
+    while (round > 0) {
+      const edge = this.routingState.graph[round]?.get(currentStop);
+      if (!edge) {
         throw new Error(
-          `No leg found for a trip leg: start stop=${
-            tripLeg?.leg?.from.id ?? 'unknown'
-          }, end stop=${currentStop}, round=${round}, origin=${fastestTime.origin}`,
+          `No edge arriving at stop ${currentStop} at round ${round}`,
         );
       }
-      route.unshift(tripLeg.leg);
-      currentStop = tripLeg.leg.from.id;
-      if ('route' in tripLeg.leg) {
+      let leg: Leg;
+      if ('routeId' in edge) {
+        let vehicleEdge = edge;
+        // Handle leg reconstruction for in-seat trip continuations
+        const chainedEdges = [vehicleEdge];
+        while ('routeId' in vehicleEdge && vehicleEdge.continuationOf) {
+          chainedEdges.push(vehicleEdge.continuationOf);
+          vehicleEdge = vehicleEdge.continuationOf;
+        }
+        leg = this.buildVehicleLeg(chainedEdges);
+      } else if ('type' in edge) {
+        leg = this.buildTransferLeg(edge);
+      } else {
+        break;
+      }
+      route.unshift(leg);
+      currentStop = leg.from.id;
+      if ('routeId' in edge) {
         round -= 1;
       }
     }
     return new Route(route);
   }
 
+  /**
+   * Builds a vehicle leg from a chain of vehicle edges.
+   *
+   * @param edges Array of vehicle edges representing continuous trips on transit vehicles
+   * @returns A vehicle leg with departure/arrival information and route details
+   * @throws Error if the edges array is empty
+   */
+  private buildVehicleLeg(edges: VehicleEdge[]): VehicleLeg {
+    if (edges.length === 0) {
+      throw new Error('Cannot build vehicle leg from empty edges');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const firstEdge = edges[edges.length - 1]!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const lastEdge = edges[0]!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const firstRoute = this.timetable.getRoute(firstEdge.routeId)!;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const lastRoute = this.timetable.getRoute(lastEdge.routeId)!;
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      from: this.stopsIndex.findStopById(firstRoute.stopId(firstEdge.from))!,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      to: this.stopsIndex.findStopById(lastRoute.stopId(lastEdge.to))!,
+      // The route info comes from the first boarded route in case on continuous trips
+      route: this.timetable.getServiceRouteInfo(firstRoute),
+      departureTime: firstRoute.departureFrom(
+        firstEdge.from,
+        firstEdge.tripIndex,
+      ),
+      arrivalTime: lastEdge.arrival,
+      pickUpType: firstRoute.pickUpTypeFrom(
+        firstEdge.from,
+        firstEdge.tripIndex,
+      ),
+      dropOffType: lastRoute.dropOffTypeAt(lastEdge.to, lastEdge.tripIndex),
+    };
+  }
+
+  /**
+   * Builds a transfer leg from a transfer edge.
+   *
+   * @param edge Transfer edge representing a walking connection between stops
+   * @returns A transfer leg with from/to stops and transfer details
+   */
+  private buildTransferLeg(edge: TransferEdge): Transfer {
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      from: this.stopsIndex.findStopById(edge.from)!,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      to: this.stopsIndex.findStopById(edge.to)!,
+      minTransferTime: edge.minTransferTime,
+      type: edge.type,
+    };
+  }
+
   /**
    * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
    *
@@ -86,21 +157,30 @@ export class Result {
    * @param maxTransfers The optional maximum number of transfers allowed.
    * @returns The arrival time if the target stop is reachable, otherwise undefined.
    */
-  arrivalAt(
-    stop: SourceStopId,
-    maxTransfers?: number,
-  ): ReachingTime | undefined {
+  arrivalAt(stop: SourceStopId, maxTransfers?: number): Arrival | undefined {
     const equivalentStops = this.stopsIndex.equivalentStops(stop);
-    let earliestArrival: ReachingTime | undefined = undefined;
-
-    const relevantArrivals =
-      maxTransfers !== undefined
-        ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          this.earliestArrivalsPerRound[maxTransfers + 1]!
-        : this.earliestArrivals;
+    let earliestArrival: Arrival | undefined = undefined;
 
     for (const equivalentStop of equivalentStops) {
-      const arrivalTime = relevantArrivals.get(equivalentStop.id);
+      let arrivalTime;
+      if (maxTransfers === undefined) {
+        arrivalTime = this.routingState.earliestArrivals.get(equivalentStop.id);
+      } else {
+        // We have no guarantee that the stop was visited in the last round,
+        // so we need to check all rounds if it's not found in the last one.
+        for (let i = maxTransfers + 1; i >= 0; i--) {
+          const arrivalEdge = this.routingState.graph[i]?.get(
+            equivalentStop.id,
+          );
+          if (arrivalEdge !== undefined) {
+            arrivalTime = {
+              arrival: arrivalEdge.arrival,
+              legNumber: i,
+            };
+            break;
+          }
+        }
+      }
       if (arrivalTime !== undefined) {
         if (
           earliestArrival === undefined ||

package/src/routing/route.ts

@@ -38,11 +38,8 @@ export type VehicleLeg = BaseLeg & {
   route: ServiceRouteInfo;
   departureTime: Time;
   arrivalTime: Time;
-  // TODO support pick up and drop off types
-  /*
   pickUpType: PickUpDropOffType;
   dropOffType: PickUpDropOffType;
-  */
 };
 
 export type Leg = Transfer | VehicleLeg;