[PHP] Coördinaten uitrekenen aan de hand van tijden

[Xanland]

Dag GoT'ters,

Op dit moment loop ik bij mijzelf aardig vast om iets te realiseren waar mijn denkproces stopt. Wat ik wil realiseren is iets in de richting van een volgsysteem met betrekking tot het OV op kaarten van OpenStreetMap (nu: OSM).
Een dienstregeling van de betreffende lijn heb ik, alsmede een kaart en iets wat elke seconde een Ajax request uitvoert om de data/informatie op te halen. Een lijn rijd altijd van halte naar halte waar uiteraard haltetijden bij staan vermeld van hoelaat een lijn daar behoort te arriveren. Het punt waar ik compleet op vast loop is uitrekenen waar een lijn ongeveer zou moeten zijn.

Om eerlijk te zijn zou ik het totaal niet weten hoe dat zou werken. Laat staan dat ik weet dat ik qua zoekwoorden weet wat ik in zou moeten tikken. De gegevens die ik heb zijn namelijk; een tigtal coördinaten van de route (polyline); tijden van elke halte (statisch) en that's it. Hetgeen waar ik dus naar op zoek ben is iets waarbij ik kan uitreken waar een voertuig op welke seconde behoort te zijn. Dit klinkt in mijn ogen in de richting van een routeplanner, wat OSM naar ik weet niet heeft.

Wie kan mij wat zoekwoorden/-hints geven of mij uit mijn vreemde denkproces helpen? Want zeer geheid dat ik hier ergens flink verkeerd ga/denk!

[RobIII]

Als je de lengte van zo'n lijn weet en de vertrek- en aankomsttijd van de begin- en eindpunten dan kun je toch gewoon interpoleren? Je weet dat de rit X minuten (beter: seconden) duurt, de afstand tussen beginpint en eindpunt is Y. Dan is het toch geen rocketscience om voor tijdstip T te bepalen hoever je al op die afstand gevorderd bent (of: zou moeten zijn)?

Simpel voorbeeld:

Halte A tijd: 12:30
Halte B tijd: 12:35
Afstand tussen A en B: 4Km

Om 12:30.00 ben je bij A
Om 12:30.01 ben je op 1s * (4000m / (5 * 60)) = 13.33m van A
Om 12.30.02 ben je op 2s * (4000m / (5 * 60)) = 16.66m van A
...
Om 12.34.59 ben je op 299s * (4000m / (5 * 60)) = 3986,66m van A
Om 12.35.00 ben je bij B

Eventueel reken je per halte nog een bepaalde "wachttijd" mee van (zeg) 30 seconden(?) maar dat is een ander verhaal.

[Voor 39% gewijzigd door RobIII op 04-11-2012 23:00]

[Gomez12]

Wat wil je precies hebben?

Want in een lineare vogelvlucht is dit heel simpel te doen, zoek de laatste vertrektijd voor nu op, zoek de eerste aankomsttijd na nu op en bereken op welk percentage van die tijd je nu zit.
Trek een rechte lijn tussen die coordinaten en x percentage van die lijn zit je bus dan.

Enkel heb je dan nog niet waar de bus hoort te zijn, je hebt enkel maar waar de bus zou moeten zijn als hij in een rechte lijn reed, niet in langzamer rijdende stukjes tegen zou komen etc. etc. etc.

Wil je het ingewikkelder dan kan het wel, enkel moet je dan ook meer gegevens aanleveren.
Je moet dan bijv de exacte afstand weten die de bus rijdt in combinatie met wegsnelheden (en in combinatie met tijdsgebonden filedrukte etc).
Met behulp van die gegevens kan je dan meerdere tussenstops maken (bijv per snelheidswisseling) zodat je meer punten hebt waardoor je interpolatie preciezer wordt.

Maar houd wel in je achterhoofd dat dit soort dingen altijd een heel onnauwkeurige schatting zijn, vanwege het feit dat je actuele gegevens mist. Daarom geven bussen ook continu (of bij elke stop weet ik even niet meer) hun positie door, zodat er bijgesteld kan worden naar de actuele situatie.

Wordt er een straat op de bus-route opgebroken dan kan de bus deze week omrijden of een stuk afsnijden en jouw berekening heeft deze info niet.

[matthijsln]

Als je je OSM data met osm2pgsql in PostGIS hebt geladen kan je voor polylines de functie ST_Line_Interpolate_Point gebruiken.

