Category Archives: Website

Gepruts in Son

Ik kan de schuld niet aan de kaart geven want die was voor iedereen het zelfde. Het weer dan? Ik liep nog droog, terwijl lopers vóór mijn door hoosbuien en onweer moesten. En iedereen (die omloop 1 deed) had dezelfde route. Nee, het gepruts was volledig mijnerzijds.

Welk gepruts? Geen foute of vergeten posten dit keer. Maar onverantwoord oriënteren. Ik probeerde op hoogtelijnen te lopen, maar tussen al het gebladerte waardoor het gezichtsveld bij een meter of tien ophield, waren die moeilijk te zien. Toch lagen de meeste posten zo dat dat de enige optie was. Meer over paden lopen was gezien de route ook niet veel gunstiger. Of veiliger. Nee, het was een uiterst pittige baan op een redelijk pittige kaart in een bos dat in een extreem pittige toestand verkeerde.

Maar een lichtpuntje: mijn enkel heeft het gehouden. Misschien dank zij mijn nieuwe VJ Integrator High’s, een paar schoenen met hoge schacht, en een ingenieus scharnier waardoor ze heel normaal lopen, maar toch zijwaartse bewegingen fixeren. En dat was geen overbodige luxe in deze jungle, waarin ik vaak niet kon zien waar ik mijn eigen voeten neerzette, terwijl het vol lag met kreupelhout, losse takken, en stronken. En dan waren de bramen op dit moment van het jaar nog niet op volle sterkte.

Maar goed, ik moet wat verbeteren, want als ik naar de resultaten van de anderen kijk, liep ik zwaar onder gemiddeld. Mijn splits springen als een bezetene op en neer: als ik een stukje goed liep, had ik de 4e á 7e tijd, maar de ander helft van de posten was ik gemiddeld zo’n 20e.

Opvallend is dat ik bij het ophalen van 10 van de posten, in het schemerdonker, veelal direct naar de juiste plek liep. Niet omdat ik er al geweest was, maar omdat ik een beter plan had.

Wat me verder opviel was dat het vaak veel beter werkte om gewoon nauwkeurig een kompas peiling te maken, en de afstand te schatten, dan kenmerken op de kaart terug te zoeken in het landschap, en zo te oriënteren.

Niet zelden interpreteerde ik een verlaging als heuvel, omdat het hoogtestreepje half schuil ging achter de paarse route-lijn op de kaart. Dat moet toch beter, of anders, kunnen; iets waardoor je in één oogopslag ziet wat omhoog is en wat omlaag. Maar ja, ieder had dezelfde kaart, dus ook op dat punt stond ik er niet slechter voor.

Nee, ik moet maar eens goed informeren hoe anderen dit deden: deze loop in dit bos. Wat doe ik fout? Wat het resultaat zint me niet.

Of zou ik gewoon niet uitgeslapen genoeg zijn geweest? En om verzwikkende enkels te voorkomen te veel naar de ondergrond gekeken hebben in plaats van naar de omgeving? Het zou zo maar kunnen.

Missers

Een paar voorbeeldjes van hoe het niet moet:

20160601_Son_01Ik startte iets te snel. Els een olifant die de porseleinkast binnen dendert. Door de dichte struiken miste ik de verhoging met de put waar de post stond, en vond een andere verhoging, iets noordelijker (rechts van 1 op de kaart). Ik corrigeerde door door te lopen naar het pad en te heroriënteren. Maar de trend voor de rest van de race was gezet. Resultaat: het gevoel tijd in te moeten halen, nog sneller lopen, en nog meer fouten. Ik had meteen beter moeten weten: dit wordt een lastige route, en dus uiterste voorzichtig te werkt gaan; zekerheid voor alles.


Van 5 naar 6 ging ook niet helemaal volgens plan. Als aanvalspunt koos ik het bankje links van het pad, liep recht op de post af, maar miste. Lastig om afstand te schatten als je door een jungle van groen ploetert, en zo miste ik de paden die ik als stoplijn had gedacht te gebruiken. Het pad waar ik verderop op terechtkwam voldeed niet aan de verwachtingen, maar ik volgde het toch maar. Veeeel te ver! De T-splitsing (vlak bij de post) bleek een 4-sprong, en dus ging ik heroriënteren. Zo kwam de post weer binnen bereik, maar wel met ruim 4 minuten vertraging.
20160601_Son_36En nu van 35 naar 36: Het begon al met het missen van een splitsing, maar door de vorm en richting van de paden had ik dat snel door. Vervolgens had ik nogal wat moeite met het vinden van de juiste doorgang naar de post. Alle hobbels leken op elkaar. het werd meer een loterij…

Correcting splits

Last weekend, during the ROM 2013, a couple of SI-controls were out of sync. The overall times were correct, but for a few courses, the ones comprising controls 138, 148, and 163, the Splitsbrowser graphs looked awful.

