minotor 11.2.2 → 11.3.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +3 -3
- package/README.md +28 -0
- package/dist/cli.mjs +378 -127
- package/dist/cli.mjs.map +1 -1
- package/dist/gtfs/parser.d.ts +3 -1
- package/dist/gtfs/routes.d.ts +1 -2
- package/dist/gtfs/trips.d.ts +2 -1
- package/dist/parser.cjs.js +225 -81
- package/dist/parser.cjs.js.map +1 -1
- package/dist/parser.d.ts +6 -2
- package/dist/parser.esm.js +224 -82
- package/dist/parser.esm.js.map +1 -1
- package/dist/router.cjs.js +1 -1
- package/dist/router.cjs.js.map +1 -1
- package/dist/router.d.ts +5 -3
- package/dist/router.esm.js +1 -1
- package/dist/router.esm.js.map +1 -1
- package/dist/router.umd.js +1 -1
- package/dist/router.umd.js.map +1 -1
- package/dist/routing/query.d.ts +20 -0
- package/dist/routing/rangeState.d.ts +1 -0
- package/dist/routing/raptor.d.ts +2 -0
- package/dist/routing/result.d.ts +1 -4
- package/dist/routing/route.d.ts +9 -5
- package/dist/routing/state.d.ts +11 -1
- package/dist/timetable/route.d.ts +9 -5
- package/dist/timetable/timetable.d.ts +24 -2
- package/dist/transfers/__tests__/straightLineTransferGenerator.test.d.ts +1 -0
- package/dist/transfers/generator.d.ts +40 -0
- package/dist/transfers/straightLineTransferGenerator.d.ts +58 -0
- package/dist/utils/map.d.ts +10 -0
- package/package.json +1 -1
- package/src/__e2e__/router.test.ts +6 -2
- package/src/cli/minotor.ts +21 -1
- package/src/cli/perf.ts +4 -2
- package/src/cli/repl.ts +55 -35
- package/src/gtfs/__tests__/parser.test.ts +29 -1
- package/src/gtfs/__tests__/routes.test.ts +4 -3
- package/src/gtfs/__tests__/transfers.test.ts +8 -8
- package/src/gtfs/__tests__/trips.test.ts +60 -24
- package/src/gtfs/parser.ts +50 -1
- package/src/gtfs/profiles/__tests__/extended.test.ts +2 -1
- package/src/gtfs/profiles/extended.ts +14 -14
- package/src/gtfs/profiles/standard.ts +11 -10
- package/src/gtfs/routes.ts +5 -2
- package/src/gtfs/transfers.ts +6 -5
- package/src/gtfs/trips.ts +7 -14
- package/src/parser.ts +20 -2
- package/src/router.ts +15 -6
- package/src/routing/__tests__/access.test.ts +14 -6
- package/src/routing/__tests__/plainRouter.test.ts +47 -23
- package/src/routing/__tests__/plotter.test.ts +8 -3
- package/src/routing/__tests__/rangeResult.test.ts +6 -2
- package/src/routing/__tests__/rangeRouter.test.ts +32 -6
- package/src/routing/__tests__/raptor.test.ts +157 -9
- package/src/routing/__tests__/result.test.ts +9 -4
- package/src/routing/__tests__/route.test.ts +3 -4
- package/src/routing/__tests__/router.test.ts +2 -1
- package/src/routing/access.ts +7 -4
- package/src/routing/plainRouter.ts +1 -0
- package/src/routing/plotter.ts +8 -3
- package/src/routing/query.ts +18 -0
- package/src/routing/rangeRouter.ts +2 -0
- package/src/routing/rangeState.ts +4 -0
- package/src/routing/raptor.ts +19 -9
- package/src/routing/result.ts +32 -14
- package/src/routing/route.ts +13 -10
- package/src/routing/state.ts +30 -0
- package/src/timetable/__tests__/io.test.ts +22 -10
- package/src/timetable/__tests__/route.test.ts +18 -24
- package/src/timetable/__tests__/timetable.test.ts +17 -11
- package/src/timetable/io.ts +30 -28
- package/src/timetable/route.ts +14 -7
- package/src/timetable/timetable.ts +77 -31
- package/src/transfers/README.md +97 -0
- package/src/transfers/__tests__/straightLineTransferGenerator.test.ts +204 -0
- package/src/transfers/generator.ts +45 -0
- package/src/transfers/straightLineTransferGenerator.ts +143 -0
- package/src/utils/map.ts +22 -0
|
@@ -1,13 +1,15 @@
|
|
|
1
1
|
import assert from 'node:assert';
|
|
2
2
|
import { describe, it } from 'node:test';
|
|
3
3
|
|
|
4
|
-
import {
|
|
4
|
+
import { PickUpDropOffTypes, Route } from '../route.js';
|
|
5
5
|
import { timeFromHMS } from '../time.js';
|
|
6
6
|
import {
|
|
7
7
|
RouteType,
|
|
8
|
+
RouteTypes,
|
|
8
9
|
ServiceRoute,
|
|
9
10
|
StopAdjacency,
|
|
10
11
|
Timetable,
|
|
12
|
+
TransferTypes,
|
|
11
13
|
TripStop,
|
|
12
14
|
TripTransfers,
|
|
13
15
|
} from '../timetable.js';
|
|
@@ -17,14 +19,14 @@ describe('Timetable', () => {
|
|
|
17
19
|
const stopsAdjacency: StopAdjacency[] = [
|
|
18
20
|
{ routes: [] },
|
|
19
21
|
{
|
|
20
|
-
transfers: [{ destination: 2, type:
|
|
22
|
+
transfers: [{ destination: 2, type: TransferTypes.RECOMMENDED }],
|
|
21
23
|
routes: [0, 1],
|
|
22
24
|
},
|
|
23
25
|
{
|
|
24
26
|
transfers: [
|
|
25
27
|
{
|
|
26
28
|
destination: 1,
|
|
27
|
-
type:
|
|
29
|
+
type: TransferTypes.GUARANTEED,
|
|
28
30
|
minTransferTime: 3,
|
|
29
31
|
},
|
|
30
32
|
],
|
|
@@ -50,7 +52,7 @@ describe('Timetable', () => {
|
|
|
50
52
|
id: 2,
|
|
51
53
|
arrivalTime: timeFromHMS(17, 20, 0),
|
|
52
54
|
departureTime: timeFromHMS(17, 30, 0),
|
|
53
|
-
pickUpType: NOT_AVAILABLE,
|
|
55
|
+
pickUpType: PickUpDropOffTypes.NOT_AVAILABLE,
|
|
54
56
|
},
|
|
55
57
|
],
|
|
56
58
|
},
|
|
@@ -92,8 +94,8 @@ describe('Timetable', () => {
|
|
|
92
94
|
});
|
|
93
95
|
const routesAdjacency = [route1, route2];
|
|
94
96
|
const routes: ServiceRoute[] = [
|
|
95
|
-
{ type:
|
|
96
|
-
{ type:
|
|
97
|
+
{ type: RouteTypes.RAIL, name: 'Route 1', routes: [0] },
|
|
98
|
+
{ type: RouteTypes.RAIL, name: 'Route 2', routes: [1] },
|
|
97
99
|
];
|
|
98
100
|
|
|
99
101
|
const sampleTimetable: Timetable = new Timetable(
|
|
@@ -191,7 +193,7 @@ describe('Timetable', () => {
|
|
|
191
193
|
|
|
192
194
|
const railRoutes = sampleTimetable.findReachableRoutes(
|
|
193
195
|
fromStops,
|
|
194
|
-
new Set<RouteType>([
|
|
196
|
+
new Set<RouteType>([RouteTypes.RAIL]),
|
|
195
197
|
);
|
|
196
198
|
assert.strictEqual(railRoutes.size, 2);
|
|
197
199
|
assert.deepStrictEqual(
|
|
@@ -204,14 +206,18 @@ describe('Timetable', () => {
|
|
|
204
206
|
|
|
205
207
|
const busRoutes = sampleTimetable.findReachableRoutes(
|
|
206
208
|
fromStops,
|
|
207
|
-
new Set<RouteType>([
|
|
209
|
+
new Set<RouteType>([RouteTypes.BUS]),
|
|
208
210
|
);
|
|
209
211
|
assert.strictEqual(busRoutes.size, 0);
|
|
210
212
|
assert.deepStrictEqual(busRoutes, new Map());
|
|
211
213
|
|
|
212
214
|
const multiModeRoutes = sampleTimetable.findReachableRoutes(
|
|
213
215
|
fromStops,
|
|
214
|
-
new Set<RouteType>([
|
|
216
|
+
new Set<RouteType>([
|
|
217
|
+
RouteTypes.RAIL,
|
|
218
|
+
RouteTypes.BUS,
|
|
219
|
+
RouteTypes.SUBWAY,
|
|
220
|
+
]),
|
|
215
221
|
);
|
|
216
222
|
assert.strictEqual(multiModeRoutes.size, 2);
|
|
217
223
|
});
|
|
@@ -685,7 +691,7 @@ describe('Timetable', () => {
|
|
|
685
691
|
id: 0,
|
|
686
692
|
arrivalTime: timeFromHMS(9, 0, 0),
|
|
687
693
|
departureTime: timeFromHMS(9, 0, 0),
|
|
688
|
-
pickUpType: NOT_AVAILABLE,
|
|
694
|
+
pickUpType: PickUpDropOffTypes.NOT_AVAILABLE,
|
|
689
695
|
},
|
|
690
696
|
{
|
|
691
697
|
id: 1,
|
|
@@ -731,7 +737,7 @@ describe('Timetable', () => {
|
|
|
731
737
|
];
|
|
732
738
|
|
|
733
739
|
const ffbtServiceRoutes = [
|
|
734
|
-
{ type:
|
|
740
|
+
{ type: RouteTypes.BUS, name: 'Route 2', routes: [FFBT_ROUTE_ID] },
|
|
735
741
|
];
|
|
736
742
|
|
|
737
743
|
const ffbtTimetable = new Timetable(
|
package/src/timetable/io.ts
CHANGED
|
@@ -9,11 +9,13 @@ import {
|
|
|
9
9
|
import { Route } from './route.js';
|
|
10
10
|
import {
|
|
11
11
|
RouteType,
|
|
12
|
+
RouteTypes,
|
|
12
13
|
ServiceRoute,
|
|
13
14
|
ServiceRouteId,
|
|
14
15
|
StopAdjacency,
|
|
15
16
|
Transfer,
|
|
16
17
|
TransferType,
|
|
18
|
+
TransferTypes,
|
|
17
19
|
TripStop,
|
|
18
20
|
TripTransfers,
|
|
19
21
|
} from './timetable.js';
|
|
@@ -255,13 +257,13 @@ const parseTransferType = (type: ProtoTransferType): TransferType => {
|
|
|
255
257
|
case ProtoTransferType.TRANSFER_TYPE_UNSPECIFIED:
|
|
256
258
|
throw new Error('Unspecified protobuf transfer type.');
|
|
257
259
|
case ProtoTransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT:
|
|
258
|
-
return
|
|
260
|
+
return TransferTypes.RECOMMENDED;
|
|
259
261
|
case ProtoTransferType.TRANSFER_TYPE_TIMED_TRANSFER:
|
|
260
|
-
return
|
|
262
|
+
return TransferTypes.GUARANTEED;
|
|
261
263
|
case ProtoTransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME:
|
|
262
|
-
return
|
|
264
|
+
return TransferTypes.REQUIRES_MINIMAL_TIME;
|
|
263
265
|
case ProtoTransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER:
|
|
264
|
-
return
|
|
266
|
+
return TransferTypes.IN_SEAT;
|
|
265
267
|
case ProtoTransferType.UNRECOGNIZED:
|
|
266
268
|
throw new Error('Unrecognized protobuf transfer type.');
|
|
267
269
|
}
|
|
@@ -269,13 +271,13 @@ const parseTransferType = (type: ProtoTransferType): TransferType => {
|
|
|
269
271
|
|
|
270
272
|
const serializeTransferType = (type: TransferType): ProtoTransferType => {
|
|
271
273
|
switch (type) {
|
|
272
|
-
case
|
|
274
|
+
case TransferTypes.RECOMMENDED:
|
|
273
275
|
return ProtoTransferType.TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT;
|
|
274
|
-
case
|
|
276
|
+
case TransferTypes.GUARANTEED:
|
|
275
277
|
return ProtoTransferType.TRANSFER_TYPE_TIMED_TRANSFER;
|
|
276
|
-
case
|
|
278
|
+
case TransferTypes.REQUIRES_MINIMAL_TIME:
|
|
277
279
|
return ProtoTransferType.TRANSFER_TYPE_REQUIRES_MINIMAL_TIME;
|
|
278
|
-
case
|
|
280
|
+
case TransferTypes.IN_SEAT:
|
|
279
281
|
return ProtoTransferType.TRANSFER_TYPE_IN_SEAT_TRANSFER;
|
|
280
282
|
}
|
|
281
283
|
};
|
|
@@ -285,25 +287,25 @@ const parseRouteType = (type: ProtoRouteType): RouteType => {
|
|
|
285
287
|
case ProtoRouteType.ROUTE_TYPE_UNSPECIFIED:
|
|
286
288
|
throw new Error('Unspecified protobuf route type.');
|
|
287
289
|
case ProtoRouteType.ROUTE_TYPE_TRAM:
|
|
288
|
-
return
|
|
290
|
+
return RouteTypes.TRAM;
|
|
289
291
|
case ProtoRouteType.ROUTE_TYPE_SUBWAY:
|
|
290
|
-
return
|
|
292
|
+
return RouteTypes.SUBWAY;
|
|
291
293
|
case ProtoRouteType.ROUTE_TYPE_RAIL:
|
|
292
|
-
return
|
|
294
|
+
return RouteTypes.RAIL;
|
|
293
295
|
case ProtoRouteType.ROUTE_TYPE_BUS:
|
|
294
|
-
return
|
|
296
|
+
return RouteTypes.BUS;
|
|
295
297
|
case ProtoRouteType.ROUTE_TYPE_FERRY:
|
|
296
|
-
return
|
|
298
|
+
return RouteTypes.FERRY;
|
|
297
299
|
case ProtoRouteType.ROUTE_TYPE_CABLE_TRAM:
|
|
298
|
-
return
|
|
300
|
+
return RouteTypes.CABLE_TRAM;
|
|
299
301
|
case ProtoRouteType.ROUTE_TYPE_AERIAL_LIFT:
|
|
300
|
-
return
|
|
302
|
+
return RouteTypes.AERIAL_LIFT;
|
|
301
303
|
case ProtoRouteType.ROUTE_TYPE_FUNICULAR:
|
|
302
|
-
return
|
|
304
|
+
return RouteTypes.FUNICULAR;
|
|
303
305
|
case ProtoRouteType.ROUTE_TYPE_TROLLEYBUS:
|
|
304
|
-
return
|
|
306
|
+
return RouteTypes.TROLLEYBUS;
|
|
305
307
|
case ProtoRouteType.ROUTE_TYPE_MONORAIL:
|
|
306
|
-
return
|
|
308
|
+
return RouteTypes.MONORAIL;
|
|
307
309
|
case ProtoRouteType.UNRECOGNIZED:
|
|
308
310
|
default:
|
|
309
311
|
throw new Error('Unrecognized protobuf route type.');
|
|
@@ -312,25 +314,25 @@ const parseRouteType = (type: ProtoRouteType): RouteType => {
|
|
|
312
314
|
|
|
313
315
|
const serializeRouteType = (type: RouteType): ProtoRouteType => {
|
|
314
316
|
switch (type) {
|
|
315
|
-
case
|
|
317
|
+
case RouteTypes.TRAM:
|
|
316
318
|
return ProtoRouteType.ROUTE_TYPE_TRAM;
|
|
317
|
-
case
|
|
319
|
+
case RouteTypes.SUBWAY:
|
|
318
320
|
return ProtoRouteType.ROUTE_TYPE_SUBWAY;
|
|
319
|
-
case
|
|
321
|
+
case RouteTypes.RAIL:
|
|
320
322
|
return ProtoRouteType.ROUTE_TYPE_RAIL;
|
|
321
|
-
case
|
|
323
|
+
case RouteTypes.BUS:
|
|
322
324
|
return ProtoRouteType.ROUTE_TYPE_BUS;
|
|
323
|
-
case
|
|
325
|
+
case RouteTypes.FERRY:
|
|
324
326
|
return ProtoRouteType.ROUTE_TYPE_FERRY;
|
|
325
|
-
case
|
|
327
|
+
case RouteTypes.CABLE_TRAM:
|
|
326
328
|
return ProtoRouteType.ROUTE_TYPE_CABLE_TRAM;
|
|
327
|
-
case
|
|
329
|
+
case RouteTypes.AERIAL_LIFT:
|
|
328
330
|
return ProtoRouteType.ROUTE_TYPE_AERIAL_LIFT;
|
|
329
|
-
case
|
|
331
|
+
case RouteTypes.FUNICULAR:
|
|
330
332
|
return ProtoRouteType.ROUTE_TYPE_FUNICULAR;
|
|
331
|
-
case
|
|
333
|
+
case RouteTypes.TROLLEYBUS:
|
|
332
334
|
return ProtoRouteType.ROUTE_TYPE_TROLLEYBUS;
|
|
333
|
-
case
|
|
335
|
+
case RouteTypes.MONORAIL:
|
|
334
336
|
return ProtoRouteType.ROUTE_TYPE_MONORAIL;
|
|
335
337
|
}
|
|
336
338
|
};
|
package/src/timetable/route.ts
CHANGED
|
@@ -11,12 +11,19 @@ import { ServiceRouteId } from './timetable.js';
|
|
|
11
11
|
*/
|
|
12
12
|
export type RouteId = number;
|
|
13
13
|
|
|
14
|
-
export
|
|
14
|
+
export const PickUpDropOffTypes = {
|
|
15
|
+
REGULAR: 0,
|
|
16
|
+
NOT_AVAILABLE: 1,
|
|
17
|
+
MUST_PHONE_AGENCY: 2,
|
|
18
|
+
MUST_COORDINATE_WITH_DRIVER: 3,
|
|
19
|
+
} as const;
|
|
15
20
|
|
|
16
|
-
export
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
export
|
|
21
|
+
export type PickUpDropOffType =
|
|
22
|
+
(typeof PickUpDropOffTypes)[keyof typeof PickUpDropOffTypes];
|
|
23
|
+
|
|
24
|
+
export type PickUpDropOffTypeString = keyof typeof PickUpDropOffTypes;
|
|
25
|
+
|
|
26
|
+
export type RawPickUpDropOffType = PickUpDropOffType;
|
|
20
27
|
|
|
21
28
|
/*
|
|
22
29
|
* A trip route index corresponds to the index of a given trip in a route.
|
|
@@ -182,8 +189,8 @@ export class Route {
|
|
|
182
189
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
183
190
|
const stop = trip.stops[stopIndex]!;
|
|
184
191
|
const globalIndex = tripIndex * numStops + stopIndex;
|
|
185
|
-
const pickUp = stop.pickUpType ?? REGULAR;
|
|
186
|
-
const dropOff = stop.dropOffType ?? REGULAR;
|
|
192
|
+
const pickUp = stop.pickUpType ?? PickUpDropOffTypes.REGULAR;
|
|
193
|
+
const dropOff = stop.dropOffType ?? PickUpDropOffTypes.REGULAR;
|
|
187
194
|
const byteIndex = Math.floor(globalIndex / 2);
|
|
188
195
|
const isSecondPair = globalIndex % 2 === 1;
|
|
189
196
|
|
|
@@ -13,16 +13,26 @@ import {
|
|
|
13
13
|
serializeTripTransfers,
|
|
14
14
|
} from './io.js';
|
|
15
15
|
import { Timetable as ProtoTimetable } from './proto/v1/timetable.js';
|
|
16
|
-
import {
|
|
17
|
-
|
|
16
|
+
import {
|
|
17
|
+
PickUpDropOffTypes,
|
|
18
|
+
Route,
|
|
19
|
+
RouteId,
|
|
20
|
+
StopRouteIndex,
|
|
21
|
+
TripRouteIndex,
|
|
22
|
+
} from './route.js';
|
|
18
23
|
import { Duration, DURATION_ZERO, Time, TIME_ORIGIN } from './time.js';
|
|
19
24
|
import { encode, TripStopId } from './tripStopId.js';
|
|
20
25
|
|
|
21
|
-
export
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
+
export const TransferTypes = {
|
|
27
|
+
RECOMMENDED: 1,
|
|
28
|
+
GUARANTEED: 2,
|
|
29
|
+
REQUIRES_MINIMAL_TIME: 3,
|
|
30
|
+
IN_SEAT: 4,
|
|
31
|
+
} as const;
|
|
32
|
+
|
|
33
|
+
export type TransferType = (typeof TransferTypes)[keyof typeof TransferTypes];
|
|
34
|
+
|
|
35
|
+
export type TransferTypeString = keyof typeof TransferTypes;
|
|
26
36
|
|
|
27
37
|
export type Transfer = {
|
|
28
38
|
destination: StopId;
|
|
@@ -45,17 +55,22 @@ export type TripTransfers = Map<TripStopId, TripStop[]>;
|
|
|
45
55
|
|
|
46
56
|
export type ServiceRouteId = number;
|
|
47
57
|
|
|
48
|
-
export
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
58
|
+
export const RouteTypes = {
|
|
59
|
+
TRAM: 1,
|
|
60
|
+
SUBWAY: 2,
|
|
61
|
+
RAIL: 3,
|
|
62
|
+
BUS: 4,
|
|
63
|
+
FERRY: 5,
|
|
64
|
+
CABLE_TRAM: 6,
|
|
65
|
+
AERIAL_LIFT: 7,
|
|
66
|
+
FUNICULAR: 8,
|
|
67
|
+
TROLLEYBUS: 9,
|
|
68
|
+
MONORAIL: 10,
|
|
69
|
+
} as const;
|
|
70
|
+
|
|
71
|
+
export type RouteType = (typeof RouteTypes)[keyof typeof RouteTypes];
|
|
72
|
+
|
|
73
|
+
export type RouteTypeString = keyof typeof RouteTypes;
|
|
59
74
|
|
|
60
75
|
// A service refers to a collection of trips that are displayed to riders as a single service.
|
|
61
76
|
// As opposed to a route which consists of the subset of trips from a service which shares the same list of stops.
|
|
@@ -67,18 +82,9 @@ export type ServiceRoute = {
|
|
|
67
82
|
};
|
|
68
83
|
export type ServiceRouteInfo = Omit<ServiceRoute, 'routes'>;
|
|
69
84
|
|
|
70
|
-
export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set(
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
'RAIL',
|
|
74
|
-
'BUS',
|
|
75
|
-
'FERRY',
|
|
76
|
-
'CABLE_TRAM',
|
|
77
|
-
'AERIAL_LIFT',
|
|
78
|
-
'FUNICULAR',
|
|
79
|
-
'TROLLEYBUS',
|
|
80
|
-
'MONORAIL',
|
|
81
|
-
]);
|
|
85
|
+
export const ALL_TRANSPORT_MODES: Set<RouteType> = new Set(
|
|
86
|
+
Object.values(RouteTypes),
|
|
87
|
+
);
|
|
82
88
|
|
|
83
89
|
const EMPTY_TRIP_BOARDINGS: TripStop[] = [];
|
|
84
90
|
|
|
@@ -370,7 +376,7 @@ export class Timetable {
|
|
|
370
376
|
|
|
371
377
|
for (let t = earliestTrip; t < (beforeTrip ?? nbTrips); t++) {
|
|
372
378
|
const pickup = route.pickUpTypeFrom(stopIndex, t);
|
|
373
|
-
if (pickup === NOT_AVAILABLE) {
|
|
379
|
+
if (pickup === PickUpDropOffTypes.NOT_AVAILABLE) {
|
|
374
380
|
continue;
|
|
375
381
|
}
|
|
376
382
|
if (fromTripStop === undefined) {
|
|
@@ -416,3 +422,43 @@ export class Timetable {
|
|
|
416
422
|
return guaranteedTripTransfers;
|
|
417
423
|
}
|
|
418
424
|
}
|
|
425
|
+
|
|
426
|
+
export const routeTypeToString = (type: RouteType): RouteTypeString => {
|
|
427
|
+
switch (type) {
|
|
428
|
+
case RouteTypes.TRAM:
|
|
429
|
+
return 'TRAM';
|
|
430
|
+
case RouteTypes.SUBWAY:
|
|
431
|
+
return 'SUBWAY';
|
|
432
|
+
case RouteTypes.RAIL:
|
|
433
|
+
return 'RAIL';
|
|
434
|
+
case RouteTypes.BUS:
|
|
435
|
+
return 'BUS';
|
|
436
|
+
case RouteTypes.FERRY:
|
|
437
|
+
return 'FERRY';
|
|
438
|
+
case RouteTypes.CABLE_TRAM:
|
|
439
|
+
return 'CABLE_TRAM';
|
|
440
|
+
case RouteTypes.AERIAL_LIFT:
|
|
441
|
+
return 'AERIAL_LIFT';
|
|
442
|
+
case RouteTypes.FUNICULAR:
|
|
443
|
+
return 'FUNICULAR';
|
|
444
|
+
case RouteTypes.TROLLEYBUS:
|
|
445
|
+
return 'TROLLEYBUS';
|
|
446
|
+
case RouteTypes.MONORAIL:
|
|
447
|
+
return 'MONORAIL';
|
|
448
|
+
}
|
|
449
|
+
};
|
|
450
|
+
|
|
451
|
+
export const transferTypeToString = (
|
|
452
|
+
type: TransferType,
|
|
453
|
+
): TransferTypeString => {
|
|
454
|
+
switch (type) {
|
|
455
|
+
case TransferTypes.RECOMMENDED:
|
|
456
|
+
return 'RECOMMENDED';
|
|
457
|
+
case TransferTypes.GUARANTEED:
|
|
458
|
+
return 'GUARANTEED';
|
|
459
|
+
case TransferTypes.REQUIRES_MINIMAL_TIME:
|
|
460
|
+
return 'REQUIRES_MINIMAL_TIME';
|
|
461
|
+
case TransferTypes.IN_SEAT:
|
|
462
|
+
return 'IN_SEAT';
|
|
463
|
+
}
|
|
464
|
+
};
|
|
@@ -0,0 +1,97 @@
|
|
|
1
|
+
# Virtual transfers
|
|
2
|
+
|
|
3
|
+
Many GTFS feeds only partially populate `transfers.txt`, so nearby stops that belong to different stations (e.g. a subway platform and an adjacent tram or bus terminal) end up with no walking connection and cannot be used as an interchange. A `TransferGenerator` can be passed to the parser to synthesize the missing walking transfers as a pre-processing step, before the timetable is serialized.
|
|
4
|
+
|
|
5
|
+
## Built-in implementation
|
|
6
|
+
|
|
7
|
+
`StraightLineTransferGenerator` connects nearby stops that aren't already linked in the feed — for every stop it adds walking transfers to the other stops within a radius, estimating the walking time from the straight-line distance:
|
|
8
|
+
|
|
9
|
+
```ts
|
|
10
|
+
import {
|
|
11
|
+
GtfsParser,
|
|
12
|
+
StraightLineTransferGenerator,
|
|
13
|
+
extendedGtfsProfile,
|
|
14
|
+
} from 'minotor/parser';
|
|
15
|
+
|
|
16
|
+
const parser = new GtfsParser(
|
|
17
|
+
'gtfs-feed.zip',
|
|
18
|
+
extendedGtfsProfile,
|
|
19
|
+
new StraightLineTransferGenerator({ maxDistanceMeters: 500 }),
|
|
20
|
+
);
|
|
21
|
+
|
|
22
|
+
const timetable = await parser.parseTimetable(new Date());
|
|
23
|
+
```
|
|
24
|
+
|
|
25
|
+
On top of the walking time, some adjustments make the estimate more realistic:
|
|
26
|
+
|
|
27
|
+
- a **detour factor** as no path in the real world is a straight line
|
|
28
|
+
- a flat **change penalty** added to every transfer, for the general overhead of changing
|
|
29
|
+
|
|
30
|
+
The change penalty is symmetric, so the two directions of a transfer share the same minimum time. Existing transfers from the feed are always preserved:
|
|
31
|
+
|
|
32
|
+
| Option | Default | Description |
|
|
33
|
+
| ---------------------- | ------- | ----------------------------------------------------------------------- |
|
|
34
|
+
| `maxDistanceMeters` | `500` | Radius within which two stops are connected |
|
|
35
|
+
| `walkingSpeedKmh` | `4` | Assumed walking speed |
|
|
36
|
+
| `detourFactor` | `1.3` | Multiplier from straight-line to real walking distance (`1` to disable) |
|
|
37
|
+
| `changePenaltyMinutes` | `3` | Flat penalty added to every generated transfer (`0` to disable) |
|
|
38
|
+
|
|
39
|
+
## Custom implementation
|
|
40
|
+
|
|
41
|
+
The straight-line estimate is relatively basic but works without external dependencies. For realistic walking times, you can implement the `TransferGenerator` interface yourself by e.g. delegating to an external pedestrian routing engine.
|
|
42
|
+
|
|
43
|
+
The parser passes the candidate origin stops (route-served stops with coordinates) and deduplicates the result against the transfers already in the feed, keeping only links between stops a route actually calls at — so you can emit a transfer for every nearby pair without tracking what already exists. Return the directed transfers to add, using `TransferTypes.REQUIRES_MINIMAL_TIME` so the router treats them as walking connections (for both transfers and access/egress). `minTransferTime` is expressed in minutes.
|
|
44
|
+
|
|
45
|
+
```ts
|
|
46
|
+
import { GtfsParser, TransferTypes, extendedGtfsProfile } from 'minotor/parser';
|
|
47
|
+
import type { GeneratedTransfers, TransferGenerator } from 'minotor/parser';
|
|
48
|
+
import type { Stop, StopsIndex } from 'minotor';
|
|
49
|
+
|
|
50
|
+
// Delegates to a hypothetical external walking-router HTTP API.
|
|
51
|
+
class WalkingApiTransferGenerator implements TransferGenerator {
|
|
52
|
+
async generate(
|
|
53
|
+
originStops: Stop[],
|
|
54
|
+
stops: StopsIndex,
|
|
55
|
+
): Promise<GeneratedTransfers> {
|
|
56
|
+
const generated: GeneratedTransfers = new Map();
|
|
57
|
+
|
|
58
|
+
for (const origin of originStops) {
|
|
59
|
+
// Reuse minotor's geo index to find nearby candidate stops.
|
|
60
|
+
const neighbors = stops.findStopsByLocation(
|
|
61
|
+
origin.lat,
|
|
62
|
+
origin.lon,
|
|
63
|
+
Infinity,
|
|
64
|
+
this.maxDistanceKm,
|
|
65
|
+
);
|
|
66
|
+
|
|
67
|
+
for (const neighbor of neighbors) {
|
|
68
|
+
// Ask the external engine for a real door-to-door walking time.
|
|
69
|
+
const walkTimeInMinutes = await callExternalRoutingEngine(
|
|
70
|
+
origin.lat,
|
|
71
|
+
origin.lon,
|
|
72
|
+
neighbor.lat,
|
|
73
|
+
neighbor.lon,
|
|
74
|
+
);
|
|
75
|
+
|
|
76
|
+
const transfers = generated.get(origin.id) ?? [];
|
|
77
|
+
transfers.push({
|
|
78
|
+
destination: neighbor.id,
|
|
79
|
+
type: TransferTypes.REQUIRES_MINIMAL_TIME,
|
|
80
|
+
minTransferTime: walkTimeInMinutes,
|
|
81
|
+
});
|
|
82
|
+
generated.set(origin.id, transfers);
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
return generated;
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
const parser = new GtfsParser(
|
|
91
|
+
'gtfs-feed.zip',
|
|
92
|
+
extendedGtfsProfile,
|
|
93
|
+
new WalkingApiTransferGenerator('https://walk.example.com'),
|
|
94
|
+
);
|
|
95
|
+
```
|
|
96
|
+
|
|
97
|
+
Transfers are directed. The example above emits one edge per `origin -> neighbor`; the reverse edge is produced when the neighbor is itself visited as an origin (every candidate stop is passed as an origin), so a symmetric walking time yields a usable connection both ways.
|