From 39c89d563b2beef8e707d1bedc94ca816fbc3dce Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 12:03:12 -0800 Subject: [PATCH 1/3] Draw transit vehicles as trolleybuses, cable cars, funiculars, gondolas and monorails The transit layer knew five modes, so a trolleybus drew as a bus, a funicular as a train and a coach as a city bus. The GTFS basic route types are now modes of their own (trolleybus, cable_tram, monorail, funicular, aerial_lift), each with an icon, colour, detection tier, card word, voice name, speed ceiling and fleet model. A vehicle record may carry its route's GTFS route_type as routeType. It settles the mode after the feed's fleet hint and before its route hint, and picks the finer model (a coach for 200, a high-speed set for 101) when the type is a kind of the vehicle's mode. Retained history classifies epochs through transitModeFor too, so trails join the live vehicle. Route hints from each operator's routes.txt: Prague's trolleybus lines (51-59, 232, 275) and Petrin funicular, and the trams, trolleybuses and metro lines of Bucharest, Cluj-Napoca and Turin. A feed may also name route corrections that outrank the route type: Le Havre's routes.txt types its funicular (8-FUNI) as a bus, so it is corrected to a funicular. --- changelog.d/0000-transit-route-type-models.md | 10 + docs/CURRENT-STATE.md | 30 ++- server/providers/transitHistory.test.mjs | 22 ++ src/data/fleetModels.test.mjs | 33 +++ src/data/transitFeeds.js | 253 ++++++++++++++++-- src/data/transitFeeds.test.mjs | 122 ++++++++- src/data/transitIcons.js | 81 +++++- src/data/transitIcons.test.mjs | 10 +- src/data/transitPresetStyle.js | 12 +- src/data/transitProxy.js | 1 + src/i18n/locales/ar.json | 7 +- src/i18n/locales/de.json | 7 +- src/i18n/locales/es.json | 7 +- src/i18n/locales/fr.json | 7 +- src/i18n/locales/he.json | 7 +- src/i18n/locales/it.json | 7 +- src/i18n/locales/ja.json | 7 +- src/i18n/locales/pt.json | 7 +- src/i18n/locales/ru.json | 7 +- src/i18n/locales/sv.json | 7 +- src/i18n/locales/uk.json | 7 +- src/i18n/locales/zh-CN.json | 7 +- src/i18n/locales/zh-Hant.json | 7 +- src/i18n/same-as-english.json | 4 + src/layers/transit/ingestion.js | 13 +- src/layers/transit/movement.js | 5 + src/layers/transit/policy.js | 15 ++ src/layers/transit/rendering.js | 10 +- src/layers/transit/trails.js | 11 +- src/overlays/worldOverlayTokens.js | 20 ++ src/sources/transitHistoryStore.js | 13 +- src/voice/layerManifest.js | 13 +- 32 files changed, 708 insertions(+), 61 deletions(-) create mode 100644 changelog.d/0000-transit-route-type-models.md diff --git a/changelog.d/0000-transit-route-type-models.md b/changelog.d/0000-transit-route-type-models.md new file mode 100644 index 000000000..463820354 --- /dev/null +++ b/changelog.d/0000-transit-route-type-models.md @@ -0,0 +1,10 @@ +- Draw transit vehicles as their kind, not one of five: trolleybuses, cable + cars, funiculars, gondolas and monorails are modes of their own, with their + own icon, colour, card word and fleet model. A vehicle record may carry its + route's GTFS `route_type` (`routeType`), which settles its mode before the + feed's route hints and picks the finer model (a coach for 200, a high-speed + set for 101). Prague's trolleybuses and Petřín funicular, and Bucharest, + Cluj and Turin's trams, trolleybuses and metro lines, now read as such from + the route ids in each operator's routes.txt. Le Havre's funicular, which its + routes.txt types as a bus, is a named correction that outranks the route + type (samehkhamis, #0000). diff --git a/docs/CURRENT-STATE.md b/docs/CURRENT-STATE.md index fc00c5934..4b578d178 100644 --- a/docs/CURRENT-STATE.md +++ b/docs/CURRENT-STATE.md @@ -5868,7 +5868,26 @@ Helsinki, the Netherlands, Norway, South East Queensland, Rio de Janeiro Ontario — Toronto (TTC surface vehicles; the subway publishes no positions), MiWay, Hamilton HSR, Durham Region, YRT/Viva, Guelph, Burlington, Barrie and Kingston. Mode silhouettes -identify buses, trams, subways, trains, ferries and unclassified vehicles. +identify buses, trolleybuses, trams, cable cars, subways, monorails, trains, +funiculars, gondolas (aerial lifts), ferries and unclassified vehicles. + +A vehicle's mode comes from, in order: the feed's fleet-number hint +(`vehicleMode`, which knows a bus standing in on a streetcar route); the feed's +correction for a route its own routes.txt mistypes (`routeCorrections`: Le +Havre's funicular `8-FUNI`, which LiA's routes.txt types as a bus); the GTFS +`route_type` of its route, when its record carries one as `routeType` (basic +0–12 or extended 100–1799, each extended type taken as the basic mode it is a +kind of: 200 coach is a bus, 101 high-speed is rail, 405 is a monorail); the +feed's route-id hint (`routeMode`); and the feed's default (`transitModeFor`, +`src/data/transitFeeds.js`). The GTFS-Realtime decoder carries no route type, so +a record from the bundled proxy is classified by the hints alone. Route hints +read from each operator's routes.txt cover Prague's trolleybus lines and Petřín +funicular, and Bucharest, Cluj-Napoca and Turin's trams, trolleybuses and metro +lines (and Turin's Sassi–Superga rack tramway, typed a funicular in its +routes.txt). Le Havre's funicular is a correction, not read from routes.txt: its +route hint and its correction both say funicular. Vilnius publishes no route ids in its positions, so +its trolleybuses read as buses. Retained history classifies its epochs the same +way, so a trail joins the live vehicle. Retained transit history uses the same outlier quarantine as live observations and preserves the active live bracket. Rejected reports do not publish route or mode @@ -5934,9 +5953,10 @@ External halos are 1/1.5 px in normal, 1.25/1.25 px in CRT and 2/2 px in sensors final unpadded display size. Each mode has an outline with a front (a nose, a bow or a chamfered cab) for a vehicle with a known course and a symmetric outline for one without, which would otherwise sit at rotation 0 and point -north; a vehicle switches to the pointed glyph when a course arrives. Six modes, two sizes, three -profiles and the two outlines cap the raster cache at 72 variants. Normal mode colours are bus `#5EF08A`, tram -`#FFC24A`, subway `#FF4538`, rail `#D9A6FF`, ferry `#5FD6FF`, and unknown +north; a vehicle switches to the pointed glyph when a course arrives. Eleven modes, two sizes, three +profiles and the two outlines cap the raster cache at 132 variants. Normal mode colours are bus `#5EF08A`, +trolleybus `#B6F04A`, tram `#FFC24A`, cable car `#FF8F4A`, subway `#FF4538`, monorail `#FF6FB8`, rail +`#D9A6FF`, funicular `#E8C98A`, gondola `#7FA8FF`, ferry `#5FD6FF`, and unknown `#D8DDE5`. Selection keeps the mode colour. Sensors reuse each normal silhouette's exact outer path, filled opaque white without interior panel lines, with an opaque `#05080C` halo. Only the external padding grows; the unpadded silhouette remains @@ -7430,7 +7450,7 @@ pins and share links already supply complete boxes. 30-second backoff ahead of the current clock are ignored. A smaller rollback can retain a bounded retry delay of up to 30 seconds. - Commercial and military aircraft use the same high-level FLEET model regime: 2D billboards when zoomed out, optional glTF models when closer, controlled by the DISPLAY rail `3D` toggle and `Proximity` / `All` modes. Every model is one of the project's procedural fleet models (`public/models/fleet/`, MIT, 122 GLBs, about 2 MB in all; `public/models/README.md`), chosen per aircraft by `aircraftModelSpec` (`src/data/fleetModels.js`): the first of its ICAO type's callsign rules in `types.json` (`aircraft_callsign`) its callsign matches, else its type's entry, else the model of its `classifyAircraft` class for a type the map lacks, else its ADS-B emitter category's, else the default airliner. It is drawn LIFE SIZE: the type's published length over the model's built length (`src/layers/flights/modelSpec.js`, shared by Flights, Military Flights and Local ADS-B), and a grounded aircraft stands the model's scaled clearance above the ground. An airport ground vehicle (feed type `ZVEH`) is a fire truck (`FIRE…`), pushback tug (`PUSH…`, `TUG…`), van (`DEICER…`, `SQUID…`, `SQB…`) or else a car by its callsign, and a ground station (`GRND`) is an 11.8 m radio mast; these models (catalog category `other`) are drawn at their built size, and such a contact with no altitude stands on the ground instead of at the airborne default (`src/layers/flights/records.js`). `classifyAircraft` still picks the 2D icons. The whole set loads once, up front, when a layer that draws it starts (`loadFleetModelSet`, which logs `[Fleet] N/122 models (X MB) loaded in N ms`); models are built from those bytes, never fetched mid-session, and an aircraft stays its billboard until the set has loaded. Every aircraft model draws its mesh's own colours (`aircraftModelBlend`, `src/data/aircraftModelLighting.js`): Cesium's `ColorBlendMode.HIGHLIGHT` with white, in Flights, Military Flights and Local ADS-B alike; the tracked colour (cyan, or amber in Military Flights) and the emergency red multiply into the mesh, so its paint still shows. IR boost draws them flat white (`MIX` at `1.0`). Under NVG/FLIR (map preset or Cockpit vision) models render unlit flat-white at full alpha and scene fog is disabled (fog otherwise blacks out distant models with the globe hidden); state restores on exit. -- Vessels, Transit and Rail draw fleet models under the same DISPLAY rail `3D` toggle, at the same altitude ceiling, caps and add/keep radii as the aircraft (`FLEET_MODEL_POLICY`, `src/layers/flights/policy.js`; `createFleetModelLayer`, `src/data/fleetModelInstances.js`). A vessel's model follows its AIS ship type and is drawn at its reported length and beam (AIS static dimensions A+B and C+D, now carried on vessel rows as `length` and `beam`), standing at the sea surface, heading by true heading then course. An aid to navigation is not a hull: a vessel record whose type names a buoy, beacon, mark, RACON or light, or whose MMSI is an aid-to-navigation station's (`99MIDxxxx`), is `isAidToNavigation` (`src/data/vesselTypes.js`) and is drawn as the set's `buoys` model of the IALA mark its type names (`aidToNavigationModel`, `src/data/fleetModels.js`: cardinal N/E/S/W, port or starboard hand, preferred channel by its side, safe water, isolated danger, special mark; a beacon, light, light vessel, RACON or reference point with no mark of its own is the special mark), else a red can (`DEFAULT_AID_MODEL`), at its built size and facing north whatever heading it reports. A type is an aid's when it is one of the 32 kinds an aid report names or uses a word for one (buoy, beacon, cardinal, safe water, RACON, lighthouse and so on); a vessel that works on aids (`Buoy Tender`, `Buoy Layer`) is not one. Its icon is a bone-white ringed disc (`AID_TO_NAVIGATION_STYLE`, `src/data/vesselLabels.js`) instead of a chevron, never rotated, and its card, selected card and HUD readout (`src/layers/vessels/cards.js`) show its kind alone, whole, in that colour: no speed or heading, since a fixed mark has neither. AISStream subscribes to `AidsToNavigationReport` (message 21) by default, and the server names each report's aid type code (0 to 31) as its kind (`aidToNavigationTypeName`: `20` is `Cardinal Mark N`) rather than reading it as a ship type, and its name runs on into the report's `NameExtension`. A virtual aid (the report's `VirtualAtoN` flag: a mark broadcast where nothing physical stands) carries `virtual: true` on its row, and on its vessel source record (the live-source contract's `virtual`, `src/sources/live/contract.js`, false unless a source says true; any source may set it). It keeps its disc but never gets a model (`vesselModelSpec` returns null for it, and the vessel layer gathers no model item for it), and its card and readout add `VIRTUAL` after its kind. `aisStreamRows` (`server/providers/vessels/ais-store.js`) puts every vessel ahead of every aid, so a capped request (the layer asks for 12,000 rows) never gives up a ship for a buoy. The `vessels_in_area` tool (and the brief built on it) counts ships only: it leaves aids out of its rows, counts, breakdowns and speed stats. A transit vehicle's model follows its layer mode (bus, tram, subway, rail or ferry; a vehicle of `unknown` mode keeps its icon), a train's its rail category and mode (rail, metro or tram). Neither the transit nor the rail sources carry a GTFS `route_type` or a finer mode (monorail, gondola, funicular, cable car), so the set's models for those and their `transit.elevation` lifts are not reached by any live source today. Both stand on the road or rail top they are drawn on, without the 1.5 m `GROUND_FLOOR_LIFT_M` their icons carry, and are painted in their mode or category colour where the model's `_TINT` attribute marks it. A vessel model is clipped at its waterline (one clipping plane per model, at the model origin's horizontal plane), so its hull below the water never shows through a plain globe, which Cesium does not depth-test models against. Under the NVG/FLIR styles (the Flights `irBoost` parameter) these models render unlit flat white, as aircraft models do. Each vehicle's icon stays the visual until its model is loaded, ready and placed; a model is picked as its icon is, and a vehicle drawn as its model keeps its selection card and its place in the detection overlay. +- Vessels, Transit and Rail draw fleet models under the same DISPLAY rail `3D` toggle, at the same altitude ceiling, caps and add/keep radii as the aircraft (`FLEET_MODEL_POLICY`, `src/layers/flights/policy.js`; `createFleetModelLayer`, `src/data/fleetModelInstances.js`). A vessel's model follows its AIS ship type and is drawn at its reported length and beam (AIS static dimensions A+B and C+D, now carried on vessel rows as `length` and `beam`), standing at the sea surface, heading by true heading then course. An aid to navigation is not a hull: a vessel record whose type names a buoy, beacon, mark, RACON or light, or whose MMSI is an aid-to-navigation station's (`99MIDxxxx`), is `isAidToNavigation` (`src/data/vesselTypes.js`) and is drawn as the set's `buoys` model of the IALA mark its type names (`aidToNavigationModel`, `src/data/fleetModels.js`: cardinal N/E/S/W, port or starboard hand, preferred channel by its side, safe water, isolated danger, special mark; a beacon, light, light vessel, RACON or reference point with no mark of its own is the special mark), else a red can (`DEFAULT_AID_MODEL`), at its built size and facing north whatever heading it reports. A type is an aid's when it is one of the 32 kinds an aid report names or uses a word for one (buoy, beacon, cardinal, safe water, RACON, lighthouse and so on); a vessel that works on aids (`Buoy Tender`, `Buoy Layer`) is not one. Its icon is a bone-white ringed disc (`AID_TO_NAVIGATION_STYLE`, `src/data/vesselLabels.js`) instead of a chevron, never rotated, and its card, selected card and HUD readout (`src/layers/vessels/cards.js`) show its kind alone, whole, in that colour: no speed or heading, since a fixed mark has neither. AISStream subscribes to `AidsToNavigationReport` (message 21) by default, and the server names each report's aid type code (0 to 31) as its kind (`aidToNavigationTypeName`: `20` is `Cardinal Mark N`) rather than reading it as a ship type, and its name runs on into the report's `NameExtension`. A virtual aid (the report's `VirtualAtoN` flag: a mark broadcast where nothing physical stands) carries `virtual: true` on its row, and on its vessel source record (the live-source contract's `virtual`, `src/sources/live/contract.js`, false unless a source says true; any source may set it). It keeps its disc but never gets a model (`vesselModelSpec` returns null for it, and the vessel layer gathers no model item for it), and its card and readout add `VIRTUAL` after its kind. `aisStreamRows` (`server/providers/vessels/ais-store.js`) puts every vessel ahead of every aid, so a capped request (the layer asks for 12,000 rows) never gives up a ship for a buoy. The `vessels_in_area` tool (and the brief built on it) counts ships only: it leaves aids out of its rows, counts, breakdowns and speed stats. A transit vehicle's model follows its route's GTFS `route_type` when its record carries one and that type is a kind of the vehicle's mode (`types.json` `transit.route_types`: 200 a coach, 101 a high-speed set, 106 a regional DMU, 710 a double-decker), else its layer mode (`transit.modes`: bus, trolleybus, tram, cable car, subway, monorail, rail, funicular, gondola or ferry; a vehicle of `unknown` mode keeps its icon); a fleet hint that overrules the route (a bus on a tram route) leaves the type unused. A monorail and a gondola are raised by their `transit.elevation` lifts. A train's model follows its rail category and mode (rail, metro or tram). The bundled GTFS-Realtime proxy carries no route type, so its vehicles draw their mode's model; a source that adds `routeType` reaches the finer ones. Both stand on the road or rail top they are drawn on, without the 1.5 m `GROUND_FLOOR_LIFT_M` their icons carry, and are painted in their mode or category colour where the model's `_TINT` attribute marks it. A vessel model is clipped at its waterline (one clipping plane per model, at the model origin's horizontal plane), so its hull below the water never shows through a plain globe, which Cesium does not depth-test models against. Under the NVG/FLIR styles (the Flights `irBoost` parameter) these models render unlit flat white, as aircraft models do. Each vehicle's icon stays the visual until its model is loaded, ready and placed; a model is picked as its icon is, and a vehicle drawn as its model keeps its selection card and its place in the detection overlay. - **Aircraft models skip Cesium's dynamic environment map (2026-10-24).** Flights, Military Flights and Local ADS-B pass `environmentMapOptions: AIRCRAFT_ENVIRONMENT_MAP_OPTIONS` (`{ enabled: false }`, `src/data/aircraftModelLighting.js`) to every drawn model. Otherwise each `Model` renders the sky around it and reads it back from the GPU (`readPixels`) when it is first placed, and again whenever it moves more than 1 km, the scene's atmosphere settings change, or (under sunlight dynamic lighting) an hour of scene time passes (`DynamicEnvironmentMapManager`, Cesium 1.138). The models are lit from Cesium's default spherical harmonics instead, with no specular environment map, so the sky's model-lighting cube map no longer reaches aircraft. `src/data/aircraftModelLighting.test.mjs` pins the option at every drawn model call; every model is built from the fleet set loaded up front, so there is no separate preload. - The DISPLAY-rail `3D` toggle is the user-facing activation path for both aircraft layers. Their small approved GLBs build their render resources without Cesium's frame-spread job queue, preventing continuous Photorealistic 3D Tiles streaming from starving model readiness; model caps, tracking, camera, and fallback billboards are unchanged. - **The `3D` toggle DEFAULTS ON in `proximity` on a first run.** Proximity is itself the budget — models appear only below `MODEL_ALT_CEIL_M` and only for the nearest `MODEL_MAX` in view — so the default costs nothing at globe scale, and `all` remains a deliberate opt-in. A fresh boot runs NO layer-state restoration (`LayerStateCoordinator.start()` returns early with neither a share payload nor stored state), so four independent initializers decide what a first-run operator sees and must agree: `booleanOption('models3d', 'e', true)` in `src/data/layerState.js`, `_models3dEnabled = true` in BOTH flight layers, `this._models3dEnabled = true` in `src/ui/aircraftDisplay.js`, and the `active` / `visible` classes on `#models3d-toggle` / `#models3d-mode-row` in `index.html`. All four are pinned together in `src/data/layerState.test.mjs`. Explicit state still wins: because the codec omits default-valued options, `models3d: false` is now what travels in a link (`lo=…f.e.0`) and restores OFF at both aircraft layers. **Consequence for returning users:** a stored `gev:layer-state:v2` blob is a FULL options snapshot, so a session that wrote one before this change carries `models3d:false` and keeps 3D off until the operator flips it (or clears the key) — the durable snapshot is treated as the recipient's own state, by design. diff --git a/server/providers/transitHistory.test.mjs b/server/providers/transitHistory.test.mjs index 551fee7a7..aeed8308a 100644 --- a/server/providers/transitHistory.test.mjs +++ b/server/providers/transitHistory.test.mjs @@ -202,3 +202,25 @@ test('a feed fleet-number mode outranks its route mode in the epoch context', (t assert.equal(h.get('ttc', '4507', 100000).epochs[0].mode, 'tram'); assert.equal(h.get('ttc', 'x1', 100000).epochs[0].mode, 'tram'); }); +test('the epoch mode is the live mode: a route type, else hints, else the default', (t) => { + const h = history(t); + const pid = { + id: 'pid', + historyRetention: true, + defaultMode: 'bus', + routeMode: (route) => (route === 'L22' ? 'tram' : 'unknown'), + }; + h.ingest( + pid, + [ + row(100000, 'a', { routeId: 'L58', routeType: 11 }), + row(100000, 'b', { routeId: 'L22' }), + row(100000, 'c', { routeId: 'L9999' }), + ], + 100000, + ); + assert.equal(h.get('pid', 'a', 100000).epochs[0].mode, 'trolleybus'); + assert.equal(h.get('pid', 'b', 100000).epochs[0].mode, 'tram'); + // A hint that knows nothing leaves the default, as the live layer does. + assert.equal(h.get('pid', 'c', 100000).epochs[0].mode, 'bus'); +}); diff --git a/src/data/fleetModels.test.mjs b/src/data/fleetModels.test.mjs index d48e744c1..315c53746 100644 --- a/src/data/fleetModels.test.mjs +++ b/src/data/fleetModels.test.mjs @@ -25,6 +25,7 @@ import { vesselModelSpec, } from './fleetModels.js'; import { FLEET_TRAIL_ANCHORS } from './fleetTrailAnchors.js'; +import { TRANSIT_MODES } from './transitFeeds.js'; import { centrelineSegments, distanceToSurface, @@ -444,6 +445,38 @@ test('aids to navigation are the buoy of the mark their type names', () => { } }); +test('every transit mode but unknown draws its own model, and a route type a finer one', () => { + for (const mode of TRANSIT_MODES.filter((m) => m !== 'unknown')) { + assert.ok(types.transit.modes[mode], `${mode} has a model`); + assert.equal( + resolveTransit(types, { mode }).model, + types.transit.modes[mode][0], + ); + } + for (const [mode, model] of [ + ['trolleybus', 'trolleybus'], + ['cable_tram', 'cable_tram'], + ['aerial_lift', 'gondola'], + ['funicular', 'funicular'], + ['monorail', 'monorail'], + ]) + assert.equal(resolveTransit(types, { mode }).model, model, mode); + // A route type outranks the mode: a coach and a high-speed set are still + // the bus and rail modes. + for (const [routeType, mode, model] of [ + [200, 'bus', 'coach'], + [101, 'rail', 'high_speed'], + [106, 'rail', 'regional_dmu'], + [710, 'bus', 'double_decker'], + ]) + assert.equal(resolveTransit(types, { routeType, mode }).model, model); + // A type the table lacks falls back to the mode. + assert.equal( + resolveTransit(types, { routeType: 300, mode: 'rail' }).model, + 'commuter_emu', + ); +}); + test('transit specs: rail category and mode, then route type, then mode, then the default', () => { assert.deepEqual(resolveTransit(types, { railCategory: 'national' }), { model: 'intercity', diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js index 42f399d77..3e9f9cebc 100644 --- a/src/data/transitFeeds.js +++ b/src/data/transitFeeds.js @@ -29,12 +29,21 @@ import { RIO_ROUTE_NAMES } from './rioRouteNames.js'; * node:test. No Cesium, no Node built-ins. */ -/** Transit modes the layer colors. `routeMode` hints refine a feed's default. */ +/** + * Transit modes the layer colors: the GTFS basic route types, by name. A + * vehicle's GTFS `route_type` settles its mode when its record carries one; + * otherwise `routeMode` hints refine a feed's default. + */ export const TRANSIT_MODES = Object.freeze([ 'bus', + 'trolleybus', 'tram', + 'cable_tram', 'subway', + 'monorail', 'rail', + 'funicular', + 'aerial_lift', 'ferry', 'unknown', ]); @@ -42,13 +51,81 @@ export const TRANSIT_MODES = Object.freeze([ /** Per-mode icon used in labels and the selection card. */ export const TRANSIT_MODE_ICON = Object.freeze({ bus: '🚌', + trolleybus: '🚎', tram: '🚊', + cable_tram: '🚋', subway: '🚇', + monorail: '🚝', rail: '🚆', + funicular: '🚞', + aerial_lift: '🚡', ferry: '⛴️', unknown: '🚏', }); +/** The basic GTFS route types (0–7, 11, 12) by mode. */ +const BASIC_ROUTE_TYPE_MODES = Object.freeze({ + 0: 'tram', + 1: 'subway', + 2: 'rail', + 3: 'bus', + 4: 'ferry', + 5: 'cable_tram', + 6: 'aerial_lift', + 7: 'funicular', + 11: 'trolleybus', + 12: 'monorail', +}); + +/** + * A GTFS `route_type` as an integer: a basic type (0–12) or an extended one + * (100–1799), as a number or its decimal text. Null for anything else. + * @param {unknown} value + * @returns {number|null} + */ +export function transitRouteType(value) { + const n = + typeof value === 'number' + ? value + : typeof value === 'string' && /^\d{1,4}$/.test(value.trim()) + ? Number(value.trim()) + : NaN; + return Number.isInteger(n) && n >= 0 && n < 1800 ? n : null; +} + +/** + * The mode of a GTFS `route_type`: the basic types, and the extended ones + * mapped to the basic mode they are a kind of (a coach, 200, is a bus; a + * high-speed train, 101, is rail; 405 is a monorail). Air, taxi and other + * services, and a value GTFS does not define, are `unknown`. + * @param {unknown} routeType + * @returns {string} One of TRANSIT_MODES. + */ +export function transitModeOfRouteType(routeType) { + const n = transitRouteType(routeType); + if (n === null) return 'unknown'; + if (n < 100) return BASIC_ROUTE_TYPE_MODES[n] ?? 'unknown'; + if (n === 405) return 'monorail'; + const family = Math.floor(n / 100); + return ( + { + 1: 'rail', // railway + 2: 'bus', // coach + 3: 'rail', // suburban railway + 4: 'subway', // urban railway + 5: 'subway', // metro + 6: 'subway', // underground + 7: 'bus', + 8: 'trolleybus', + 9: 'tram', + 10: 'ferry', // water transport + 12: 'ferry', // ferry + 13: 'aerial_lift', + 14: 'funicular', + }[family] ?? 'unknown' + ); +} + /** * MBTA route ids are human-readable and mode-typed: rapid-transit lines carry * colour names, commuter rail is prefixed `CR-`, ferries `Boat-`, buses are @@ -443,7 +520,7 @@ const liaRouteLabel = routeIdPattern(/^8-0*(\w.*)$/); function liaRouteMode(routeId) { if (!routeId) return 'unknown'; const line = liaRouteLabel(routeId); - if (line === 'FUNI') return 'rail'; + if (line === 'FUNI') return 'funicular'; return /^[AB]$/.test(line) ? 'tram' : 'bus'; } @@ -474,6 +551,7 @@ function astuceRouteLabel(routeId) { * Prague PID route ids are `L` plus a number whose range says what runs it, * per PID's GTFS routes.txt (data.pid.cz, checked 2026-11-09): 1–99 trams * (50–59 trolleybuses, 49 the Petřín funicular `LD`), 100–990 buses (the + * trolleybus routes 232 and 275 among them, GTFS route type 11; the * 800s are the X replacement lines, `L803` is X3), 991–993 metro A–C, * 1000s and 1100s the S and R trains (`L1004` is S4, `L1109` R9), the rest * of 1200–1399 other trains, 1700s town buses, 1800s the P ferries, and from @@ -487,10 +565,11 @@ function pidRoute(routeId) { if (!match) return { mode: 'unknown', label: routeId }; const n = Number(match[1]); // i18n-ignore: line code, as signed - if (n === 49) return { mode: 'rail', label: 'LD' }; - if (n >= 50 && n <= 59) return { mode: 'bus', label: String(n) }; + if (n === 49) return { mode: 'funicular', label: 'LD' }; + if (n >= 50 && n <= 59) return { mode: 'trolleybus', label: String(n) }; if (n < 100) return { mode: 'tram', label: String(n) }; if (n >= 800 && n < 900) return { mode: 'bus', label: `X${n - 800}` }; + if (n === 232 || n === 275) return { mode: 'trolleybus', label: String(n) }; if (n < 991) return { mode: 'bus', label: String(n) }; // i18n-ignore: metro line letters, as signed if (n <= 993) return { mode: 'subway', label: 'ABC'[n - 991] }; @@ -512,6 +591,102 @@ function pidRouteLabel(routeId) { return pidRoute(routeId).label; } +/** + * A feed's route hint from its static GTFS routes.txt: the route ids of + * every mode but `bus`, which is everything else. + * @param {Record} idsByMode + * @returns {(routeId: string|null) => string} + */ +function routeModeTable(idsByMode) { + const modes = new Map( + Object.entries(idsByMode).flatMap(([mode, ids]) => + ids.map((id) => [id, mode]), + ), + ); + return (routeId) => (routeId ? (modes.get(routeId) ?? 'bus') : 'unknown'); +} + +/** + * Bucharest TPBI by route id, from its routes.txt (checked 2026-11-14): the + * trams (route type 0), metro lines M1–M5 (1) and trolleybuses (11); every + * other route is a bus. Realtime route ids are the static ones. + */ +const tpbiRouteMode = routeModeTable({ + tram: [ + '54', + '55', + '57', + '61', + '63', + '65', + '66', + '67', + '68', + '69', + '70', + '814', + '915', + '1013', + ], + subway: ['968', '969', '970', '971', '999'], + trolleybus: [ + '72', + '73', + '74', + '75', + '76', + '78', + '81', + '83', + '84', + '85', + '86', + '87', + '247', + '910', + '916', + '924', + '925', + ], +}); + +/** + * Cluj-Napoca CTP by route id, from its routes.txt (checked 2026-11-14): the + * trams 100–102L (route type 0) and the trolleybuses (11). + */ +const ctpClujRouteMode = routeModeTable({ + tram: ['2', '3', '4', '5'], + trolleybus: [ + '1', + '10', + '14', + '15', + '22', + '36', + '49', + '53', + '54', + '55', + '117', + '119', + '120', + '153', + '166', + '187', + ], +}); + +/** + * Turin GTT by route id, from its routes.txt (checked 2026-11-14): the trams + * (route type 0), metro M1, and the Sassi–Superga rack tramway `79U`, which + * the file types as a funicular (7). + */ +const gttRouteMode = routeModeTable({ + tram: ['3U', '4U', '7U', '9U', '10U', '13U', '15U', '16CDU', '16CSU'], + subway: ['METROU'], + funicular: ['79U'], +}); + /** * Bordeaux TBM tram and boat lines by route id, from TBM's static GTFS * routes.txt (checked 2026-11-09): the trams are numbered ids, not letters. @@ -571,6 +746,7 @@ function transitFeed(fields) { * url: string, headers?: Record, * license: string, licenseUrl: string, attribution: string, * defaultMode: string, routeMode?: (routeId: string|null) => string, + * routeCorrections?: Readonly>, * speedUnit?: 'km/h', refreshMs?: number, sourceUrl?: string, * creditDated?: boolean, * }>>} @@ -579,6 +755,9 @@ function transitFeed(fields) { * stretches the proxy's cache for an upstream that rate-limits below one * request per 15 s TTL. `sourceUrl` and `creditDated` add a link and a date * to the credit for licences that ask for them (`transitFeedCredit`). + * `routeCorrections` names the routes whose `route_type` the operator's own + * routes.txt gets wrong, `route_id` to the mode they really are; a correction + * outranks the route type, which would otherwise outrank the route hint. */ export const TRANSIT_FEED_REGISTRY = Object.freeze([ Object.freeze({ @@ -1264,6 +1443,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([ note: 'Keyless public endpoint from the metropolitan transport authority; no licence found. Same basis as Metro Transit and OVapi.', }, defaultMode: 'bus', + routeMode: tpbiRouteMode, }), transitFeed({ id: 'roma-mobilita', @@ -1296,6 +1476,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([ note: 'Official keyless endpoint; no licence found. Same basis as Metro Transit and OVapi. Route ids append `U` for urban lines.', }, defaultMode: 'bus', + routeMode: gttRouteMode, routeLabel: gttRouteLabel, }), transitFeed({ @@ -1401,6 +1582,7 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([ note: 'Keyless; no licence found. Same basis as Metro Transit and OVapi.', }, defaultMode: 'bus', + routeMode: ctpClujRouteMode, }), transitFeed({ id: 'ctp-iasi', @@ -1567,6 +1749,8 @@ export const TRANSIT_FEED_REGISTRY = Object.freeze([ defaultMode: 'bus', routeLabel: liaRouteLabel, routeMode: liaRouteMode, + // LiA's routes.txt types the funicular (`8-FUNI`) as a bus (3). + routeCorrections: Object.freeze({ '8-FUNI': 'funicular' }), }), transitFeed({ id: 'filbleu-tours', @@ -1664,54 +1848,89 @@ export function transitFeedsInRange(lat, lon, slackKm = 0) { } /** - * The feed's own hint for a vehicle: its fleet number when the feed maps - * those (`vehicleMode`), else its route (`routeMode`). Null when neither knows. + * What settles a vehicle's mode, most specific first: the feed's fleet hint + * (`vehicleMode`, which knows a bus standing in on a tram route), else the + * feed's correction for a route its routes.txt mistypes (`routeCorrections`), + * else the GTFS `route_type` of its route when the record carries one, else + * the feed's route hint (`routeMode`). Null when none of them knows. * @param {object} feed Registry entry. * @param {string|null} routeId * @param {string|null} vehicleId + * @param {unknown} routeType GTFS `route_type`, when the record has one. * @returns {string|null} */ -function hintedMode(feed, routeId, vehicleId) { +function hintedMode(feed, routeId, vehicleId, routeType) { const byVehicle = typeof feed?.vehicleMode === 'function' ? feed.vehicleMode(vehicleId) : null; if (byVehicle && byVehicle !== 'unknown') return byVehicle; + const corrections = feed?.routeCorrections; + if (routeId && corrections && Object.hasOwn(corrections, routeId)) + return corrections[routeId]; + const byType = transitModeOfRouteType(routeType); + if (byType !== 'unknown') return byType; return typeof feed?.routeMode === 'function' ? feed.routeMode(routeId) : null; } /** - * Mode for a vehicle: the feed's fleet or route hint when it has one, else - * its default. + * Mode for a vehicle: its fleet hint, route type or route hint when one + * knows ({@link hintedMode}), else its feed's default. * @param {object} feed Registry entry. * @param {string|null} routeId GTFS route_id from the vehicle's trip. * @param {string|null} [vehicleId] GTFS-RT vehicle id. + * @param {unknown} [routeType] GTFS `route_type` of the route, when known. * @returns {string} One of TRANSIT_MODES. */ -export function transitModeFor(feed, routeId, vehicleId = null) { - const hinted = hintedMode(feed, routeId, vehicleId); +export function transitModeFor( + feed, + routeId, + vehicleId = null, + routeType = null, +) { + const hinted = hintedMode(feed, routeId, vehicleId, routeType); const mode = hinted && hinted !== 'unknown' ? hinted : feed?.defaultMode || 'unknown'; return TRANSIT_MODES.includes(mode) ? mode : 'unknown'; } /** - * Whether the mode came from the route id rather than the feed's default. A - * default is a guess about a fleet — TransLink's is "bus" while it publishes - * rail in the same feed — so a consumer judging physical plausibility must - * not hold a defaulted vehicle to a bus's limits. + * Whether the mode came from the vehicle, its route type or its route id + * rather than the feed's default. A default is a guess about a fleet — + * TransLink's is "bus" while it publishes rail in the same feed — so a + * consumer judging physical plausibility must not hold a defaulted vehicle + * to a bus's limits. * @param {object} feed Registry entry. * @param {string|null} routeId * @param {string|null} [vehicleId] + * @param {unknown} [routeType] * @returns {boolean} */ -export function transitModeResolved(feed, routeId, vehicleId = null) { - const hinted = hintedMode(feed, routeId, vehicleId); +export function transitModeResolved( + feed, + routeId, + vehicleId = null, + routeType = null, +) { + const hinted = hintedMode(feed, routeId, vehicleId, routeType); return ( Boolean(hinted) && hinted !== 'unknown' && TRANSIT_MODES.includes(hinted) ); } +/** + * The route type a vehicle's model is chosen by: its record's, when that type + * is a kind of the mode it was given. A fleet hint can overrule the route (a + * bus on a tram route), and then the route's type does not describe it. + * @param {string} mode The vehicle's mode ({@link transitModeFor}). + * @param {unknown} routeType + * @returns {number|null} + */ +export function transitModelRouteType(mode, routeType) { + const n = transitRouteType(routeType); + return n !== null && transitModeOfRouteType(n) === mode ? n : null; +} + /** * The route as a rider would say it. Most feeds publish that already, so this * is identity for them; a feed that publishes internal keys supplies its own diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs index 75a902728..37ad82a56 100644 --- a/src/data/transitFeeds.test.mjs +++ b/src/data/transitFeeds.test.mjs @@ -11,9 +11,13 @@ import { haversineKm, publicTransitCatalog, transitFeedsInRange, + TRANSIT_MODE_ICON, transitModeFor, + transitModeOfRouteType, transitModeResolved, + transitModelRouteType, transitRouteLabel, + transitRouteType, } from './transitFeeds.js'; import { RIO_ROUTE_NAMES } from './rioRouteNames.js'; @@ -729,8 +733,9 @@ test('Prague route-id ranges give metro, trains, ferries and trolleybuses their transitRouteLabel(feed, routeId), ]; assert.deepEqual(read('L22'), ['tram', '22']); - assert.deepEqual(read('L58'), ['bus', '58'], 'trolleybus'); - assert.deepEqual(read('L49'), ['rail', 'LD'], 'Petřín funicular'); + assert.deepEqual(read('L58'), ['trolleybus', '58']); + assert.deepEqual(read('L275'), ['trolleybus', '275'], 'route type 11'); + assert.deepEqual(read('L49'), ['funicular', 'LD'], 'Petřín funicular'); assert.deepEqual(read('L135'), ['bus', '135']); assert.deepEqual(read('L803'), ['bus', 'X3']); assert.deepEqual(read('L991'), ['subway', 'A']); @@ -767,7 +772,7 @@ test('Rouen Métro and Calypso are not buses; Le Havre reads its own ids', () => assert.equal(transitModeFor(feed, 'TCAR:93'), 'bus'); assert.equal(transitRouteLabel(feed, 'TAE:F'), 'F'); const lia = getTransitFeed('lia-le-havre'); - assert.equal(transitModeFor(lia, '8-FUNI'), 'rail'); + assert.equal(transitModeFor(lia, '8-FUNI'), 'funicular'); assert.equal(transitRouteLabel(lia, '8-C3'), 'C3'); assert.equal(transitRouteLabel(lia, '8-09'), '9'); assert.equal(transitRouteLabel(lia, '8-A'), 'A'); @@ -778,3 +783,114 @@ test('data.gov.my feeds ask the proxy for no more than its 4 a minute', () => { assert.ok(getTransitFeed(id).refreshMs >= 30_000, id); } }); + +test('a GTFS route type names its mode, basic and extended alike', () => { + for (const [routeType, mode] of [ + [0, 'tram'], + [1, 'subway'], + [2, 'rail'], + [3, 'bus'], + [4, 'ferry'], + [5, 'cable_tram'], + [6, 'aerial_lift'], + [7, 'funicular'], + [11, 'trolleybus'], + [12, 'monorail'], + [101, 'rail'], + [106, 'rail'], + [200, 'bus'], + [300, 'rail'], + [401, 'subway'], + [405, 'monorail'], + [702, 'bus'], + [800, 'trolleybus'], + [900, 'tram'], + [1000, 'ferry'], + [1200, 'ferry'], + [1300, 'aerial_lift'], + [1400, 'funicular'], + ['11', 'trolleybus'], + ]) + assert.equal(transitModeOfRouteType(routeType), mode, String(routeType)); + // Air, taxi and other services, and values GTFS does not define. + for (const other of [8, 1100, 1500, 1700, 1800, -1, 2.5, '', 'tram', null]) + assert.equal(transitModeOfRouteType(other), 'unknown', String(other)); + assert.equal(transitRouteType(' 200 '), 200); + assert.equal(transitRouteType('2e2'), null); +}); + +test('every mode has an icon, and every mode a route type names is a mode', () => { + for (const mode of TRANSIT_MODES) assert.ok(TRANSIT_MODE_ICON[mode], mode); + for (let routeType = 0; routeType < 1800; routeType++) + assert.ok(TRANSIT_MODES.includes(transitModeOfRouteType(routeType))); +}); + +test('a route type settles the mode before a route hint or the default', () => { + const mbta = getTransitFeed('mbta'); + // The hint calls every numbered MBTA route a bus; a route type is finer. + assert.equal(transitModeFor(mbta, '71'), 'bus'); + assert.equal(transitModeFor(mbta, '71', 'y1', 11), 'trolleybus'); + assert.equal(transitModeResolved(mbta, '71', 'y1', 11), true); + // A default-only feed is resolved by a route type alone. + const durham = getTransitFeed('durham-region'); + assert.equal(transitModeResolved(durham, '915', 'b1'), false); + assert.equal(transitModeFor(durham, '915', 'b1', 200), 'bus'); + assert.equal(transitModeResolved(durham, '915', 'b1', 200), true); + // A type that names no mode leaves the hints in charge. + assert.equal(transitModeFor(mbta, 'Red', null, 1700), 'subway'); + assert.equal(transitModeFor(mbta, 'Red', null, 'x'), 'subway'); +}); + +test('a fleet hint outranks the route type, and then the type picks no model', () => { + const ttc = getTransitFeed('ttc-toronto'); + // A bus standing in on the 501 streetcar route (route type 0). + const mode = transitModeFor(ttc, '501', '8400', 0); + assert.equal(mode, 'bus'); + assert.equal(transitModelRouteType(mode, 0), null); + assert.equal(transitModelRouteType('tram', 0), 0); + assert.equal(transitModelRouteType('bus', 200), 200, 'a coach is a bus'); + assert.equal(transitModelRouteType('bus', null), null); +}); + +test('a route correction outranks a mistyped route type, and only for its route', () => { + const lia = getTransitFeed('lia-le-havre'); + // LiA's routes.txt types the funicular as a bus (3). + assert.equal(transitModeFor(lia, '8-FUNI', null, 3), 'funicular'); + assert.equal(transitModeResolved(lia, '8-FUNI', null, 3), true); + // A correction is a mode, so the bus type picks no model for it. + assert.equal(transitModelRouteType('funicular', 3), null); + // Every other route still takes its route type. + assert.equal(transitModeFor(lia, '8-A', null, 0), 'tram'); + assert.equal(transitModeFor(lia, '8-C3', null, 3), 'bus'); + assert.equal(transitModeFor(lia, null, null, 3), 'bus'); + // Corrections are narrow: a few named routes, each to a known mode. + for (const feed of TRANSIT_FEED_REGISTRY) { + if (!feed.routeCorrections) continue; + assert.ok(Object.isFrozen(feed.routeCorrections), feed.id); + for (const [route, mode] of Object.entries(feed.routeCorrections)) { + assert.ok(TRANSIT_MODES.includes(mode), `${feed.id} ${route}`); + assert.notEqual(mode, 'unknown', `${feed.id} ${route}`); + } + } + // An inherited key is not a correction. + assert.equal(transitModeFor(lia, 'toString', null, 3), 'bus'); +}); + +// Route ids as each realtime feed and its operator's routes.txt carried them +// on 2026-11-14. +test('Bucharest, Cluj and Turin route ids give trams, trolleybuses and a funicular', () => { + const mode = (id, routeId) => transitModeFor(getTransitFeed(id), routeId); + assert.equal(mode('tpbi-bucuresti', '85'), 'trolleybus', 'line 74'); + assert.equal(mode('tpbi-bucuresti', '1013'), 'tram', 'line 4'); + assert.equal(mode('tpbi-bucuresti', '968'), 'subway', 'M1'); + assert.equal(mode('tpbi-bucuresti', '828'), 'bus'); + assert.equal(mode('tpbi-bucuresti', 'PV1_407'), 'bus'); + assert.equal(mode('ctp-cluj', '1'), 'trolleybus'); + assert.equal(mode('ctp-cluj', '2'), 'tram', 'line 100'); + assert.equal(mode('ctp-cluj', '6'), 'bus', 'line 19'); + assert.equal(mode('gtt-torino', '79U'), 'funicular', 'Sassi–Superga'); + assert.equal(mode('gtt-torino', '16CDU'), 'tram'); + assert.equal(mode('gtt-torino', 'METROU'), 'subway'); + assert.equal(mode('gtt-torino', '6U'), 'bus'); + assert.equal(mode('gtt-torino', null), 'bus', 'no route: the default'); +}); diff --git a/src/data/transitIcons.js b/src/data/transitIcons.js index c6ad963e1..deb82656c 100644 --- a/src/data/transitIcons.js +++ b/src/data/transitIcons.js @@ -21,7 +21,9 @@ import { * at the ~18 px the fleet renders at, by shape and not only by colour: a bus is * short and blunt, a tram is long and slender with articulation joints, a metro * car is squared off, a mainline train has a tapered nose, and a ferry is a - * hull with a bow. + * hull with a bow. A trolleybus trails its two poles, a cable car is a short + * single car, a monorail the slimmest bullet, a funicular hangs off its rope, + * and a gondola is a cabin on its cable. * * Interior detail is drawn with the same dark hairline as the edge — windscreen * lines, articulation joints, a deck line — because a solid dark panel would @@ -103,6 +105,49 @@ const HEADING_BODIES = { fill="white" ${STROKE}/> `, + // ── Trolleybus: a bus a little narrower, trailing the two trolley poles + // that reach back to its wires. Body and poles are one outline, so no + // edge is drawn across the body. + trolleybus: ` + + `, + + // ── Cable car (street cable railway): a short single car, under half a + // tram, with open platforms at both ends. + cable_tram: ` + + + `, + + // ── Monorail: the slimmest train in the set, a rounded bullet nose over + // its beam. + monorail: ` + + `, + + // ── Funicular: a squat car hauled by the rope at its upper end. + funicular: ` + + + `, + + // ── Gondola (aerial lift): a cabin hung on the cable that runs through + // it; the cabin's nose is its front. + aerial_lift: ` + `, + // ── Unknown: a plain marker with a nose and nothing else, so an // unclassified vehicle never pretends to be a mode it is not. unknown: ` @@ -146,6 +191,40 @@ const NEUTRAL_BODIES = { fill="white" ${STROKE}/> `, + trolleybus: ` + `, + + cable_tram: ` + + + `, + + monorail: ` + + `, + + funicular: ` + + + `, + + aerial_lift: ` + `, + unknown: ` { +test('every variant retains the specified final halo at both display sizes', async () => { const { presetSpriteScale, presetSpriteOutlinePx } = await import('./transitPresetStyle.js'); for (const kind of TRANSIT_ICON_KINDS) { @@ -97,7 +97,8 @@ test('all 72 variants retain the specified final halo at both display sizes', as } for (let i = 0; i < 100; i++) transitIcon('invalid', i, { haloScreenPx: i, screenPx: i }); - assert.equal(transitIconCacheSize(), 72); + // Every kind at two sizes, three profiles, with and without a course. + assert.equal(transitIconCacheSize(), TRANSIT_ICON_KINDS.length * 12); }); test('every mono raster preserves the normal silhouette mask and aspect at CRT display size', async () => { @@ -197,6 +198,11 @@ test('sensor raster halo stays dark across its screen-space band on a white roof subway: 11.5, rail: 10.5, ferry: 12.5, + trolleybus: 15, + cable_tram: 11, + monorail: 8.5, + funicular: 11, + aerial_lift: 12, unknown: 10, }; for (const selected of [false, true]) { diff --git a/src/data/transitPresetStyle.js b/src/data/transitPresetStyle.js index 5996d4d97..cfb39053a 100644 --- a/src/data/transitPresetStyle.js +++ b/src/data/transitPresetStyle.js @@ -60,9 +60,14 @@ const SPRITE_STYLE = Object.freeze({ outlinePx: 1.25, rgbaByMode: Object.freeze({ bus: Object.freeze([0, 255, 102, 1]), + trolleybus: Object.freeze([170, 255, 0, 1]), tram: Object.freeze([255, 179, 0, 1]), + cable_tram: Object.freeze([255, 120, 0, 1]), subway: Object.freeze([255, 59, 48, 1]), + monorail: Object.freeze([255, 64, 170, 1]), rail: Object.freeze([215, 139, 255, 1]), + funicular: Object.freeze([255, 214, 140, 1]), + aerial_lift: Object.freeze([90, 140, 255, 1]), ferry: Object.freeze([58, 208, 255, 1]), unknown: Object.freeze([255, 255, 255, 1]), }), @@ -72,9 +77,14 @@ const SPRITE_STYLE = Object.freeze({ /** Modes with a bracket tier of their own. */ const TIER_MODES = Object.freeze([ 'bus', + 'trolleybus', 'tram', + 'cable_tram', 'subway', + 'monorail', 'rail', + 'funicular', + 'aerial_lift', 'ferry', 'unknown', ]); @@ -128,7 +138,7 @@ export function presetSpriteOutlinePx(styleName, selected = false) { /** * Detection-overlay tier key for a transit mode. Every theme's `tiers` - * table carries these six, so the bracket colour is per mode in every + * table carries one per mode, so the bracket colour is per mode in every * preset. Unlike traffic, transit sets its tier keyless as well: the feeds * are keyless, and there is no separate keyless experience to keep * byte-identical. diff --git a/src/data/transitProxy.js b/src/data/transitProxy.js index 6b328e5a5..e601a592d 100644 --- a/src/data/transitProxy.js +++ b/src/data/transitProxy.js @@ -19,6 +19,7 @@ import { decodeVehiclePositions, } from './gtfsRealtime.js'; import { getTransitFeed } from './transitFeeds.js'; +export { transitModeFor, transitRouteType } from './transitFeeds.js'; /** Fresh window: a snapshot younger than this is served without refetching. */ export const TRANSIT_PROXY_TTL_MS = 15_000; diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json index 44024e10f..ebdc0ef99 100644 --- a/src/i18n/locales/ar.json +++ b/src/i18n/locales/ar.json @@ -3962,5 +3962,10 @@ "Reset view reloads the app without the view restored from the address bar.": "تعيد «إعادة ضبط العرض» تحميل التطبيق دون العرض المستعاد من شريط العنوان.", "Reload": "إعادة التحميل", "Retry": "إعادة المحاولة", - "Reset view": "إعادة ضبط العرض" + "Reset view": "إعادة ضبط العرض", + "Trolleybus": "ترولي باص", + "Cable car": "ترام كابلي", + "Monorail": "قطار أحادي السكة", + "Funicular": "قطار جبلي مائل", + "Gondola": "تلفريك" } diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json index cdb669452..c1bf7dd2a 100644 --- a/src/i18n/locales/de.json +++ b/src/i18n/locales/de.json @@ -3614,5 +3614,10 @@ "Reset view reloads the app without the view restored from the address bar.": "Ansicht zurücksetzen lädt die App ohne die aus der Adressleiste wiederhergestellte Ansicht neu.", "Reload": "Neu laden", "Retry": "Erneut versuchen", - "Reset view": "Ansicht zurücksetzen" + "Reset view": "Ansicht zurücksetzen", + "Trolleybus": "Oberleitungsbus", + "Cable car": "Kabelstraßenbahn", + "Monorail": "Einschienenbahn", + "Funicular": "Standseilbahn", + "Gondola": "Gondelbahn" } diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json index b0d10ae06..1ba3bc810 100644 --- a/src/i18n/locales/es.json +++ b/src/i18n/locales/es.json @@ -3701,5 +3701,10 @@ "Reset view reloads the app without the view restored from the address bar.": "Restablecer la vista recarga la app sin la vista restaurada desde la barra de direcciones.", "Reload": "Recargar", "Retry": "Reintentar", - "Reset view": "Restablecer la vista" + "Reset view": "Restablecer la vista", + "Trolleybus": "Trolebús", + "Cable car": "Tranvía de cable", + "Monorail": "Monorraíl", + "Funicular": "Funicular", + "Gondola": "Góndola" } diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json index ffe522ad9..cb82ee62b 100644 --- a/src/i18n/locales/fr.json +++ b/src/i18n/locales/fr.json @@ -3701,5 +3701,10 @@ "Reset view reloads the app without the view restored from the address bar.": "Réinitialiser la vue recharge l’app sans la vue restaurée depuis la barre d’adresse.", "Reload": "Recharger", "Retry": "Réessayer", - "Reset view": "Réinitialiser la vue" + "Reset view": "Réinitialiser la vue", + "Trolleybus": "Trolleybus", + "Cable car": "Tramway à câble", + "Monorail": "Monorail", + "Funicular": "Funiculaire", + "Gondola": "Télécabine" } diff --git a/src/i18n/locales/he.json b/src/i18n/locales/he.json index cfe612894..80943335a 100644 --- a/src/i18n/locales/he.json +++ b/src/i18n/locales/he.json @@ -3701,5 +3701,10 @@ "Reset view reloads the app without the view restored from the address bar.": "\"איפוס תצוגה\" טוען מחדש את האפליקציה בלי התצוגה ששוחזרה משורת הכתובת.", "Reload": "טען מחדש", "Retry": "נסה שוב", - "Reset view": "איפוס תצוגה" + "Reset view": "איפוס תצוגה", + "Trolleybus": "טרוליבוס", + "Cable car": "חשמלית כבלים", + "Monorail": "מונורייל", + "Funicular": "פוניקולר", + "Gondola": "רכבל" } diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json index e8d939278..d68693f31 100644 --- a/src/i18n/locales/it.json +++ b/src/i18n/locales/it.json @@ -3701,5 +3701,10 @@ "Reset view reloads the app without the view restored from the address bar.": "Ripristina vista ricarica l’app senza la vista ripristinata dalla barra degli indirizzi.", "Reload": "Ricarica", "Retry": "Riprova", - "Reset view": "Ripristina vista" + "Reset view": "Ripristina vista", + "Trolleybus": "Filobus", + "Cable car": "Tram a fune", + "Monorail": "Monorotaia", + "Funicular": "Funicolare", + "Gondola": "Cabinovia" } diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json index 8039831d8..6c36c71ce 100644 --- a/src/i18n/locales/ja.json +++ b/src/i18n/locales/ja.json @@ -3527,5 +3527,10 @@ "Reset view reloads the app without the view restored from the address bar.": "「ビューをリセット」は、アドレスバーから復元したビューを使わずにアプリを再読み込みします。", "Reload": "再読み込み", "Retry": "再試行", - "Reset view": "ビューをリセット" + "Reset view": "ビューをリセット", + "Trolleybus": "トロリーバス", + "Cable car": "ケーブルトラム", + "Monorail": "モノレール", + "Funicular": "ケーブルカー", + "Gondola": "ゴンドラ" } diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json index 18b6d1dd2..8864f6d22 100644 --- a/src/i18n/locales/pt.json +++ b/src/i18n/locales/pt.json @@ -3701,5 +3701,10 @@ "Reset view reloads the app without the view restored from the address bar.": "Redefinir vista recarrega o app sem a vista restaurada da barra de endereços.", "Reload": "Recarregar", "Retry": "Tentar novamente", - "Reset view": "Redefinir vista" + "Reset view": "Redefinir vista", + "Trolleybus": "Trólebus", + "Cable car": "Bonde a cabo", + "Monorail": "Monotrilho", + "Funicular": "Funicular", + "Gondola": "Teleférico" } diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json index b58d78d26..37c6db315 100644 --- a/src/i18n/locales/ru.json +++ b/src/i18n/locales/ru.json @@ -3788,5 +3788,10 @@ "Reset view reloads the app without the view restored from the address bar.": "«Сбросить вид» перезагружает приложение без вида, восстановленного из адресной строки.", "Reload": "Перезагрузить", "Retry": "Повторить", - "Reset view": "Сбросить вид" + "Reset view": "Сбросить вид", + "Trolleybus": "Троллейбус", + "Cable car": "Канатный трамвай", + "Monorail": "Монорельс", + "Funicular": "Фуникулёр", + "Gondola": "Канатная дорога" } diff --git a/src/i18n/locales/sv.json b/src/i18n/locales/sv.json index bd1f25a7e..b1c9887e3 100644 --- a/src/i18n/locales/sv.json +++ b/src/i18n/locales/sv.json @@ -3614,5 +3614,10 @@ "Reset view reloads the app without the view restored from the address bar.": "”Återställ vy” laddar om appen utan vyn som återställdes från adressfältet.", "Reload": "Ladda om", "Retry": "Försök igen", - "Reset view": "Återställ vy" + "Reset view": "Återställ vy", + "Trolleybus": "Trådbuss", + "Cable car": "Kabelspårvagn", + "Monorail": "Enskensbana", + "Funicular": "Bergbana", + "Gondola": "Kabinbana" } diff --git a/src/i18n/locales/uk.json b/src/i18n/locales/uk.json index 9506d0a31..f59df5624 100644 --- a/src/i18n/locales/uk.json +++ b/src/i18n/locales/uk.json @@ -3788,5 +3788,10 @@ "Reset view reloads the app without the view restored from the address bar.": "«Скинути вигляд» перезавантажує застосунок без вигляду, відновленого з адресного рядка.", "Reload": "Перезавантажити", "Retry": "Повторити", - "Reset view": "Скинути вигляд" + "Reset view": "Скинути вигляд", + "Trolleybus": "Тролейбус", + "Cable car": "Канатний трамвай", + "Monorail": "Монорейка", + "Funicular": "Фунікулер", + "Gondola": "Канатна дорога" } diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json index f34c36028..2c4b5e9df 100644 --- a/src/i18n/locales/zh-CN.json +++ b/src/i18n/locales/zh-CN.json @@ -3527,5 +3527,10 @@ "Reset view reloads the app without the view restored from the address bar.": "“重置视图”会重新加载应用，不使用从地址栏恢复的视图。", "Reload": "重新加载", "Retry": "重试", - "Reset view": "重置视图" + "Reset view": "重置视图", + "Trolleybus": "无轨电车", + "Cable car": "缆索电车", + "Monorail": "单轨列车", + "Funicular": "缆索铁路", + "Gondola": "缆车" } diff --git a/src/i18n/locales/zh-Hant.json b/src/i18n/locales/zh-Hant.json index 0e01c7773..c9f352964 100644 --- a/src/i18n/locales/zh-Hant.json +++ b/src/i18n/locales/zh-Hant.json @@ -3527,5 +3527,10 @@ "Reset view reloads the app without the view restored from the address bar.": "「重置視圖」會重新加載應用，不使用從地址欄恢復的視圖。", "Reload": "重新加載", "Retry": "重試", - "Reset view": "重置視圖" + "Reset view": "重置視圖", + "Trolleybus": "無軌電車", + "Cable car": "纜索電車", + "Monorail": "單軌列車", + "Funicular": "纜索鐵路", + "Gondola": "纜車" } diff --git a/src/i18n/same-as-english.json b/src/i18n/same-as-english.json index b8a7eeb61..e95d5afc4 100644 --- a/src/i18n/same-as-english.json +++ b/src/i18n/same-as-english.json @@ -291,6 +291,7 @@ "FOV {value}°", "FT", "Folk", + "Funicular", "Funk", "GEO", "GOOGLE STREET VIEW", @@ -501,6 +502,7 @@ "MINI", "MISSION", "MM", + "Monorail", "MSG/S", "Metal", "Minimal", @@ -571,6 +573,7 @@ "TAGS · {tags}", "TEMP", "TLE", + "Trolleybus", "TYPE", "Tallinn", "Techno", @@ -950,6 +953,7 @@ "FOV {value}°", "FT", "Folk", + "Funicular", "Funk", "GEO", "GOOGLE STREET VIEW", diff --git a/src/layers/transit/ingestion.js b/src/layers/transit/ingestion.js index 3f5669c65..33723fef9 100644 --- a/src/layers/transit/ingestion.js +++ b/src/layers/transit/ingestion.js @@ -16,6 +16,7 @@ import { import { transitModeFor, transitModeResolved, + transitModelRouteType, } from '../../data/transitFeeds.js'; import { attachFloorToPlace, @@ -222,12 +223,19 @@ export function createIngestion({ state, services, parts, source }) { for (const record of records) { if (isStaleVehicleFix(record, now, fetchedAt)) continue; const key = transitVehicleKey(feed.id, record.id); - const mode = transitModeFor(feed, record.routeId, record.id); + const mode = transitModeFor( + feed, + record.routeId, + record.id, + record.routeType, + ); const modeInferred = !transitModeResolved( feed, record.routeId, record.id, + record.routeType, ); + const routeType = transitModelRouteType(mode, record.routeType); // A stamp ahead of the fetch is a clock fault; the fetch time bounds it. const stamped = vehicleReportTimeMs(record, fetchedAt); const reportAt = @@ -267,6 +275,7 @@ export function createIngestion({ state, services, parts, source }) { continue; } if (entry.mode !== mode) parts.rendering.paintMode(entry, mode); + entry.routeType = routeType; entry.modeInferred = modeInferred; updatePlayback(entry, now, monoNow); parts.rendering.schedulePlayback(entry); @@ -320,6 +329,8 @@ export function createIngestion({ state, services, parts, source }) { feedId: feed.id, marker: null, mode, + // The GTFS route type its model is chosen by, when it has one. + routeType, modeInferred, heightM: prior === null ? 0 : prior, heightCell: height.cell, diff --git a/src/layers/transit/movement.js b/src/layers/transit/movement.js index 2c9a61dcd..8202d7a56 100644 --- a/src/layers/transit/movement.js +++ b/src/layers/transit/movement.js @@ -11,9 +11,14 @@ import { } from '../../data/contactPlayback.js'; const MODE_MAX_SPEED_MPS = Object.freeze({ bus: 36, // ~130 km/h — a coach on a motorway + trolleybus: 28, // ~100 km/h — wired to the street tram: 28, // ~100 km/h — interurban light rail + cable_tram: 12, // ~43 km/h — the cable runs at a walking-pace multiple subway: 42, // ~150 km/h + monorail: 42, // ~150 km/h rail: 111, // ~400 km/h — high-speed services exist on some feeds + funicular: 16, // ~58 km/h — the fastest lines + aerial_lift: 15, // ~54 km/h — the fastest gondolas and trams ferry: 25, // ~90 km/h — fast catamarans unknown: 56, // ~200 km/h }); diff --git a/src/layers/transit/policy.js b/src/layers/transit/policy.js index eabe5df4a..a74d1bc16 100644 --- a/src/layers/transit/policy.js +++ b/src/layers/transit/policy.js @@ -189,9 +189,14 @@ export const SELECTED_CARD_REFRESH_MS = 250; /** Mode palette: distinct at a glance, none reused by flights (white/cyan), military (amber), or vessels. */ export const TRANSIT_MODE_COLORS = Object.freeze({ bus: '#5EF08A', + trolleybus: '#B6F04A', tram: '#FFC24A', + cable_tram: '#FF8F4A', subway: '#FF4538', + monorail: '#FF6FB8', rail: '#D9A6FF', + funicular: '#E8C98A', + aerial_lift: '#7FA8FF', ferry: '#5FD6FF', unknown: '#D8DDE5', }); @@ -526,9 +531,14 @@ const UNDERGROUND_MODES = new Set(['subway']); /** The mode in plain words, for a card a person reads rather than scans. */ const TRANSIT_MODE_WORD = Object.freeze({ bus: msg('Bus'), + trolleybus: msg('Trolleybus'), tram: msg('Tram'), + cable_tram: msg('Cable car'), subway: msg('Subway'), + monorail: msg('Monorail'), rail: msg('Train'), + funicular: msg('Funicular'), + aerial_lift: msg('Gondola'), ferry: msg('Ferry'), unknown: msg('Transit vehicle'), }); @@ -536,9 +546,14 @@ const TRANSIT_MODE_WORD = Object.freeze({ /** Short, fixed-width mode word for the detection card's class field. */ const TRANSIT_MODE_ABBR = Object.freeze({ bus: 'BUS', + trolleybus: 'TROLLEY', tram: 'TRAM', + cable_tram: 'CABLE', subway: 'METRO', + monorail: 'MONO', rail: 'RAIL', + funicular: 'FUNI', + aerial_lift: 'GONDOLA', ferry: 'FERRY', unknown: 'TRANSIT', }); diff --git a/src/layers/transit/rendering.js b/src/layers/transit/rendering.js index 058aa3a5d..8a1b19635 100644 --- a/src/layers/transit/rendering.js +++ b/src/layers/transit/rendering.js @@ -531,9 +531,15 @@ export function createRendering({ state, services, parts }) { groundLiftM, }; } - if (item.mode !== entry.mode) { + if (item.mode !== entry.mode || item.routeType !== entry.routeType) { item.mode = entry.mode; - item.spec = transitModelSpec(set, { mode: entry.mode }); + item.routeType = entry.routeType; + // The route type picks the finer model (a coach, a high-speed set); + // the mode is the fallback for a type the model table lacks. + item.spec = transitModelSpec(set, { + routeType: entry.routeType, + mode: entry.mode, + }); item.tint = MODE_CESIUM_COLORS[entry.mode] || MODE_CESIUM_COLORS.unknown; } diff --git a/src/layers/transit/trails.js b/src/layers/transit/trails.js index 4080766ee..315b2ece8 100644 --- a/src/layers/transit/trails.js +++ b/src/layers/transit/trails.js @@ -8,16 +8,9 @@ import { } from '../../data/contactPlayback.js'; import { createContactTrailRenderer } from '../../data/contactTrailRenderer.js'; import { fixDistanceM } from './movement.js'; +import { TRANSIT_MODE_COLORS } from './policy.js'; import { transitStyleProfile } from '../../data/transitPresetStyle.js'; -const MODE_COLOR = { - bus: '#5EF08A', - tram: '#FFC24A', - subway: '#FF4538', - rail: '#D9A6FF', - ferry: '#5FD6FF', - unknown: '#D8DDE5', -}; // Final Cesium batching uses 3,152 bytes per two-lane edge. // The 1,278-instance body plus 64 bytes/instance reserve stays below 2 MiB. export const TRAIL_VERTEX_LIMIT = 640; @@ -41,7 +34,7 @@ export function createTrails({ state, services, parts, source }) { renderer?.setStyle( transitStyleProfile(state._stylePreset) === 'mono' ? '#FFFFFF' - : MODE_COLOR[selected?.mode] || MODE_COLOR.unknown, + : TRANSIT_MODE_COLORS[selected?.mode] || TRANSIT_MODE_COLORS.unknown, ); } function releaseSelectionGeometry(entry) { diff --git a/src/overlays/worldOverlayTokens.js b/src/overlays/worldOverlayTokens.js index c03383148..895ba9ac7 100644 --- a/src/overlays/worldOverlayTokens.js +++ b/src/overlays/worldOverlayTokens.js @@ -139,9 +139,14 @@ export const DETECTION_THEME_MAP = Object.freeze({ veh_free: '#00ff66', veh_nodata: '#c9c9c9', transit_bus: '#5EF08A', + transit_trolleybus: '#B6F04A', transit_tram: '#FFC24A', + transit_cable_tram: '#FF8F4A', transit_subway: '#FF4538', + transit_monorail: '#FF6FB8', transit_rail: '#D9A6FF', + transit_funicular: '#E8C98A', + transit_aerial_lift: '#7FA8FF', transit_ferry: '#5FD6FF', transit_unknown: '#D8DDE5', }, @@ -169,9 +174,14 @@ export const DETECTION_THEME_MAP = Object.freeze({ veh_free: '#45d8ff', veh_nodata: '#dcdcdc', transit_bus: '#5EF08A', + transit_trolleybus: '#B6F04A', transit_tram: '#FFC24A', + transit_cable_tram: '#FF8F4A', transit_subway: '#FF4538', + transit_monorail: '#FF6FB8', transit_rail: '#D9A6FF', + transit_funicular: '#E8C98A', + transit_aerial_lift: '#7FA8FF', transit_ferry: '#5FD6FF', transit_unknown: '#D8DDE5', }, @@ -199,9 +209,14 @@ export const DETECTION_THEME_MAP = Object.freeze({ veh_free: '#2ecc71', veh_nodata: '#d8d8d8', transit_bus: '#5EF08A', + transit_trolleybus: '#B6F04A', transit_tram: '#FFC24A', + transit_cable_tram: '#FF8F4A', transit_subway: '#FF4538', + transit_monorail: '#FF6FB8', transit_rail: '#D9A6FF', + transit_funicular: '#E8C98A', + transit_aerial_lift: '#7FA8FF', transit_ferry: '#5FD6FF', transit_unknown: '#D8DDE5', }, @@ -229,9 +244,14 @@ export const DETECTION_THEME_MAP = Object.freeze({ veh_free: '#2ecc71', veh_nodata: '#c9c9c9', transit_bus: '#5EF08A', + transit_trolleybus: '#B6F04A', transit_tram: '#FFC24A', + transit_cable_tram: '#FF8F4A', transit_subway: '#FF4538', + transit_monorail: '#FF6FB8', transit_rail: '#D9A6FF', + transit_funicular: '#E8C98A', + transit_aerial_lift: '#7FA8FF', transit_ferry: '#5FD6FF', transit_unknown: '#D8DDE5', }, diff --git a/src/sources/transitHistoryStore.js b/src/sources/transitHistoryStore.js index cf82835c1..b53082e27 100644 --- a/src/sources/transitHistoryStore.js +++ b/src/sources/transitHistoryStore.js @@ -1,3 +1,4 @@ +import { transitModeFor } from '../data/transitFeeds.js'; import { validTransitIdentifier } from './transitHistory.js'; export { validTransitIdentifier } from './transitHistory.js'; /** Bounded, process-local operator position history. No upstream or scene access. */ @@ -328,12 +329,12 @@ export function createTransitHistory({ t > now + 10000 ) continue; - const byVehicle = feed.vehicleMode?.(record.id); - const mode = - (byVehicle !== 'unknown' && byVehicle) || - feed.routeMode?.(record.routeId) || - feed.defaultMode || - 'unknown'; + const mode = transitModeFor( + feed, + record.routeId, + record.id, + record.routeType, + ); const context = contextOf(record, mode); if (!context) continue; const key = `${feed.id}\u0000${record.id}`; diff --git a/src/voice/layerManifest.js b/src/voice/layerManifest.js index 189ee8e44..60cda6f25 100644 --- a/src/voice/layerManifest.js +++ b/src/voice/layerManifest.js @@ -302,7 +302,18 @@ const layers = [ }, { id: 'transit', - aliases: ['buses', 'trains', 'public transit', 'trams', 'subway'], + aliases: [ + 'buses', + 'trains', + 'public transit', + 'trams', + 'subway', + 'trolleybus', + 'gondola', + 'cable car', + 'funicular', + 'monorail', + ], context: false, query: { fields: { From 96cefa28b34f067211e9b2d933824610acf6dd12 Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 12:03:54 -0800 Subject: [PATCH 2/3] Number the transit route type changelog fragment for #1734 --- ...t-route-type-models.md => 1734-transit-route-type-models.md} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename changelog.d/{0000-transit-route-type-models.md => 1734-transit-route-type-models.md} (96%) diff --git a/changelog.d/0000-transit-route-type-models.md b/changelog.d/1734-transit-route-type-models.md similarity index 96% rename from changelog.d/0000-transit-route-type-models.md rename to changelog.d/1734-transit-route-type-models.md index 463820354..f451376e3 100644 --- a/changelog.d/0000-transit-route-type-models.md +++ b/changelog.d/1734-transit-route-type-models.md @@ -7,4 +7,4 @@ Cluj and Turin's trams, trolleybuses and metro lines, now read as such from the route ids in each operator's routes.txt. Le Havre's funicular, which its routes.txt types as a bus, is a named correction that outranks the route - type (samehkhamis, #0000). + type (samehkhamis, #1734). From dd152231090799c29ef106440eb41ef97b52f1eb Mon Sep 17 00:00:00 2001 From: Sameh Khamis Date: Sat, 14 Nov 2026 12:22:30 -0800 Subject: [PATCH 3/3] Class only PID's trolleybus lines as trolleybuses, and name the new modes in the plural for voice PID's routes.txt types lines 51, 52, 53, 58, 59, 232 and 275 as trolleybuses (route type 11); the rest of 50 to 59 stay buses, as before. Voice now also knows trolleybuses, gondolas, cable cars, funiculars and monorails. --- src/data/transitFeeds.js | 8 ++++++-- src/data/transitFeeds.test.mjs | 1 + src/voice/layerManifest.js | 5 +++++ 3 files changed, 12 insertions(+), 2 deletions(-) diff --git a/src/data/transitFeeds.js b/src/data/transitFeeds.js index 3e9f9cebc..0f6844c65 100644 --- a/src/data/transitFeeds.js +++ b/src/data/transitFeeds.js @@ -547,6 +547,9 @@ function astuceRouteLabel(routeId) { return ASTUCE_ROUTES[routeId ?? '']?.label ?? astuceNetworkLabel(routeId); } +/** PID trolleybus lines: route_type 11 in PID's routes.txt (checked 2026-11-14). */ +const PID_TROLLEYBUS_LINES = new Set([51, 52, 53, 58, 59, 232, 275]); + /** * Prague PID route ids are `L` plus a number whose range says what runs it, * per PID's GTFS routes.txt (data.pid.cz, checked 2026-11-09): 1–99 trams @@ -566,10 +569,11 @@ function pidRoute(routeId) { const n = Number(match[1]); // i18n-ignore: line code, as signed if (n === 49) return { mode: 'funicular', label: 'LD' }; - if (n >= 50 && n <= 59) return { mode: 'trolleybus', label: String(n) }; + if (PID_TROLLEYBUS_LINES.has(n)) + return { mode: 'trolleybus', label: String(n) }; + if (n >= 50 && n <= 59) return { mode: 'bus', label: String(n) }; if (n < 100) return { mode: 'tram', label: String(n) }; if (n >= 800 && n < 900) return { mode: 'bus', label: `X${n - 800}` }; - if (n === 232 || n === 275) return { mode: 'trolleybus', label: String(n) }; if (n < 991) return { mode: 'bus', label: String(n) }; // i18n-ignore: metro line letters, as signed if (n <= 993) return { mode: 'subway', label: 'ABC'[n - 991] }; diff --git a/src/data/transitFeeds.test.mjs b/src/data/transitFeeds.test.mjs index 37ad82a56..85a3a8243 100644 --- a/src/data/transitFeeds.test.mjs +++ b/src/data/transitFeeds.test.mjs @@ -734,6 +734,7 @@ test('Prague route-id ranges give metro, trains, ferries and trolleybuses their ]; assert.deepEqual(read('L22'), ['tram', '22']); assert.deepEqual(read('L58'), ['trolleybus', '58']); + assert.deepEqual(read('L55'), ['bus', '55'], 'not a PID trolleybus line'); assert.deepEqual(read('L275'), ['trolleybus', '275'], 'route type 11'); assert.deepEqual(read('L49'), ['funicular', 'LD'], 'Petřín funicular'); assert.deepEqual(read('L135'), ['bus', '135']); diff --git a/src/voice/layerManifest.js b/src/voice/layerManifest.js index 60cda6f25..52cb0f90f 100644 --- a/src/voice/layerManifest.js +++ b/src/voice/layerManifest.js @@ -309,10 +309,15 @@ const layers = [ 'trams', 'subway', 'trolleybus', + 'trolleybuses', 'gondola', + 'gondolas', 'cable car', + 'cable cars', 'funicular', + 'funiculars', 'monorail', + 'monorails', ], context: false, query: {