I looked at the data sources (the line that looks like <PARAM NAME="src" VALUE=eventdata.php?eventId=6336>), and downloaded the file (after pasting the base-url http://www.splitsbrowser.org.uk/ in front of it.

Then, I inflated the file, which was compressed in gzip-format, using the 7-zip program, and looked at the contents.

I noticed that for some controls, the split-times were not monotonously increasing:

Jan-Gerard Van der T  [138:19]  87:11  02:03  03:21  07:39  09:49  12:20  18:23  20:31  21:25  23:23  28:46 139:29  34:23  37:28  40:09  43:54  46:19  -----  50:35  52:08  55:45  61:09  65:05 187:47  69:41  71:27  73:37  75:28  79:19  81:53  83:19  85:36  86:51  87:11

I found out that SI works a bit different than EMIT: the clock is in the control, and not in the badge, which means that the registered times may vary from control to control. It only works when all controls were synchronized, and that was not the case here.

But, no problem, I could correct the data file for that, if I would know the offset, how much the specific controls were off.

First, I looked at all the results, of all the different courses, and found in total three controls that consequently gave the wrong reading. Then, for the controls in my course, course 1, I looked at my GPS tracklogger data, and noted the difference in time between the wrong controls and the previous, or subsequent ones. I subtracted that difference from the time difference in the Splitsbrowser data files, and the result was the offset, for each of the controls.

This worked at least for 138 and 148. For 163, which was not in my course, and of which I therefore had no time information, I looked at the variation time difference between checking 163 and the previous, and the next control, and assumed that the ratio between the relative standard deviation of the leg time for the leg before and after it, would correspond to the ratio in distance, and thus in time. Thereby, I estimated what the offset would be.

Then, assuming an offset for all three controls, and with help of a couple of lines of Matlab code, I processed the data files, and uploaded them to my server.

So now, while the ROM’13 organization may upload the final results to the official site, you can enjoy a proper Splitsbrowser results page, on my own jgeo.nl-blogserver:

STAGE 1, March 9th, Vrachelse heide.

STAGE 2, March 10th, ‘t Zand.

The original Splitsbrowser pages can be found here: Stage 1, and Stage 3.

By the way, it is interesting to observe the time-spread in split times, or asynchronicity of the SI-clocks, by comparing the GPS-log speeds at the controls, for both an SI-timed- and an EMIT-timed event:

left: SI: the controls are timed about +/-3 seconds accurate. right: EMIT shows obviously a better correlation.

 

Overlay maps: the browser does it all!

I created something similar before, but I simplified the code a bit, and the result is still exciting. I put some JavaScrtipting in my weblog, to overlay maps with each other. The result you can see on this blog entry from a past training, when we had to draw our own map, and my latest post about the Midwinterrun, where I overlayed an ancient map we got with the current topographic map.

The fun is that you can change the opacity of the different layers. In the first example, you can change the view to the map of the different runners, with and without the real, complete orienteering map underneath, or with the map semi-transparent.

In the second example, you can hover with your mouse over a slider, that changed the opacity-ratio of the two different maps.

It is nice to see that some features in the landscape still remain visible, while others have completely gone. And it is remarkable that some features were apparenty not correctly mapped, one-and-a-half century ago, as they have not moved, for sure, in the mean time, but are shown on the map on a significantly deviating location. I tend to believe that the present map is correct.

The JavaScript code is shown below:
<p><a name="overlay"></a>nieuwe kaart <span id="slider"></span> → oude kaart<br />
(ga met je muis over het balkje om de kaart te wisselen)</p>
<div id="kaarten" style="position: relative;">
 <a href="//jgeo.nl/o/wp-uploads/jgeo.nl/2013/01/oude_kaart.jpg">
  <img id="overlay_oud" style="position: absolute; left: 0pt;" alt="" src="//jgeo.nl/o/wp-uploads/jgeo.nl/2013/01/oude_kaart.jpg" width="640" height="533" />
 </a>
</div>
<p>
 <a href="//jgeo.nl/o/wp-uploads/jgeo.nl/2013/01/nieuwe_kaart.jpg">
  <img id="overlay_nieuw" alt="" src="//jgeo.nl/o/wp-uploads/jgeo.nl/2013/01/nieuwe_kaart.jpg" width="640" height="533" />
 </a>
 <br />
 <script type='text/javascript'>
/* <![CDATA[ */
//gebruik geen lege regels want die worden als paragraph tag aangemerkt door de editor 
  var max=20;
  for (var i=0; i<=max; i++) { 
    jQuery("#slider").append("<span id='sliderstep"+i+"'>&equiv;</span>"); 
  };
  jQuery("[id*=sliderstep]").hover(function () { 
    jQuery("#overlay_oud").fadeTo(0,parseFloat(jQuery(this).attr('id').match(/[0-9]+/))/max); 
  });
  jQuery("#overlay_oud").fadeTo("slow", 1);
/* ]]&gt; */
 </script>
</p>

I first create overlaying images, in the plain HTML code. With the style setting, I ensure they overlap. The images should all have the same pixel-size. Just above them, I placed a placeholder for the slider.

Then, I use a bit of JavaScript to create the actual slider, and the handles that change the opacity of the image layers.

Finally, I select which image is shown initially.

Het klopt! De halve lijkt inderdaad 21097,5 meter…

Morgen de Halve proeflopen. Om alvast te checken of het parcours een beetje klopt heb ik het maar eens op RunnerMaps en GPSies ingetekend. Dan kan je heel mooi de totale afstand meten. En wat blijkt: het komt inderdaad aardig uit. Wat niet wegneemt dat ik wat heb moeten schuiven met de start en finish, en wat bochtjes al dan niet scherper of ruimer moest nemen. Meer eerder het eerste dan het laatste.

De resultaten kan je via deze links op Runnermaps en GPSies zien. Of zelfs via deze QR-tag. Handig is de optie om de route vervolgens naar je GPS horloge te sturen, en daarbij jou streeftijd in te vullen. Start je die route (“course”) dan bij het lopen, dan kan je zelfs zien hoeveel je voor of achter loopt ten opzichte van een virtuele loper die precies loopt zoals je gepland had.

En het is heel motiverend, kan ik je uit eigen ervaring vertellen, om dat fictieve poppetje tientallen of honderden meters achter je te laten.

Maar ik moet nog wel wat dingen proberen. Zo wil hij nog wel eens gekke dingen doen als je niet helemaal op het zelfde punt start. Of wanneer je van een geplande route afwijkt (wat bij een wedstrijd niet heel waarschijnlijk is). En hoe hij met weggevallen signalen om gaat (zoals bij het passeren van tunnels). Maar ook wat er gebeurt als je, zoals morgen, niet bij de start start maar ergens anders op de ronde. We zullen zien. In elk geval is het handiger dit te bekijken dan pas over twee weken, als het tijd is voor het echte werk.

Maar goed, even terug naar het getekende parcours. Één ding is zeker: de route op de officiële site klopt niet. Net als vorig jaar trouwens. De route gaat niet over de Bilderdijklaan maar over de Jan Smitzlaan. Op zijn zachts gezegd heel lullig, als er 300 meter voor de finish ineens 190 meter bij blijkt te komen. Maar, net als vorig jaar overigens, kloppen op de officiële kaart de tussen-afstanden totaal niet. Vergelijk deze kaart van marathoneindhoven.nl maar eens met deze op GPSies. En nu maar hopen dat de mensen die de borden langs het parcours neerzetten ook mijn weblog lezen, anders kan je maar beter een eigen kaart meenemen.

oO-games (online-Orienteering)

I planned to add some home-made JavaScript Orienteering games to my blog. Sounds fun to make, and to play. Something with maps, where you have to find the location of a tiny snapshot of the map. And a puzzel, where you have to select the control description icons for a certain spot on the map. And a map where you have to draw what you think is the best route, and afterwards, get a simulated time based on the underlying map colors. Or a jigsaw puzzle of a map. Like this:


But first, I decided to look what is already out there. I have bought once Catching Features, which is sort of the complete orienteering experience on your PC. A lot of fun when you can’t go out for some reason. It pretty well resembles the stress when orienteering for real. But here appear to be many more tools.
I wish I had an Android smartphone, then I could play Virtual Orienteering, or pCM Orienteering.

But there are other Orienteering computer games as well. Have a look for example at:

  • Webroute: Here you can draw what you think is the best route, on a map, and compare with others. Seems to be used a lot, but not by many Dutch people.
  • Control Descriptions Quiz, where you can exercise your knowledge on control symbols.
  • Map reading Quiz, where you can rehearse with map features.
  • On ARDF-games, you can play with virtual ARDF receivers, a kind of orienteering where you use radio waves to locate the controls.
  • This one is also fun: you have to watch the head-camera video, and locate where you are on the map. Sounds like a fun idea for a Geocache.
  • Memory training: this one shows you a map for some seconds, and then you have to run the same route, along many crossings, to get to the end point, by what you remember of the map.
  • And if you like to play online puzzels, with Orienteering as theme, then this section of the Hamok Orienteering Handbook could be interesting.

But of course, the real game is outside. I found some good sites with training exercises, some of which you can do on your own when there is no nearby race, or no training. For example here, on O-training.net, or this huge list, also from the Hamok Handbook.

Although there are not many regional races nearby during the summer season, there seems to be enough to do. So let’s quit writing my blog, and start playing.

More links:

 

RSS feeds van NOLB en VVO kalenders op mijn site

Het was wat hackwerk, maar ik je kan nu ook de eerstvolgende wedstrijden op mijn weblog zien staan, in de balk aan de rechterkant. Scroll maar omlaag naar Wedstrijdkalender NL en België.

Lastig was het wel een beetje, omdat de Nederlandse kalender alleen maar ondersteboven wilde afbeelden (dus de 5 wedstrijden het verst in de toekomst, maar niet die van komende maand). En de Belische site, van VVO, had geen RSS feed voor evenementen. Die heb ik dus maar zelf gemaakt, met en PHP scriptje dat zo nu en dan naar hun site kijkt.

Maar het werkt. Ik ben weer trots op mijzelf. Hoeveel tijd ik hiermee wel niet uitspaar…

Oriënteringslopen of Oriëntatielopen?

PlOts bOtste Ondergetekende Onlangs Onverwacht Op Onderstaande Overweging:

Is het Oriënteringslopen of Oriëntatielopen?

Ik dacht altijd het eerste, maar ik kwam een flyer tegen, ik denk van de NOLB, waarop in rood-witte sierletters Oriënteringslopen staat. Prompt heb ik de titel van mijn weblog aangepast. Toch zat het nog niet lekker. Ik heb deze vraag dus maar op het I-OL.nl forum gepost. Er ontstond meteen een discussie. Nu, een paar maanden later, is deze wel uitgedenderd.

Koen schrijft:

Nederland gebruikt oriënteringslopen, België oriëntatielopen. Zelf geef ik ook de voorkeur aan de tweede. […]

Oriëntering zie ik vooral bij Defensie, geen idee waar die verschillen ooit ontstaan zijn!

In het Engels is het duidelijk; daar heet het orienteering (wat ook makkelijker typt, zonder ümlaut). Maar ook in Zweden en Noorwegen heet het orientering, zij het met één “e”. Op zich klinkt het dan logisch als het Nederlandse woord in navolging daarvan “oriëntering” zou zijn.

Maar ja, een woord is een woord, en het kan vele oorsprongen hebben. (Zo zal het je verbazen -dat deed het mij althans- waar de uitdrukking “dat is toch baanleggerij van lik-me-vestje” vandaan komt.) Misschien moeten we het daar zoeken.

Clemens schrijft:

In de beginjaren van de NOLB heeft het oriëntatielopen geheten. Ik ben geen specialist maar als ik het me goed herinner is oriëntatielopen niet correct Nederlands en heeft iemand uit de beginjaren van de NOLB dit destijds gewijzigd. OL is afgeleid van het werkwoord oriënteren.

Dat geeft houvast. Er is maar één werkwoord oriënteren. Maar tegelijkertijd zijn er wel twee zelfstandig (of zijn het zelfstandige?) naamwoorden  aan verbonden: oriëntatie en oriëntering. Dat maakt het lastig. En als je er dan weer een werkwoord van maakt door er -lopen achter te plakken, heb je dus twee mogelijkheden, oriënteringslopen en oriëntatielopen.

Als je de diverse online woordenboeken er op na sla (een mooi overzicht van diverse bronnen krijg je via www.encyclo.nl voor orientering en orientatie), zie je beide woorden oriëntering en oriëntatie voorkomen, maar net als op de site van de Nederlandse Taalunie, komt wel oriëntatieloop voor, maar niet oriënteringsloop. Terwijl de NOLB nu juist officieel de “Nederlandse Oriënteringsloop Bond” heet (en toch beide woorden op haar site regelmatig voorkomen, net als bij de andere verenigingen, trouwens).

De betekenis van de woorden oriëntering en oriëntatie is echter een beetje verschillend, volgens de woordenboeken:

  • oriëntering is het draaien of richten van iets, een rotatie uitvoeren (bijvoorbeeld het oriënteren van de kaart mbv. een kompas tov. het landschap); het zich-oriënteren; dus het doen
  • oriëntatie is het vermogen tot plaatsbepaling ten opzichte van de omgeving; de plaatsbepaling; het georiënteerd zijn

Maar heel duidelijk is het onderscheid niet. Beide woorden kunnen op zowel de relatieve plaatsbepaling, als de relatieve richting slaan. Zou het verschil dan zitten in de betekenis uitgang van het woord? Andere woorden die een vergelijkbare -tatie/-tering variant kennen zijn:

  • argumentatie/argumentering
  • facilitatie/facilitering
  • fragmentatie/fragmentering
  • implementatie/implementering
  • interpretatie/interpretering
  • limitatie/limitering
  • reglementatie/reglementering

Echter, deze hebben allemaal in beide gevallen dezelfde betekenis, waarbij moet worden opgemerkt dat de -tatie variant verreweg het meeste voorkomt. Een paar woorden hebben echter een verschillende betekenis afhankelijk van de uitgang:

In meer of mindere mate kan je hier, net als in orientatie/orientering, een zijn en een doen in zien. Maar het blijft een grijs gebied. Het helpt dus niet erg om naar andere woord-uitgangen te kijken.

Als je het zo leest doen we aan oriëntering, we bepalen onze plaats, en onderweg doen we af en toe aan oriëntering van de kaart of ons zelf. Dat laatste dan bij de minder bedrevenen (waaronder ik zelf) veelal stilstaand, waardoor oriënteringslopen dan even wat minder voorkomt (maar daar wordt aan gewerkt).

Het doel is daarentegen wel de oriëntatie van onszelf. Als je het goed doet ben je niet aan het oriënteren, maar houd je de oriëntatie van start tot de finish vast. En gaat het behalve om kunnen hardlopen ook om het vermogen tot plaatsbepaling: oriëntatie.

Oriëntatie is meer de essentie van de sport dan oriëntering.

Pragmatisch kan je stellen dat het er om gaat dat men weet wat er bedoeld wordt. En ik denk, net als Alfred op het forum, dat het Nederlandse oriënt/erings/atie/lopen al een stuk eenduidiger is dan het Engelse orienteering (zonder lopen). Dus waar hebben we het over? We mogen toch zelf bepalen hoe het heet wat we doen?

Het moois is nog Walters observatie:

Op Vlaams niveau (VVO) spreken we over “Vlaams Verbond voor Oriënteringssporten” terwijl dit op het nationale niveau (BVOS) “Belgisch Verbond voor Oriëntatiesporten” is.

In België hebben ze dus gewoon officieel de keus! Of promoveer je van oriëntatie- naar oriënteringsloper zodra je op nationaal niveau gaat presteren? Is oriëntering die zwarte band onder de oriëntatie?

Ten slotte kan je je afvragen wat wij als lopers nou eigenlijk zijn: Oriënteerders, Oriëntatielopers, Oriënteringslopers of Oriënteurs? Ik houd het bij Oriënteurs. Gewoon, omdat ik dat een mooi woord vind. En omdat het korter is dan hic-qui-scit-accedere-ad-propositum.

Eén keer, en je bent verkocht… (zo werkt het:)

Houd je van …

  • buiten bezig zijn
  • een intellectuele uitdaging
  • hardlopen
  • buiten de bekende paden denken
  • kaartlezen
  • bijzondere sporten
  • keuzes maken
  • gecalculeerde risico’s nemen
  • een amicale sfeer
  • ben je niet bang om vies te worden
  • ben je niet bang om te verdwalen

Probeer dan eens een Oriënteringsloop

  • dat kan vrijblijvend
  • het is goedkoop
  • je hebt weinig materiaal nodig (loopschoenen, -kleding en een kompas)
  • je hoeft geen lid te zijn
  • het gaat (in het begin) niet om snelheid
  • je kan individueel of samen meedoen
  • er is altijd iemand te vinden die uitleg wil geven

Hoe dat werkt?

  • Neem contact op
  • Doe mee aan een wedstrijd [NL] [B] of training
  • Je schrijft je ter plekke in
  • Zorg voor enige basiskennis
  • en enig basismateriaal (loopschoenen, -kleding en een kompas)
  • Je huurt een EMIT of SI voor de tijdregistratie
  • Soms kan je een kompas lenen/huren

En dan verder?

Na de 1e keer ben je verkocht, dan

  • wil je vaker meedoen
  • word je lid van een club
  • schaf je wat speciaal materiaal aan
  • vergroot je je kennis van de kaart en symbolen
  • ga je vaker trainen, alleen of met anderen
  • analyseer je je resultaten, met GPS, met anderen
  • verbeter je je techniek, qua routekeuze, routine, risico’s inschatten en beperken, looptechniek in divers terrein
  • begin je een weblog over je ervaringen

Kortom, volg dit eenvoudige stappenplan, en wissel je huidige sport in voor deze onbetwiste favoriet: Oriënteringslopen!

Bloggen in Nederlands of Engels, that’s the question…

Ik vraag me af of ik deze blog niet in het Engels moet schrijven. I wonder whether I should write this blog in English or in Dutch. Orienteering is an international sport, and the North is everywhere (roughly) the same. Orienteering is een internationale sport, mijn publiek is uiteraard groter als ik in het Engels schrijf. I have a bigger audience when I writing in English. Aan de andere kant, het leest voor Nederlanders en Belgen wel weer lekkerder als ik het in het Nederlands houd. On the other hand, for the Swedish, it would be better if I would not write in Swedish, since that wouldn’t be readable at all (given my Ikea-only vocabulary). De vraag is dus: wie is mijn publiek or who is my audience?

Wie is mijn publiek?


En omdat ik ook een deel voor mezelf schrijf, gewoon om mijn gedachten op papier te zetten, denk ik dat ik het bij Nederlands houd. However, the bigger the audience, the bigger the motivation to write.
Mee eens? Of niet? Laat dan een berichtje achter onderaan deze pagina. Want ik wil best voortaan Engels typen.
De Google Ads heb ik weer van mijn site gegooid: niemand klikte ze aan, en het werd er niet overzichtelijker op. Leuk om eens te proberen, maar je moet wel heel veel bezoekers trekken wil dat wat opleveren. Wel kreeg ik meer hits om mijn blog-site zo lang ik Google betaalde (50 euro gratis introductie krediet) voor het plaatsen van links op andere sites.

Hackerdehack

Herken je dit? Je hebt een GPS track, van een tracklogger (in .gpx formaat) of van je Garmin horloge (in .tcx formaat), maar er zitten geen splits in, omdat je niet bij elke post op het knopje hebt gedrukt. En de club gebruikt niet Winsplits in combinatie met die ene specifieke server waar Quickroute mee praat, dus je kan de splits niet automatisch in Quickroute krijgen.

Herkenbaar? Je zult handmatig de tijden in moeten voeren, door op de juiste plaatsen op de kaart te klikken.

Of je schrijft een klein programmatje in Matlab (of gebruikt mijn code) om de .tcx files te voorzien van de splits die je eenvoudig van de Slitsbrowser pagina haalt (de regel in de Results Table met jouw naam er voor; copy – paste).

Heb je geen Garmin .tcx file, maar een generieke .gpx file van een tracklogger, maak er dan eerst een .tcx file van met GPSbabel.
gpsbabel -t -i gpx -f dit_track_bestand.gpx -o gtrnctr,course=0 -F het_nieuwe_bestand.tcx

En zo heb ik bijvoorbeeld deze kaart van Hamont gemaakt, met de controls direct op de juiste plek.

Er zit een slimmigheidje in de functie om te detecteren hoeveel tijdverschil er tussen de GPS gegevens zit en de start. Mocht dat niet werken, knip dan handmatig tevoren het stuk van de track tot vlak voor de start, en vlak na de finish af.

Mochten ze in QuickRoute het inladen van SplitsBrowser files ondersteuen, dan zal het wel op het QuickRoute Forum te lezen zijn. En dat is wellicht ook de plaats om om deze feature te vragen. Hoe meer mensen het hier over hebben, hoe groter de kans.

function splits2tcx(in_file,splits)
% om een extra neutralisatie-post in mee te nemen die niet in de splits zat, voeg een
% +0:17 (of andere tijd) toe op de plaats. 
 
% gpsbabel = 'c:\localdata\bin\gpsbabel\gpsbabel.exe'
 
% CHECK various splits strings
 
force_tcx_conversion = 1; % force gpsbabel to convert tcx to tcx (to fix for example Android Garmin Uploader files)
if nargin support for %s files not yet implemented.\n',fe);
    end
    if nok
        error('err-&gt; conversion to .tcx file failed');
    else
        fprintf('done.\n'); % JHH
    end
end
 
fprintf('** acquiring splits **\n');
if nargin0) % absolute times
    if splits(1)~=splits(end)
        warning('I expected the total time (1st data point) to be equal to the finish time (last data point). Netralized leg compensation?');
    end
    splittimes = [0 splits(2:end)];