[Xanland]

Kijk, ik ben alweer iets verder gekomen met mijn gedachten dankzij jullie.

Volgens mij komt het beter er op neer dat de formule: s = v * t deels van toepassing komt.
t = uiteraard de tijd tussen de 2 haltes
s = verschil tussen de halte-coördinaten langs de polyline. Alleen moet ik elke afstand in meters van tussen de coörds optellen. Alleen dan nog hopen dat de haltecoörds ook op die polyline liggen!
Aan de hand van v moet ik dan, volgens mij, eigenlijk zeggen dat de bus zoveel meter op die polyline op moet schuiven. Maar dan nog is de vraag, welke kant...!?

Kraam ik nu complete onzin uit of zit ik zeer in de goede richting?

[RobIII]

Xanland schreef op maandag 05 november 2012 @ 23:05:
Alleen dan nog hopen dat de haltecoörds ook op die polyline liggen!

Euh; dat is wel zo handig (maar anders kun je dat natuurlijk ook 'benaderen').

Xanland schreef op maandag 05 november 2012 @ 23:05:
Aan de hand van v moet ik dan, volgens mij, eigenlijk zeggen dat de bus zoveel meter op die polyline op moet schuiven.

Meter, millimeter, kilometer. Of een bepaald percentage van de totale afstand. Wat boeit het?

Xanland schreef op maandag 05 november 2012 @ 23:05:
Maar dan nog is de vraag, welke kant...!?

Euh, richting de halte waar de aankomsttijd na de aankomsttijd van de vorige halte ligt?

Xanland schreef op maandag 05 november 2012 @ 23:05:
Kraam ik nu complete onzin uit

Niet direct, maar ik heb wel 't idee dat je zelf niet héél erg hard nadenkt als ik zo'n vraag als "welke kant" lees...

[Xanland]

O-M-G. Wat ben ik een kluns inderdaad zeg, goddamn!!!

Volgens mij ben ik het gewoon te laat aan het maken, ben ook alweer 17 uur lang op. Had denk ik beter morgen weer kunnen posten.

Damn Xanland.........

[Gomez12]

Welke kant op dat weet je toch aan de hand van je busschema. Ene kant is vertrekpunt, andere kant is eindpunt.

Persoonlijk zou ik (als het slechts om een beperkt aantal bussen gaat) helemaal niet met een polyline beginnen, maar die polyline lekker opdelen in tig kleinere lijnen en dan per lijntje het uitrekenen, het is waarschijnlijk tig keer trager (maar op enkele bussen maakt het geen barst uit) maar ook tig keer minder complex.

Ik bedoel kan je wel direct een polyline op Openstreetmap tekenen?

[Xanland]

Zoals ik al zei inderdaad, domste vraag ooit. _0-

Via OpenLayers is het mogelijk om op een zelf-ingelade OpenStreetMap polylines te tekenen. Die polylines heb ik ook al, via de site van de vervoerder, en staan er ook al op. Nu alleen nog een verschuivend busje eroverheen...

[pedorus]

Het lijkt me dat je die polyline los tekent, hoewel integreren in de tiles eigenlijk mooier is. Idealiter hou je ook rekening met het optrekken en stoppen van de voertuigen. Wat je dan krijgt is ongeveer gelijk aan de volgende website:

http://kubus.mailspool.nl/spoorkaart/

[Xanland]

Klopt, daar heb ik het ook deels van, maar met buslijnen worden het er wat veel - dus wordt weer beperkt op zoomniveau enzovoort.

Mijn laatste punt is inderdaad om actuele vertraging toe te voegen, maar dat hangt af van het feit of de betreffende vervoerder die data vrijgeeft. Dat doen ze wel op hun eigen website, of het gescraped mag worden is een tweede, maar wordt verder nog niet geöpenbaard. Voor mijzelf is het tevens gewoon een interessant leerproject.

[Gomez12]

Het moeilijke met bussen is dat je niet de vertragingsdata hebt (die heeft over het algemeen de busmaatschappij nog niet eens).

Ik bedoel als ik ga rellen in de bus tussen 2 haltes kan de chauffeur de bus stilzetten en 5 minuten gaan wachten tot ik van boord ga. Die info heb jij niet.
Of als er een groep bejaarden aan boord wil gaan en de chauffeur 10 minuten bezig is met iedereen inchecken dan heb jij die data niet.
Of als er niemand staat en de bus gewoon doorrijdt ipv te stoppen (1 minuut wachten) en weer te starten.

