# TrainPulse

Live-Karte aller Züge in der Schweiz und in Deutschland: Position entlang der echten Strecke,
Linie, Ziel, Verspätung und Fahrtverlauf mit Gleis. Hintergrund umschaltbar zwischen Karte,
dunkler Karte (OpenStreetMap) und Satellit (swisstopo SWISSIMAGE, ausserhalb der Schweiz Sentinel-2).

## Wie es funktioniert

```
opentransportdata.swiss ──GTFS (Mo+Do)──┐
gtfs.de (DELFI) ─────────GTFS (täglich)──┼▶ updater-Container (stündlich)
                                         │   ├─ Filter: nur Bahn (route_type 2, 100–199)
OpenStreetMap CH + DE (Geofabrik) ───────┴▶  ├─ osmium: nur Schienennetz, pfaedle: Streckenverläufe
                                             └─▶ data/feeds/<ch|de>/<version>/
opentransportdata.swiss ──GTFS-RT (35 s)──┐
gtfs.de ─────────────────GTFS-RT (60 s)───┴▶ web-Container (Port 8080)
                                             ├─ Position = Fahrplan + Verspätung, entlang Strecke
                                             └─ /api/vehicles, /api/trip/…, /api/status, Weboberfläche
```

Es gibt **keine offenen GPS-Positionen** der Züge. Die Position wird aus Fahrplan und gemeldeter
Verspätung berechnet und auf den Streckenverlauf gelegt.

Beide Fahrpläne enthalten grenzüberschreitende Züge. Damit sie nicht doppelt erscheinen, zeigt der
Schweizer Fahrplan nur Züge innerhalb der Schweiz und der deutsche nur Züge ausserhalb
(Landesgrenze aus OpenStreetMap, `trainpulse/ch_border.json`).

Wechsel des Fahrplans: Neue Fahrpläne erscheinen Montag und Donnerstag zwischen 9 und 10 Uhr,
die Echtzeitdaten stellen erst um 15 Uhr um. Der Server lädt deshalb immer den Fahrplan, auf den
sich die Echtzeitdaten gerade beziehen (`feed_version`), und schaltet automatisch mit um.

## Installation auf Proxmox (Docker)

TrainPulse läuft als zwei Docker-Container aus demselben Image:
`web` (Webserver, Port 8080) und `updater` (holt stündlich neue Fahrpläne und beim ersten Start
die Kartenkacheln). Alle Daten liegen im Ordner `data/` neben der `compose.yaml`.

1. **Container anlegen** (Proxmox-Oberfläche → *Create CT*):
   Debian 12 oder 13 Template, unprivileged, 2 Kerne, **4 GB RAM** (pfaedle braucht beim
   Aufbereiten bis ~2 GB, der Server ~1 GB), **30 GB Disk** (Kartenkacheln ~4,5 GB, beim
   monatlichen OSM-Update kurzzeitig ~5 GB Download für Deutschland), Netz per DHCP.
   Unter *Options → Features* **Nesting** und **keyctl** aktivieren – ohne das läuft Docker
   im LXC nicht.
2. **Installieren** (im Container als root):
   ```bash
   apt install -y git
   git clone https://git.scarriffle.com/Scarriffle/Trainpulse.git
   bash Trainpulse/deploy/install.sh
   ```
   Das Skript installiert Docker, falls es fehlt, baut das Image und startet beide Container.
   Der erste Start dauert ca. 30–45 Minuten: Kartenkacheln (~4,5 GB) und OpenStreetMap für
   Deutschland (~5 GB) herunterladen, dann beide Fahrpläne aufbereiten.
3. **Echtzeit freischalten:** Auf <https://api-manager.opentransportdata.swiss> registrieren,
   eine Applikation anlegen, das Produkt *GTFS-RT* abonnieren und den API-Key in
   `Trainpulse/.env` bei `TRAINPULSE_RT_KEY=` eintragen. Dann `docker compose up -d`.

Danach ist die Karte unter `http://<ip>:8080` erreichbar. Für den Zugriff von aussen einfach
hinter deinen bestehenden Reverse Proxy hängen.

**Update:** `git pull && bash deploy/install.sh` – baut das Image neu, Daten bleiben.

## Nützliche Befehle (im Ordner `Trainpulse`)

| Was | Befehl |
|---|---|
| Status | `curl localhost:8080/api/status` |
| Logs Webserver | `docker compose logs -f web` |
| Logs Fahrplan-Update | `docker compose logs -f updater` |
| Fahrplan sofort neu aufbereiten | `docker compose exec updater python -m trainpulse.prepare --source de --force` (oder `ch`) |
| Selbsttest | `docker compose exec web python tests/test_core.py` |
| Stoppen / Starten | `docker compose down` / `docker compose up -d` |

## Datenquellen und Lizenzen

Die Hinweise erscheinen unten rechts auf der Karte.

- Fahrplan & Echtzeit Schweiz: [opentransportdata.swiss](https://opentransportdata.swiss) (Quellenangabe Pflicht)
- Fahrplan Deutschland: [gtfs.de](https://gtfs.de), Daten von DELFI e.V. (CC BY 4.0)
- Echtzeit Deutschland: [gtfs.de](https://gtfs.de/de/realtime/) (CC BY-SA 4.0, Beta, Abdeckung je nach Region)
- Karte: © OpenStreetMap-Mitwirkende (ODbL), Kacheln von [Protomaps](https://protomaps.com)
- Streckenverläufe: berechnet mit [pfaedle](https://github.com/ad-freiburg/pfaedle) aus OpenStreetMap-Daten (ODbL)
- Satellit Schweiz: © swisstopo (frei, Quellenangabe)
- Satellit ausserhalb: Sentinel-2 cloudless 2024 von EOX – **nur nicht-kommerziell** frei

## Bekannte Grenzen

- Nur Bahn. Busse, Trams und U-Bahnen sind im Fahrplan, werden aber noch herausgefiltert.
- Züge des Schweizer Fahrplans im übrigen Ausland (z. B. Tirano, Domodossola, Frankreich)
  werden nicht angezeigt, sobald sie die Schweiz verlassen.
- Der kostenlose deutsche Fahrplan enthält keine Zugnummern und kein Fahrtziel; angezeigt
  wird als Ziel der letzte Halt.
- Der deutsche Echtzeit-Feed ist ~6 MB gross (komprimiert). Bei einem Abruf pro Minute sind das
  rund 9 GB Datenverkehr pro Tag.
- Zwischen zwei Abfragen fahren die Züge auf gerader Linie; in engen Kurven schneiden sie
  für ein paar Sekunden minimal ab.
- Zusätzliche Fahrten, die nur in den Echtzeitdaten vorkommen (Extrazüge), fehlen.
- In der Nacht des Fahrplanwechsels (2. Sonntag im Dezember) fehlen bis zum nächsten
  stündlichen Lauf die Züge.