else % relative times
    splittimes = [0 cumsum(splits)];
end
 
fprintf('** using split times: "%s" **\n',reshape(strvcat(m2ms(splittimes'/60,1)',' '),1,[]));
 
fprintf('** reading tcx file: "%s" **\n',tcx_file);
t = []; tp = [];
d = []; dp = [];
ll = []; lp = [];
 
[fid,err] = fopen(tcx_file,'r');
if fid failed opening file "%s" for reading, with error: %s',tcx_file,err);
end
 
arm = 0;
while ~feof(fid)
    l = fgetl(fid);
    hms = sscanf(l,'%*[^&lt;]<time>%*[^T]T%d:%d:%dZ</time>');
    if ~isempty(hms)
        t(max(length(d),size(ll,1))+1) = [60*60 60 1]*hms;
        tp(max(length(d),size(ll,1))+1) = ftell(fid);
        arm = 1;
    else
        dm = sscanf(l,'%*[^&lt;]%f');
        if arm &amp;&amp; ~isempty(dm)
            d(length(t)) = dm;
            dp(length(t)) = ftell(fid);
            if length(d)&gt;length(t)
                l
            elseif length(d)&lt;length(t)
                l
            end
            arm = 0;
        else
            la = sscanf(l,'%*[^&lt;]%f');
            if arm &amp;&amp; ~isempty(la)
                ll(length(t),1) = la;
                lp(length(t)) = ftell(fid);
            else
                lo = sscanf(l,'%*[^&lt;]%f');
                if arm &amp;&amp; ~isempty(lo)
                    ll(length(t),2) = lo;
                else
                    ls = sscanf(l,'%*[^&lt;]');
                    if ~isempty(ls)
                        arm = 0;
                    end
                end
            end
        end
    end
end
if arm % last timepoint has no location or distance
    if ~isempty(d)
        t = t(1:length(d));
    elseif ~isempty(ll)
        t = t(1:size(ll,1));
    end
end
 
findmin = inline('min(find(a(:)==min(a(:))))','a');
if ~isempty(d)
    fprintf('%d timestamps; %d distances; %d splits; %d gaps\n',length(t),length(d),length(find(diff(t)==0)),length(find(diff(t)&gt;1)));
else
    fprintf('%d timestamps; %d distances; %d splits; %d gaps\n',length(t),length(ll),length(find(diff(t)==0)),length(find(diff(t)&gt;1)));
end
lapsplit = find(diff(t)==0);
t(lapsplit) = [];
ll(lapsplit,:) = [];
if ~isempty(d)
    d(lapsplit) = [];
    dd = diff(d);
else
    [x,y] = deg2utm(ll(:,1),ll(:,2));
    dd = sqrt(sum(diff([x y]).^2,2));
end
 
dd = dd(:).';
 
if 1
    %%
    dt = diff(t);
    if any(dt&gt;1)
        fprintf('missing track-points at: \n%s',sprintf('%d:%02d : %d [s]\n',[round(m2ms((t(find(diff(t)&gt;1))-t(1))/60)).';dt(dt&gt;1)]));
        %         if any(diff(t)&gt;2)
        %             error('only solves single missing points');
        %         end
        for ii = fliplr(find(dt&gt;1))
            dd(1:end+dt(ii)-1) = [dd(1:ii-1) repmat(dd(ii)/dt(ii),1,dt(ii)) dd(ii+1:end)];
        end
        t = t(1):t(end);
        %         t1(cumsum([1 (diff(t)&gt;1)+1])) = t;
        %         d1(cumsum([1 (diff(t)&gt;1)+1])) = dd;
        %         d1(find(~t1))   = d1(find(~t1)-1)/2;
        %         d1(find(~t1)-1) = d1(find(~t1));
        %         t1(~t1) = t1(find(~t1)-1);
    end
 
%     comb = repmat(round(splittimes),2,1)+repmat([1:2]',1,length(splittimes));
%     window(comb(:)) = 1;
%     xc = xcorr(window,dd);
%     those = length(xc)-length(dd)-[0:length(dd)-splittimes(end)];
%     xcdt = detrend(xc(those),'linear',ceil(length(those)/2));
%     %plot(xcdt)
%     offset = findmin(xcdt);
%     figure(12345);
%     s1=subplot(211);plot(dd);line(offset,0,'marker','o','color','r');line(offset+splittimes,0,'marker','s','color','g');
%     s2=subplot(212);plot(xc(those));line(offset,xc(those(offset)),'marker','o','color','r');
%     set(s2,'xlim',get(s1,'xlim'));
    %%
    m = 2;
    comb = repmat(round(splittimes),m,1)+repmat([1:m]',1,length(splittimes));
    window = [];
    window(comb(:)) = 1;
    if length(window)&gt;length(dd)
        dd = [zeros(1,2*(length(window)-length(dd))) dd zeros(1,2*(length(window)-length(dd)))];
    end
    xc = xcorr(window,dd);
    those = length(xc)-length(dd)-[0:length(dd)-splittimes(end)];
    xcdt = detrend(xc(those),'linear',ceil(length(those)/2));
    %plot(xcdt)
    offset = findmin(xcdt)+floor(m/2)
    figure(12345);
    s1=subplot(2,4,1:4);plot(dd*3600/1000);line(offset,0,'marker','o','color','r');line(offset+splittimes,0,'marker','s','color','g');
    s2=subplot(2,4,5:6);plot([1:length(those)],xc(those));line(offset-floor(m/2),xc(those(offset-floor(m/2))),'marker','o','color','r');
    n = 20;
    x=reshape(offset+repmat(0*splittimes(:)',2*n+2,1)+repmat([-n:n nan]',1,length(splittimes)),1,[]);
    y=reshape(offset+repmat(splittimes(:)',2*n+2,1)+repmat([-n:n nan]',1,length(splittimes)),1,[]);
    s3=subplot(2,4,[7 8]);plot(x,dd(min(max(y,1),length(dd))));line(offset,0,'marker','s','color','r');
    %%
else
    %%
    [b,a] = butter(2,0.9);
    dd = filtfilt(b,a,dd);
    for ii = 1:(t(end)-t(1))-splittimes(end)+1
        td(ii) = 0;
        ti = ii+(1:splittimes(end))-1;
        for jj = 1:length(splittimes)
            deze(jj) = findmin(abs((t(ti)-t(1))-splittimes(jj)));
            td(ii) = td(ii)+dd(deze(jj));
        end
    end
    offset = t(max(find(abs(td)==min(abs(td)))))-t(1);
    %%
end
 
s = sprintf('Estimated offset of GPS (nr of seconds the GPS was started before the splittimer): %0.1f [s]',offset);
fprintf('%s\n',s);
 
new_offset = inputdlg(strvcat(s,'Keep this value, or enter a different offset (based on the graphs):'),'Corect estimated offset',1,{sprintf('%0.1f',offset)});
drawnow;
if ~isempty(new_offset{1}), 
    if isempty(str2num(new_offset{1}))
        error('err-&gt; invalid value: "%s"',new_offset{1});
    end
    offset = str2num(new_offset{1});
    s3=subplot(2,4,[7 8]);
    line(offset,0,'marker','s','color','m');
end
 
 
t_sync = t-t(1)-offset;
for jj = 1:length(splittimes)
    splittimes_sync(jj) = t_sync(findmin(abs(t_sync-splittimes(jj))));
end
splittimes_abs = splittimes_sync+t(1)+offset;
 
fprintf('** finished reading tcx file **\n');
 
frewind(fid);
[fp,fn,fe] = fileparts(in_file);
outfile = fullfile(fp,[fn '_splits.tcx']);
fprintf('** writing output file: "%s" **\n',outfile);
fod = fopen(outfile,'w');
[fod,err] = fopen(outfile,'w');
if fod failed opening file "%s" for writing, with error: %s',outfile,err);
end
 
distance_offset = 0;
 
phase = 0;
% phases:
% 0 header
% 1 first track header, until first point to be included
% 2 first trackpoints being included
% 3 other trackpoints being included
% 4 buffering last point of current lap
% 5 obsolete lap header
% 6 last trackpoint writing
% 7 trackpoints after last trackpoint
% 8 trailer
 
trackpointbuffer = {};
lap = 0;
while ~feof(fid)
    l = fgets(fid);
 
    if phase==0
        lp = sscanf(l,'%*[^&lt;]&lt;Lap%s'); % StartTime=%s');
        if ~isempty(lp) &amp;&amp; phase==0
            phase = 1;
            % do not parse from here
        end
    else
        lp = sscanf(l,'%*[^&lt;]%c');
        if ~isempty(lp) &amp;&amp; phase&gt;0
            phase = 8;
            % do parse trailer from here
        else
            lp = sscanf(l,'%*[^&lt;]&lt;Creator%s'); if ~isempty(lp) &amp;&amp; phase&gt;0
                phase = 8;
                % do parse trailer from here
            end
        end
    end
 
    if any(phase==[2 3 4])
        lp = sscanf(l,'%*[^&lt;]%c');
        if ~isempty(lp)
            if any(phase==[2 3]) % not if phase is 4, since then already a lap was included here
                phase = 5;
                % do not parse from here, until next lap started
            elseif phase==4 % buffered, but continue including lap
                phase = 3; % continue writing; lap is OK here
                trackpointbuffer = {};
                lap = lap+1;
            end
        end
    end
 
    laptext = [0 0];
 
    if any(phase==[4 5 6])
        lp = sscanf(l,'%*[^&lt;]%c');
        if ~isempty(lp)
            if phase==6
                % last point passed, no output anymore except trailer
                phase = 7;
                fprintf(fod,l);
                l = '';
                laptext = [0 1];
            elseif phase==4
                % copying last trackpoint for new track
                % inlude lap split
                fprintf(fod,l);
                laptext = [1 1]; % implicitly include trackpointbuffer
            elseif phase==5
                % skip first trackpoint after lap, since it is identical
                phase = 3;
                l = '';
            end
        end
    end
 
    hms = sscanf(l,'%*[^&lt;]<time>%*[^T]T%d:%d:%dZ</time>');
    if ~isempty(hms)
        timestr = sscanf(l,'%*[^&lt;]<time>%[^Z]Z</time>');
        if [60*60 60 1]*hms&gt;=splittimes_abs(1) &amp;&amp; phase=splittimes_abs(end) &amp;&amp; phase=splittimes_abs(lap+1) &amp;&amp; phase%f');
        if ~isempty(lp)
            if phase==2
                distance_offset = lp;
            end
            l = sprintf('            %0.7f\n',lp-distance_offset);
        end
    end
 
    if laptext(2)
        fprintf(fod,'         \n');
        fprintf(fod,'       \n');
    end
    if laptext(1)
        lap = lap+1;
        fprintf(fod,'       \n',timestr);
        fprintf(fod,'         %0.7f\n',diff(splittimes_abs(lap+[0:1])));
        fprintf(fod,'         Active\n');
        fprintf(fod,'         Manual\n');
        fprintf(fod,'         \n');
        fprintf(fod,'           \n');
    end
    if phase==4
        if all(laptext)
            fprintf(fod,'%s',trackpointbuffer{:});
            trackpointbuffer = {};
            phase = 3;
        else
            trackpointbuffer{end+1} = l;
        end
    end
 
    if any(phase==[0 2 3 4 6 8])
        fprintf(fod,'%s',l);
    end
 
end
fclose(fod);
fclose(fid);
fclose('all');
 
fprintf('** finished successfully: splits were included in tcx file **\n');
 
 
 
 
function times = readtimes(in)
times = [];
offset = 0;
for ii = 1:length(in)
    this = sscanf(in{ii},'%d%*[.:]%d%*[.:]%d');
    if length(this)==2
        if in{ii}(1)=='+'
            offset = offset+[60 1]*this;
            times(end+1) = times(end)+offset;
        else
            times(end+1) = [60 1]*this+offset;
        end
    elseif length(this)==3
        if in{ii}(1)=='+'
            offset = offset+[60*60 60 1]*this;
            times(end+1) = times(end)+offset;
        else
            times(end+1) = [60*60 60 1]*this+offset;
        end
    end
end
 
 
% function strs = split(str,sep,include,num)
% % SPLIT - split a string in substrings by separator
% matches = [1 strfind(str,sep)+1 length(str)+2];
% for ii = 1:length(matches)-1
%     strs{ii} = str(matches(ii)+(ii&gt;1)*(size(sep,2)-1):matches(ii+1)-2);
% end
 
 
 
function  [x,y,utmzone] = deg2utm(Lat,Lon)
% -------------------------------------------------------------------------
% [x,y,utmzone] = deg2utm(Lat,Lon)
%
% Description: Function to convert lat/lon vectors into UTM coordinates (WGS84).
% Some code has been extracted from UTM.m function by Gabriel Ruiz Martinez.
%
% Inputs:
%    Lat: Latitude vector.   Degrees.  +ddd.ddddd  WGS84
%    Lon: Longitude vector.  Degrees.  +ddd.ddddd  WGS84
%
% Outputs:
%    x, y , utmzone.   See example
%
% Example 1:
%    Lat=[40.3154333; 46.283900; 37.577833; 28.645650; 38.855550; 25.061783];
%    Lon=[-3.4857166; 7.8012333; -119.95525; -17.759533; -94.7990166; 121.640266];
%    [x,y,utmzone] = deg2utm(Lat,Lon);
%    fprintf('%7.0f ',x)
%       458731  407653  239027  230253  343898  362850
%    fprintf('%7.0f ',y)
%      4462881 5126290 4163083 3171843 4302285 2772478
%    utmzone =
%       30 T
%       32 T
%       11 S
%       28 R
%       15 S
%       51 R
%
% Example 2: If you have Lat/Lon coordinates in Degrees, Minutes and Seconds
%    LatDMS=[40 18 55.56; 46 17 2.04];
%    LonDMS=[-3 29  8.58;  7 48 4.44];
%    Lat=dms2deg(mat2dms(LatDMS)); %convert into degrees
%    Lon=dms2deg(mat2dms(LonDMS)); %convert into degrees
%    [x,y,utmzone] = deg2utm(Lat,Lon)
%
% Author: 
%   Rafael Palacios
%   Universidad Pontificia Comillas
%   Madrid, Spain
% Version: Apr/06, Jun/06, Aug/06, Aug/06
% Aug/06: fixed a problem (found by Rodolphe Dewarrat) related to southern 
%    hemisphere coordinates. 
% Aug/06: corrected m-Lint warnings
%-------------------------------------------------------------------------
 
% Argument checking
%
error(nargchk(2, 2, nargin));  %2 arguments required
n1=length(Lat);
n2=length(Lon);
if (n1~=n2)
   error('Lat and Lon vectors should have the same length');
end
 
 
% Memory pre-allocation
%
x=zeros(n1,1);
y=zeros(n1,1);
utmzone(n1,:)='60 X';
 
% Main Loop
%
for i=1:n1
   la=Lat(i);
   lo=Lon(i);
 
   sa = 6378137.000000 ; sb = 6356752.314245;
 
   %e = ( ( ( sa ^ 2 ) - ( sb ^ 2 ) ) ^ 0.5 ) / sa;
   e2 = ( ( ( sa ^ 2 ) - ( sb ^ 2 ) ) ^ 0.5 ) / sb;
   e2cuadrada = e2 ^ 2;
   c = ( sa ^ 2 ) / sb;
   %alpha = ( sa - sb ) / sa;             %f
   %ablandamiento = 1 / alpha;   % 1/f
 
   lat = la * ( pi / 180 );
   lon = lo * ( pi / 180 );
 
   Huso = fix( ( lo / 6 ) + 31);
   S = ( ( Huso * 6 ) - 183 );
   deltaS = lon - ( S * ( pi / 180 ) );
 
   if (la&lt;-72), Letra='C';
   elseif (la&lt;-64), Letra='D';
   elseif (la&lt;-56), Letra='E';
   elseif (la&lt;-48), Letra='F';
   elseif (la&lt;-40), Letra='G';
   elseif (la&lt;-32), Letra='H';
   elseif (la&lt;-24), Letra='J';
   elseif (la&lt;-16), Letra='K';
   elseif (la&lt;-8), Letra='L';
   elseif (la&lt;0), Letra='M';
   elseif (la&lt;8), Letra='N';
   elseif (la&lt;16), Letra='P';
   elseif (la&lt;24), Letra='Q';
   elseif (la&lt;32), Letra='R';
   elseif (la&lt;40), Letra='S';
   elseif (la&lt;48), Letra='T';
   elseif (la&lt;56), Letra='U';
   elseif (la&lt;64), Letra='V';
   elseif (la&lt;72), Letra='W';
   else Letra='X';
   end
 
   a = cos(lat) * sin(deltaS);
   epsilon = 0.5 * log( ( 1 +  a) / ( 1 - a ) );
   nu = atan( tan(lat) / cos(deltaS) ) - lat;
   v = ( c / ( ( 1 + ( e2cuadrada * ( cos(lat) ) ^ 2 ) ) ) ^ 0.5 ) * 0.9996;
   ta = ( e2cuadrada / 2 ) * epsilon ^ 2 * ( cos(lat) ) ^ 2;
   a1 = sin( 2 * lat );
   a2 = a1 * ( cos(lat) ) ^ 2;
   j2 = lat + ( a1 / 2 );
   j4 = ( ( 3 * j2 ) + a2 ) / 4;
   j6 = ( ( 5 * j4 ) + ( a2 * ( cos(lat) ) ^ 2) ) / 3;
   alfa = ( 3 / 4 ) * e2cuadrada;
   beta = ( 5 / 3 ) * alfa ^ 2;
   gama = ( 35 / 27 ) * alfa ^ 3;
   Bm = 0.9996 * c * ( lat - alfa * j2 + beta * j4 - gama * j6 );
   xx = epsilon * v * ( 1 + ( ta / 3 ) ) + 500000;
   yy = nu * v * ( 1 + ta ) + Bm;
 
   if (yy&lt;0)
       yy=9999999+yy;
   end
 
   x(i)=xx;
   y(i)=yy;
   utmzone(i,:)=sprintf('%02d %c',Huso,Letra);
end
 
 
 
 
function ms = m2ms(m,textout)
% min to min:sec
% if second argument is true, then text is output
 
if nargin1 &amp;&amp; ~~textout)
    if any(ms(:,1)&gt;=60)
        f = '%d:%02d';
        hms = [floor(ms(:,1)/60) mod(ms,60)];
    else
        f = '%02d';
        hms = ms;
    end
    if any(abs(m*60-round(m*60))&gt;1e-3)
        f = [f ':%06.3f'];
    else
        f = [f ':%02.0f'];
    end
    if ~nargout
        fprintf([f '\n'],hms.');
        clear ms;
    else
        ms = num2str(hms,f);
    end
end

Wie weet maak in nog een keer een .exe file hier van, of een online tool zodat je op mijn website jouw gpx/tcx files van splits kan voorzien. Laat hier onder, als commentaar, opmerkingen, wensen of suggesties achter. Mocht je handig zijn met Perl, PHP, Python, of zo, dan kan je wellicht deze, op zich redelijke simpele, code herschrijven.

Nacht-OL in Ham, waar ze “handboeken” schrijven

N.B. De linkjes naar de filmpjes naast de filmprojector icons zijn links naar mijn eigen server, en een stuk trager dan de YouTube frames.

Op http://hamok.be/techniek/orientatielopen/ staat alles wat je wilt weten (met dank aan Luc Cloostermans, weet ik nu *).  Wat ik niet wist was dat het bos in Ham behoorlijk vol staat. Met bomen (duh), maar ook doorntakken (inmiddels zonder bramen maar met stekels), kreupelhout, en bijzonder veel dunnen stammetjes. Ook op de witte stukken kaart. En des te groener was ik zelf na afloop, mijn armen, benen, en zelfs op mijn hoofd. Groen voelde ik me ook, want ik heb toch een paar behoorlijke beginnersfouten gemaakt.

Foutjes

Kijk maar eens naar deze kaartjes. Vooral de route van 1 naar 2 was erg slordig. Ik zou nu, als ik toch eenmaal op de verharde weg was beland, die hebben gevolgd, en het pad rechtstreeks naar post 2 hebben gekozen. Waarom ik dat niet deed, en ging dolen, weet ik niet. Ik kwam onderweg Thomas van der Kleij tegen, en dacht dat hij al van 2 vandaan kwam. Dus ging ik de kant op waar hij uit kwam. Fout!

Zie hier het filmfragment:

En dan het stuk van 22 naar 23! Ik ben gewoon over de post heengelopen, volgens mijn GPS, en ben vervolgens gaan dolen. Nou ja, op zich verstandig om een referentie te zoeken, maar waarom ik nou helemaal een rondje heb gemaakt?

De hele route kan je hier zijn, in mijn Quickroute archief.

Als ik naar de splits kijk ging het nog niet zo slecht. Kon beter, maar ik ben niet ontevreden. Het beste wat ik kan doen is de balans opmaken, en er van leren. Want ik ben niet heel overdreven tevreden over mijzelf. Vermoedelijk had ik verwacht dat met mijn nieuwe hoofdlampje het lopen vanzelf zou gaan.

Leermomenten

Drie dingen gingen mis:

  • het niet vinden van punten (door te grote risico’s nemen op de verkeerde momenten),
  • minder optimale routekeuzes (door niet goed genoeg op de kaart te kijken), en
  • tijdverlies door stilstaan om op de kaart te kijken, deze te plooien, veters te strikken, hoofdlampje her aan te sluiten, en te zoeken waar ik ook alweer was op de kaart.

Wat doe ik er aan? Er zit wat tegenstrijdigs in. Enerzijds maak ik wat foutjes die toe te schrijven zijn aan het niet-de-tijd-nemen om goed op de kaart te kijken, om de juiste, snelste danwel veiligste, route te kiezen (en juist de afweging tussen die twee vergt goed kaart kijken). Anderzijds moet het sneller, minder tijd kaartlezen en harder lopen. Want Quickroute is onverbiddelijk: 25% van mijn tijd heb ik langzamer dan 15 min/km gelopen, geschuifeld of stil gestaan. Niet goed. En dat kwam niet doordat het af en toe behoorlijk glad was.

  • Stress is niet goed. Het gevoel dat ik door moet lopen, ook als ik even niet weet waar heen, moet onderdrukt worden! Beter dan stilstaan? Niet die keer dat ik lijnrecht de verkeerde kant op van de post rende. Gelukkig maar 30 meter.
  • Kaartlezen tijdens het lopen, dat zou tijd schelen. Ik heb een GPS track van Ralph Kurt gezien. Die gaat maar door. Ooit vertelde hij me dat hij geoefend heeft door de krant te lezen tijdens het joggen. Moet ik ook maar eens gaan doen.
  • Terrein inschatten is een vak. Meer dan eens bleek “wit” bos door doorntakken en talloze jonge stammen onbegaanbaar, en was “groen” bos prima doorloopbaar op begane grond niveau. Dat had ik na een paar keer mijn neus stoten toch moeten weten. Gaat doorsteken vaker fout dan goed? Pak dan in het vervolg de paden. Meer dan 40% om is het zelden, en meestal 20% sneller. Als je voor dat tijdverlies wel de zekerheid hebt de post te vinden is het geen slechte deal.
  • Ik moet gedisciplineerder mijn kaart vasthouden. Niet steeds overpakken naar de andere hand, en mijn vinger, de punt van het kompas, de nul van mijn schaal, wat dan ook, op de juiste plek houden. Zodat ik direct, bij een blik op de kaart, zie waar ik ben. Misschien moet mijn schaaltje van het kompas, zodat die het zicht niet beperkt.
  • De Verkeerslichten Methode gebruiken om op het juiste moment vol gas te geven als het niet kritisch is om mijn positie op de kaart exact te volgen. En zorgvuldig te werk gaan als het lastig wordt. Ook al komt een gokje vaak wel goed, als het mis gaat kost het veel tijd.

Materiaal

En ik heb nog wat opmerkingen over mijn gebruikte materiaal. Dat overigens steeds meer wordt, in aantal. (Het begon zo mooi, mijn eerste OL vorig jaar, met alleen een kompas en wat kleren, en een zaklamp. Maar inmiddels heb ik een duimkompas, een GPS-horloge, een hartslagband, een hoofdlamp, een accu, een GPS-tracker, een passen-schaalverdeling, een headcam, scheenbeschermers, een postomschrijvinghoesje, en een fluitje. Wat een ballast!)

  • De schaalverdeling die ik op mijn kompas heb mijn geplakt, uitgemeten in passen ik gemiddeld terrein, zit in de weg. Ik merk dat ik af en toe mijn kaart van hand wissel omdat hij onder m’n kompas niet handig leest. Toch een andere schaal? Hij is ook wel weer handig. Hier moet ik maar weer eens mee experimenteren.
  • Hoofdlampje is top. Veel licht, dimmen is onzin, hoe meer licht hoe beter, en hij strooit  bovendien veel rest-licht in het rond, wat ideaal is om het pad pal voor je neus te zien, takken die je moet ontwijken over 0.2 s, en de kaart te lezen zonder jezelf te verblinden. Maar het is wel onhandig dat onderweg drie keer mijn stekkertje door een tak uit de accu werd getrokken, zodat ik plotsklaps in het stik-donker stond. Een knoop in het snoer, rondom de interconnectie, is de oplossing, maar niet elegant. Volgende keer snoer onder mijn shirt, of iets met tape of klittenband.
  • Die accu (4×18650 Li-ion = 4400 mAh) is een blok aan het been. Of aan het heuptasje. Dat alle kanten op slingert. Niet fijn. Nog een 2e generatie houder voor verzinnen. Heb ik mooi weer wat te doen.
  • De elastische hoofdband waaraan zowel mijn lampje als mijn camera hangen, ziet wat strak. Volgende keer koop ik 1 cm meer elastiek. Tja, met €0,40 naar de fourniturenzaak in de wijk fietsen is misschien wat optimistisch geweest.
  • Het is niet zo handig als je camera voortijdig uit gaat. Tape-je over de schakelaar? Of gewoon reageren als het piep-piep-ik-ga-uit toontje klinkt?

Headcam video

Ik had mijn Contour Roam weer meegenomen. Helaas ging hij 8 minuten voor de finish uit toen ik tegen een boom liep. Gevoeld, knop leek nog aan, maar dat bleek niet zo te zijn. Jammer. Ik ga nog kijken of een nacht-video bruikbaar is, of of ik RGmapVideo aan ga slingeren.

Een stukje camerawerk in het donker:

Bier

Erg leuk nog een biertje gedronken na afloop. Gezellige kerels van Hamok (bijna hebben ze een Hamok-softshell aangesmeerd -mooi spul, daar niet van, maar eerst maar eens een KOVZ kloffie aanschaffen-) en KOL die graag wilden dat ik met een te hoog promillage naar huis reed. En daar hoorde ik dat er van het O-handboek ook een papieren off-line versie bestaat. En dat sommige woorden in het Vlaams iets heel anders betekenen dan in het Nederlands 🙂

Attackpoint

De grote vraag is of ik genoeg discipline heb om na elk stukje hardlopen de gegevens in te voeren op Attackpoint, maar het is een mooi streven.

Ik kende de site al wel langer, maar werd geprikkeld door een mail van A3, gisteren:

Beste KOVZers,

Er wordt de laatste maanden door een redelijke groep lopers dankbaar gebruik gemaakt van de inspanningen van Peter. Of te wel, er wordt flink getraind. En dan hoor ik ook nog eens dat een steeds grotere groep KOVZers aan looptraining doet. Hartstikke goed natuurlijk, zo gaan de prestaties lekker vooruit.

Een volgende stap is het registreren van je trainingen, attackpoint (een online gratis trainingslogboek) is daar een goed hulpmiddel voor. Ik hoor een aantal mensen al denken ‘wat is daar nou het nut van’? Dat kan meer omvattend zijn dan je denkt, hieronder een paar van de vele voordelen:

  • Je kunt als je een b.v. blessure oploopt terug kijken wat je anders/meer hebt gedaan dan normaal. Dat geeft je een handvat voor de toekomst (rustiger opbouwen)
  • Je kunt als je uitstekend in vorm raakt terug kijken hoe je dat gefikst hebt en dat in een volgend seizoen nog eens over doen.
  • Het is soms voor jezelf een motivatie om toch te gaan trainen.
  • Het kan voor anderen een voorbeeld/stimulans/motivatie zijn om ook te trainen.
  • Je kunt reageren op een log van andere lopers en ze een hart onder de riem steken of je bewondering uitspreken.
  • Als je ook nog eens aanmeld bij de KOVZ en NOLB groep en kijkt wat en hoe anderen het doen is het ook nog eens saamhorigheids bevorderend, lekker voor onze vereniging.
  • en nog veel meer…………kijken dus.

Waar kun je je aanmelden? http://www.attackpoint.org Je kunt daar al je gegevens invoeren en vergeet niet om ook lid te worden van de KOVZ groep!! (een aantal KOVZers zijn al actief maar hebben zich nog niet bij onze groep aangemeld) Benieuwd wie zich al wel in de KOVZ groep hebben gemeld? Meld je snel aan, ook als je alleen af en toe een wedstrijdje loopt en alleen maar de KOVZ trainingen af en toe meeloopt.

O-groeten,
Adrie.

Twee maanden later: Inmiddels heb ik vrijwel alles wat ik sneller gelopen heb dan stapvoets, sinds oktober vorig jaar, in Attachpoint gezet. En ik houd het nog steeds bij. Het is inderdaad motiverend om weer een paar kilometers en uren te kunnen noteren. Alsof het lopen een 2e nut heeft, behalve dan een vluchtige vermoeiing en wat langer blijvende conditieverbetering. Alsof je een geocache logt, zo iets. Maar dan minder nutteloos.

Met andere woorden: ik ben verkocht.

Training VI: hoogtelijnen

(Het duurde even voordat ik deze post op mijn Blog plaatste, maar ik had eigenlijk andere plannen: RouteGadget kaarten maken en hier linken waarop iedereen zijn route kon intekenen).

RouteGadget

Eerst maar even daar over. Het idee was simpel: net als bij de Sylvester op de Boshoverheide, waarvoor ik een RouteGadget kaart op mijn site had gezet, zou ik dat ook voor de laatste training doen. Het resultaat is deze kaart waar iedereen die trainde zijn kaart op kan bekijken. Maar naast bekijken bedacht Peter dat het leuk was als iedereen ook zijn route in zou kunnen tekenen. En daar is RG ook voor gemaakt, eigenlijk. Maar intekenen en uploaden vanaf GPS lukt niet. Twee avonden mee gestoeid, maar niets werkt. Intekenen lukt wel, de route wordt ook opgeslagen, maar niet getoond.

En dat is nou het leuke van zo’n weblog: je hebt het gevoel dat er iemand over je schouder meekijkt. En dus doe je extra je best (wat je er ook vanaf ziet stralen bij de headcam filmpjes, natuurlijk -knipoog-). Ik kon het niet laten om, nadat ik voorgaande paragraaf had getypt, toch even te kijken wat er mis ging. En weldra had ik het gevonden. De gesimuleerde splits (ja, bij de training gebruiken we geen Emits, dus die files moest ik met Matlab genereren) werden niet goed ingelezen. Er stond wel wat, wat juist het verwarrende was, maar niet iets dat klopte. En nu werkt het wel! Dus jullie kunnen, 2 weken na dato, alsnog je route intekenen.

Hoogtelijnen

Dat was waar deze training over ging. Eerst gaf Peter uitleg over hoe je hoogtelijnen moet lezen. Het lijkt triviaal, maar dat is het niet. En juist omdat Peter zelf kaartenmaker is, wist hij heel goed uit te leggen hoe het terrein er door het oog van een tekenaar uitziet, wat natuurlijk ook is hoe het vervolgens op papier komt te staan.

Opmerkelijk is dat, in relatief vlak terrein als Nederland, de hoogtelijnen vooral overeenkomen met de zichtbare reliefvormen. Ze geven dus niet noodzakelijk 15, 16, 17, meter boven N.A.P. aan, om maar wat te noemen als het hoogtelijneninterval 1 meter is, maar de vorm van wat je 1 meter boven het maaiveld uit ziet steken als je in het landschap staat. Of 2 meter er boven, etc. Goed om te weten. Wat je op de kaart ziet staat er zo omdat de kaartenmaker dat op het ook ook zo zag.

In de echte bergen zal dat natuurlijk anders zijn, daar spelen de hoogtelijnen een hele andere rol, en zijn de hoogteverschillen veel nadrukkelijker aanwezig.

Oro-hydro kaart

Geheel in het verlengde daarvan waren ook de kaarten waar we deze training op liepen (voor een aantal lopers) aangepast. Dat waren zogenaamde oro-hydro kaarten, kaarten met alleen hoogtelijnen en water. En de route langs de posten natuurlijk. Zeg maar een kaart waarbij alleen de bruine, blauwe, en magenta inkt niet op was. Je krijgt dan zo iets:

En ik moet zeggen dat me dat helemaal niet tegen viel. Juist omdat je niet wordt afgeleid door bos en pad en hei, maar alleen naar de vorm van de ondergrond kijkt, wordt het best overzichtelijk. Natuurlijk waren de posten er ook wel een beetje naar geplaatst, zodat je niet midden in een vlak terrein moest zoeken naar kenmerken die niet op de kaart stonden, maar toch had ik het lastiger verwacht. Daar kwam nog bij dat het behoorlijk besneeuwd was. Wat het bovendien wel extra mooi maakte.

Het hydro-aspect van de kaart kwam wat minder naar voren, ook omdat de grond en alle watertjes stijf bevroren waren, en bedekt met sneeuw. Maar dat was misschien maar goed ook, want als je alleen hoogtelijnen op de kaart hebt kan je zo in zeven sloten tegelijk lopen.

Al kan je over zo’n hoogtelijn ook behoorlijk struikelen, zoals in het onderstaande filmpje:

Reistijden in de NOLB en VVO kalenders.

Ik ken niet alle plaatsen in Nederland en België uit mijn hoofd.

Installeer:
O-reistijd
(Greasemonkey
vereist)

Daarom wilde ik eenvoudig de afstanden, en vooral de reistijden, naar plaatsen toevoegen aan de kalenders van NOLB en VVO met komende Oriëntatielopen. Het leek me handig om snel te zien waar bepaalde plaatsen op de diverse O-kalenders liggen.

Ik heb daarom een Greasemonkey-scriptje geschreven, dat in onder andere Firefox, maar ook in sommige andere browsers, werkt. Zodra je dat hebt geïnstalleerd worden automatisch de afstanden en tijden opgezocht via Google, en getoond. Zoals hier onder voor de VVO kalender:

VVO kalender, met tijden er bijEn iets vergelijkbaars gebeurt er met de NOLB kalender:NOLB kalender, met reisafstanden

Je kan zelf het vertrekpunt ingeven in de balk direct boven de tabel (dat kan zowel een coördinaat, als een adres of plaatsnaam zijn), en je kan de reistijd opgeven (in minuten) waaronder de reistijden (groen) gemarkeerd worden.

Installatie

Installatie is heel eenvoudig.

  • Je hebt een browser nodig die Add-ons ondersteunt, zoals Firefox.
  • Vervolgens installeer je Greasemonkey, als je dat niet al hebt. Bijvoorbeeld via deze link naar Greasemonkey, maar anders is het ook via Google te vinden.
  • Tenslotte installeer je mijn script, door op deze link naar O-reistijd te klikken.
  • Als je vervolgens een van de kalenders van de NOLB of VVO opent, krijg je automatisch de tijden en afstanden te zien. Je kan je eigen locatie instellen, en die wordt vanzelf onthouden.

Makkelijk, niet? Als je vragen of suggesties hebt, mail me dan via deze O-blog, of plaats een opmerking onderaan deze pagina.

Help, waar ben ik nu weer?

Per vandaag ben ik overgegaan op WordPress, als CMS voor mijn Oriëntatielopen site. Handig, leek me. Kost niet zo veel werk. Ahum.

Op zoek naar de oude JG-O site? Die kan je vinden op http://jan-gerard.nl/jg/o1/. Maar goed, die onderhoud ik niet meer. Nog even kijken of ik met niet al te veel moeite de lay-out over kan nemen naar WordPress, hier dus, maar het moet wel onderhoudbaar blijven, dus ik wil niet te veel aanpassen. Het kompasje en de control-flag zijn al over, nu nog het transparante menu dat doorloopt in de titelbalk, en de tekst-kolom wat smaller maken. Een automatische inhoudsopgave heb ik inmiddels toegevoegd.
Intussen zie je al dat er meer van programmeren dan van inhoud schrijven komt. Dat is natuurlijk niet de bedoeling. En erger nog: er komt niet zo veel van lopen. Er lijkt, of blijkt, een soort zomerstop te heersen in O-land. Vorige week drie lopen in de buurt, maar toen zaten we in de Ardennen. En in Frankrijk zie ik tijdens de zomervakantie ook niets in de streek waar we zitten. Ik vrees dat het tot september gaat duren voordat ik weer achter de naald van mijn kompas aan ga rennen. Nou ja, kan ik intussen mooi trainen, want een beetje conditie kan ook geen kwaad.