Wil je het een beetje kloppend hebben dan zou je iets moeten doen van enkel tijdshaltes pakken en geen tussengelegen haltes, maarja als de chauffeur snel naar huis wil dan is er een kans dat hij ook de tijdhaltes negeert.

Alternatief is dat je het niet van de dienstregeling af gaat halen (uitermate onbetrouwbaar) maar van bijv :
- openov.nl
- http://ovapi.nl/
Geen idee hoe snel / betrouwbaar die zijn, maar ze waren de eerste links onder google : openbaar vervoer api (eigenlijk dacht ik dat google zoiets had gekregen en daar zocht ik info van, maar deze stonden bovenaan )

Nu ik er eigenlijk over zit na te denken kan je het ook heel simpel aanpakken met een dubbele mashup van google maps en de ovapi.
- Laat google maps een route plannen met bijv de auto (hopelijk heb je geen buslanen waar je het wilt toepassen ) tussen bushalte a en bushalte b dan krijg je daar de afstand en de reistijd vandaan.
- Via ovapi kan je de geschatte aankomsttijd en de geschatte reisduur berekenen en de nog te doen reistijd.
- Leg de ovapi data over de google maps data en je weet waar je ongeveer momenteel zit.
- Waar je zit en hoe je bij de volgende bushalte moet komen kan je dan weer voeren aan google maps / openstreetmap en vanaf daar kan je bus incrementeel gaan verschuiven nav tijd + mogelijke wijzigingen op ovapi.nl

Dan doen google/ovapi het zware werk voor je en als bijv google rekening houdt met files (geen idee, maar anders kan je wellicht een andere bron erbij zoeken) kan je hem weer verder gaan verfijnen.

Busschemas zijn slechts een extreme benadering, met een api heb je kans op veel actuelere data.

[zzattack]

Mooie zou zijn als je een trace hebt van een goede rit, want dan kun je interpoleren tussen punten waarvan je weet dat niet alleen de positie maar ook de verstreken tijd goed zijn. Hiermee kun je hele aardige reconstructie doen. Ter illustratie: ik heb zelf eens een soortgelijk projectje gedaan. GPS data gelogd in canyons was erg brak doordat er weinig sats ontvangen werden. Het slechte deel van de route werd in Google Earth overgetrokken, en als .kmz file geexporteerd. Ik zoek nu het punt in de trace waar de kwaliteit slecht wordt, en zoek het dichtsbijzijnde punt in het traject in de .kmz. Helaas was hierbij geen tijdsinformatie beschikbaar, dus de snelheid over het gereconstrueerde traject was constant. Dat hoeft natuurlijk niet als je een goede log hebt om er naast te leggen. Je weet van tevoren waar de log weer goed wordt, en je kunt ook bij dit punt het dichtsbijzijnde punt in de goede log vinden, alles daartussenin kun je interpoleren in zowel tijd als positie.

[matthijsln]

Nog ter aanvulling over PostGIS nav bovenstaande: Als je niet linear wilt interpoleren kan je bij elke vertex van je polyline een measure opnemen waarin je bijvoorbeeld het aantal seconden na vertrek opslaat. Dan kan je met de functie ST_Locate_Along_Measure het punt op het traject krijgen op een gegeven aantal secondes na vertrek. Dit resultaat is via WKT direct door OpenLayers weer te geven.

Bijvoorbeeld een bus rijdt in een vierkant van 10 x 10 en doet over alle zijdes 1 seconde behalve de laatste waarover de bus 2 secondes doet. Je lijn wordt dan als volgt:

SQL:

select ST_GeomFromEWKT('LINESTRINGM(0 0 0, 0 10 1, 10 10 2, 10 0 3, 0 0 5)');

dus: LINESTRINGM(<x0> <y0> <seconden_na_vertrek0>, <x1> <y1> <seconden_na_vertrek1>, etc)

Als je de positie wilt weten op de helft, dus na 2,5 seconden:

code:

# select ST_AsText(ST_Locate_Along_Measure(ST_GeomFromEWKT('LINESTRINGM(0 0 0, 0 10 1, 10 10 2, 10 0 3, 0 0 5)'),2.5));
  st_astext  
-------------
 POINT(10 5)