Als het fietsen dan niet wil lukken zijn er soms leuke dingen te melden. Zo werd ik herkent door de Nederlands Kampioen Tijdrijden Elite (één treedje onder de profs). Niet dat we dagelijks bij elkaar op de koffie komen (dat bocht drink ik niet), of omdat we vroeger samen geknikkerd hebben, nee, hij won de eerste editie van de TijdstrijdersCup. Vandaar.

Van hele andere orde van herkenning door een gerenommeerde wedstrijdroeier. Hij kwam aan z’n vorm werken voor het aanstaande WK (in Nieuw Zeeland, bofkont!)
- Jij bent toch Corniel van forum.fiets.nl?
- Euh, ja, dat schijnt.
- Ja, ik herkende je fiets.

Hij was niet de enige. Kom ik ’s avond thuis, lees ik op datzelfde wielerforum het volgende: Bekend forumlid in NRC!

Tja, was dat tacxen toch nog ergens goed voor.

McEwen niet geselecteerd voor WK wielrennen

AMSTERDAM – Robbie McEwen moet de wereldkampioenschappen wielrennen in eigen land missen. De Australische sprinter is niet geselecteerd voor de wegwedstrijd die begin oktober in Geelong op het programma staat.

“Ik ben niet bij de wereldtitelstrijd”, liet McEwen zondagochtend (lokale tijd) op Twitter weten. “Ik weet niet wie de negen geselecteerde renners zijn. Ik weet alleen dat ik niet bij de selectie zit.”

De tweevoudig wereldkampioen zegt teleurgesteld te zijn. “Ik dacht dat ik hier een goede kans zou maken.” McEwen toonde afgelopen week met een etappezege in de Eneco Tour aan in vorm te zijn.

De sprinter behoorde tot één van de outsiders voor de wereldtitelstrijd. Het is voor het eerst dat de WK in Australië georganiseerd worden. Het is nog niet bekend wanneer de Australische coach Dave Sanders zijn selectie bekendmaakt.

Robbie McEwen, de sympathieke Australische klasbak, met zijn leuke vlaamse accent (voor de outsiders: hij woont al jaren in Vlaanderen), die zichzelf altijd prima in de sprint wist te wormen, ook zonder Cavendish-treintje. Het was hem zo gegund. In zijn laatste jaar als profrenner, in eigen land, schitteren op het wereldkampioenschap. Welke idioot verzint zo iets? Elke wielerliefhebber zou hem opstellen in het Australische team. En iedereen zou voor hem duimen.

Maar de coach besliste anders. Hij is klaarblijkelijk van mening dat er négen renners met Australisch paspoort zijn, die beter uit de verf zouden komen. Er zijn er voor kleinere blunders uit hun functie ontheven…

Zoals altijd kom je pas achter gebreken als het te laat is. Zo ook nu. Daar stond ik met mijn goede gedrag in dat stukje niemandsland in de Alblasserwaard. Mijn oude hartslagmeter weigerde nog langer dienst te doen, en de nieuw aangeschafte (met gecodeerd signaal, toemaar) bleek niet samen te werken met m’n (on)vermogenmeter. De input voor donderdag was dus: snelheid, trapfrequentie en vermogen. Geen hartslag.

Geen man overboord. Ik ging op vermogen rijden en koos de niet helemaal willekeurige waarde van 320 Watt. We gingen wel zien waar het schip zou stranden.

Het ging best goed, dat eerste rondje. Tegen de wind zakte de snelheid niet onder de 39 kilometer per uur, en voor de wind liep zij hier en daar op tot dik 47 uitgedrukt in de zelfde eenheid. Het geplande vermogen werd goed aangehouden en het lijf voelde goed.

Het tweede rondje ging min of meer gelijk aan het eerste. Enig verschil was dat de maximum snelheid voor de wind nu 45 kilometer per uur bedroeg, maar meten is weten: de vermogenmeter zei dat het een gelijke inspanning was.

Langzaam maar zeker echter, voltrok zich iets. Iets kleins. Heel geniepig in m’n rechter kuit. Maar ik kon het duidelijk voelen. Er werd een ballonnetje opgeblazen. Gevuld met melkzuur. Steeds harder voelde ik hem drukken tegen de buitenkant. Ik hoor Hans Kazan ergens achter in mijn hoofd lachen.

Het laatste stuk tegen de wind in richting finish ging het mis. Pang! De ballon geknapt. Het been weigert. Strekken en (ver)rekken is alles wat er rest. Weer zitten, weer aanzetten. Geen effect. Mijn snelheid is gehalveerd in vergelijking met de vorige passage.

Zoef! Een bekend gezicht komt mij vrolijk voorbij gesjeesd. Shit! Dat was niet de bedoeling. Met alles wat in me is verbijt ik de pijn. Ik moet en zal hem weer inhalen. De snelheid loopt op tot 45 kilometer per uur (tegen de wind, voorwaar!) het vermogen gaat richting de 500 Watt. De finish nadert, de kramploze nadert…

Ik kan hem bijna aanraken… En dan binnen… Hij racet verder. Ondanks dit pijnlijke intermezzo 31:01. En 25e van de 30. Zo gaat dat. In Zuid-Holland.

Nu twee dagen later voel ik m’n kuit nog steeds. Nu hopen dat die vervelende goochelaar  dat ballontje ook weer weet wet te goochelen.

Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning (..)

Rick Cook

Hoewel ik al dat mystieke, zweverige (haast religieuze) gedoe omtrent klimmen zwaar overdreven vind, stond de Mont Ventoux wel bovenaan m’n lijstje van colletjes die ik wel eens wilde oprijden. Het is een klim die wat voorstelt. Verder is de klim heel erg mooi, en dat is ook wat waard.

Het had niet eens heel veel voeten in de aarde om m’n liefje te overtuigen dat ook zij deze klim ook moest doen. Na wat wikken en wegen kozen we voor de beklimming via Malaucène. Deze is nét iets zwaarder dan die vanuit Bédoin (de Tour de France kant, die alleen daarom populairder is). De klim vanuit Sault is voor slappelingen, die viel direct af.

Na een heuze verkenning per oto (liefje: de Garmin zegt hier dertien procent!, hier is het vier procent, etc.) konden we de volgende ochtend aan de bak. Vroeg uit de veren en vanuit de camping richting Malaucène. Zestien kilometer warmdraaien, met ook al aardig wat (licht, dat wel) klimwerk: maximaal zes procent.

En dan spot je het eerste paaltje:

Liefje vertrekt stipt 9:05 voor haar 21 kilometer. Ik zou een halfuur wachten. Het worden er vijfentwintig. Ik houd het niet langer, ik moet, ik zal, ik ga! 9:30 en los.

Na mijn ervaringen met de Col de la Forclaz had ik ingezet op een tijd van onder de 1:30. De Forclaz is weliswaar korter (minder dan de helft) maar ook (behoorlijk) steiler, dus wellicht was een zelfde gemiddelde snelheid (veertien kilometer per uur) wel te doen. Vanwege de lange stukken tien procent echter, moet er ook ergens tijd worden ‘goedgemaakt’. Dus direct met de hartslag richting eind D2 en dik boven de twintig kilometer per uur. Al vrij snel haal ik wat mensen in die ik al wachtend had zien vertrekken.
- Hé, niet te gek man, het is nog ver!
- Maak je geen zorgen, ik zit nog lang niet in het rood.

Na anderhalve kilometer wordt het voor het eerst stijl. Tikje voor tikje schakel ik terug. Ik houd van souplesse, ook berg op. Binnen no-time zit ik op de 34:25, mijn kleinste verzet. De hartslag loopt  keurig op tot dik D3 en de trapfrequentie zit ruim boven de tachtig rotaties per minuut.

Als het eerste stuk negen procent aanbreekt schiet de hartslag voor het eerst boven omslag. Het is nog ver, maar ik voel me sterk. De benen zijn goed. Het tempo blijft hoog. Geen enkele cijfers op het display. Na kilometer vier is het vijf kilometer relatief vlak (met twee piekjes van dik tien procent, dat wel). Tempo blijven rijden is het devies. Daarna is het zwaarste stuk, vier kilometer lang boven de tien procent.

Ik nader m’n liefje. Bijna dertig minuten onderweg, zij dus bijna een uur. Ik zeg iets liefs (denk ik) en laat haar achter. Liefde is mooi, maar heel even, liggen de prioriteiten anders. Ik zie je boven!

De trapfrequentie is goed, ik schakel een paar tandjes op (en op de steile stukjes weer keurig terug). Voortdurend zie ik renners voor me. Een voor een haal ik ze in. Als ik iets Nederlandstaligs op hun shirt zie groet ik m’n moerstaal, anders volsta ik met: Bonjour!  Hoewel sommigen zo’n mooie dag niet lijken te hebben. Wat een lijken…

Het zware gedeelte breekt aan. De paaltjes waarschuwen me. De snelheid zakt tot net tien à elf kilometer per uur. De trapfrequentie nadert de vijftig. In binnenbochten – of als ik renners opraap – ga ik erbij staan. Heel, heel, heel soms, heel even maar, verschijnt er “09” op het scherm. Hmm, dat was niet de bedoeling. Voor een tijdje voel ik zelfs wat pijn in de aanhechtspieren van mijn bovenbeen met mijn linker knie.

Daarna vlakt het weer af. Bij het opvoeren van de snelheid merk ik vermoeidheid. De vlakkere stukken krijg ik mijn hartslag niet meer in  D3. De snelheid en trapfrequentie zijn nog prima dus zorgen maak ik me niet.

Bij de rotonde (Mont Serein)  gaat het even licht naar beneden, en de snelheid dus omhoog. Het is van korte duur, de bocht, er staat een fotograaf. Ik lees sport-photo.fr. Geen leuke foto van mij blijkt. Jammer, niets aan te doen. Het wordt weer echt steil (boven de tien procent) en ik focus op het fietsen. De hartslag weer keurig in de D3, en geen enkele cijfers.

Als ik 1:15 op de fiets zit zie ik het paaltje dat zegt dat ik nog drie kilometer moet. Voor een tijd onder de 1:30 moet ik dus – kraak, kraak, kraak, kraak, rekenen gaat niet snel meer – de rest van de rit afleggen met tenminste twaalf kilometer per uur. Dat moet nét kunnen.

De mistral – die volgens de mevrouw van de camping sterker was dan normaal (er mocht niet ge-bbq’d worden) – staat tegen. Ik probeer de snelheid boven de twaalf kilometer per uur te houden, maar dat lukt niet altijd. Ik ga een momentje staan, maar beter wordt het daar niet van. En dus terug in het zadel. Dan zie ik de top. In mist gehuld.

Ga ik dat echt redden? Het lijkt nog zo ver, en nog zo hoog. Als ik het voorwiel over de streep druk weet ik het: 1:30,26. Nét niet. Maar ik ben boven! Het is nog even wachten op m’n liefje, maar als ze er ook is, laten we ons vereeuwigen:

Gelukkig had ik een regenjackje en armstukken bij me, want het was koooouuuud….

Na de afdaling, en een goed bord pasta rijden we in de zon – die eindelijk is gaan schijnen – terug richting camping. Onderweg pakken we nog even een klim van de buiten categorie mee:

De niet te onderschatten Col de la Chaine. En genieten van het landschap:

Het was een mooie dag uit een mooie vakantie.

Na wat verkenningen en een flinke tocht samen, stond op 30 juli de Col de la Forclaz op het programma.

Aangezien deze col meerdere langere stukjes boven de 14 procent kent, zag liefje het niet zitten (Als je de 800 meter daling uit de klim haalt kom je op gemiddeld 8,7 procent, anders is het gemiddeld 8,0 procent).  Wel stond ze met de oto en camara in de aanslag langs de weg (waarvoor heel veel dank):

Filmpje: Soepel de Forclaz op

In 38 minuten boven. Nét geen veertien kilometer per uur. Best aardig al zeg ik het zelf. Onderweg vijf mensen ingehaald, waaronder een Fries te voet. Je merkt dan toch dat dit geen overbekende klim is: het ziet er niet zwart van de wielrenners.

Daarna parkeerden we de oto bij het meer, en reden samen ook nog een leuk rondje met een stevige col. We kwamen heelhuids boven. Naar beneden bleek wat lastiger:

Gelukkig hadden ze allemaal een bel.

The re-usability wasn’t that great, merging and writing was not supported, and as .NET 1.1 did not support Typed lists yet, I had to rewrite it all:

using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;

namespace HelloWorld.Xamples.Drawing
{
    /// <summary>Represents a Windows multi icon, which is a collection of small bitmap images
    /// used to represent an object. Icons can be thought of as transparent
    /// bitmaps, although their size is determined by the system.
    /// </summary>
    public class MultiIcon : List<Icon>
    {
        /// <summary>Initializes a new instance of the Tjip.Drawing.MultiIcon class.</summary>
        public MultiIcon() { }

        /// <summary>Represents the Widows multi icon as System.String.</summary>
        public override string ToString()
        {
            var str = string.Format("{0} Items: {1}",
                GetType().FullName,
                this.Count);
            if (this.Count == 1)
            {
                str += string.Format(", Size: {0} px",
                    this.First().Width);
            }
            if (this.Count > 1)
            {
                str += string.Format(", Smallest: {0} px, Largest: {1} px",
                    this.GetSmallest().Width,
                    this.GetLargest().Width);
            }
            return str;
        }

        /// <summary>Loads a Windows multi icon based on the specfied path.</summary>
        /// <param name="filepath">The filepath to load from.</param>
        public static MultiIcon Load(string filepath)
        {
            using (var stream = new FileStream(filepath, FileMode.Open, FileAccess.Read))
            {
                return Load(stream);
            }
        }
        /// <summary>Loads a Windows multi icon from a stream.</summary>
        /// <param name="stream">The stream to load from.</param>
        public static MultiIcon Load(Stream stream)
        {
            // Read the stream.
            using (var reader = new BinaryReader(stream))
            {
                var icon = new MultiIcon();
                var entries = new List<MultiIconEntry>();

                // Read the header.
                var header = reader.ReadMultiIconHeader();

                // Read the icon entries.
                for (int i = 0; i < header.Count; i++)
                {
                    var entry = reader.ReadMultiIconEntry();
                    entries.Add(entry);
                }
                // Read the icons based on the entries.
                foreach (var entry in entries)
                {
                    var ico = reader.ReadIcon(header, entry);
                    icon.Add(ico);
                }
                return icon;
            }
        }
    }

    /// <summary>Methods for Windows multi icon, that should be available
    /// for all collections of Widows icons.</summary>
    public static class MultiIconExtensions
    {
        /// <summary>Saves the Windows icons to a single file.</summary>
        /// <param name="icon">The list of icons.</param>
        /// <param name="filepath">The filepath to save to.</param>
        public static void Save(this IList<Icon> icons, string filepath)
        {
            using (var stream = new FileStream(filepath, FileMode.CreateNew, FileAccess.Write))
            {
                icons.Save(stream);
            }
        }
        /// <summary>Saves the Windows icons to a single stream.</summary>
        /// <param name="icon">The list of icons.</param>
        /// <param name="stream">The stream to save to.</param>
        public static void Save(this IList<Icon> icons, Stream stream)
        {
            using (var writer = new BinaryWriter(stream))
            {
                long startposition = stream.Position;

                var entries = new List<MultiIconEntry>();
                var buffers = new List<byte[]>();
                // create header.
                var header = new MultiIconHeader()
                {
                    Count = (short)icons.Count,
                };
                // create entries.
                for (int i = 0; i < icons.Count; i++)
                {
                    using (var icon_stream = new MemoryStream())
                    {
                        var entry = new MultiIconEntry();
                        var item = icons[i];
                        item.Save(icon_stream);
                        icon_stream.Position = 0;

                        using (var reader = new BinaryReader(icon_stream))
                        {
                            // icoHeader.Reserved[2],
                            // icoHeader.Type[2],
                            // none.Pos[2],
                            // Width[1],
                            // Height[1],
                            // ColorCount[1],
                            // Reserved[1]
                            // Planes[2]
                            // BitCount[2]
                            // BytesInRes[4]
                            // none.OffSet[4]
                            var header_reserved = reader.ReadInt16();
                            var header_type = reader.ReadInt16();
                            var none_startpos = reader.ReadInt16();
                            entry.Width = reader.ReadByte();
                            entry.Height = reader.ReadByte();
                            entry.ColorCount = reader.ReadByte();
                            entry.Reserved = reader.ReadByte();
                            entry.Planes = reader.ReadInt16();
                            entry.BitCount = reader.ReadInt16();
                            entry.BytesInRes = reader.ReadInt32();
                            entry.ImageOffset = MultiIconHeader.ByteSize + MultiIconEntry.ByteSize * icons.Count + buffers.Sum(buf => buf.Length);
                            var none_offset = reader.ReadInt32();

                            var buffer = new byte[icon_stream.Length - icon_stream.Position];
                            icon_stream.Read(buffer, 0, buffer.Length);
                            entries.Add(entry);
                            buffers.Add(buffer);
                        }
                    }
                }
                // Writer header.
                writer.Write(header);

                // Write entries.
                foreach (var entry in entries)
                {
                    writer.Write(entry);
                }
                // Write images.
                foreach (var buffer in buffers)
                {
                    writer.Write(buffer);
                }
                // Clear buffer and save.
                writer.Flush();
            }
        }

        /// <summary>Gets the smallest icon.</summary>
        /// <param name="icon">The list of icons.</param>
        /// <returns>The smallest icon.</returns>
        public static Icon GetSmallest(this IEnumerable<Icon> icons)
        {
            var icon =
            (
                from
                    item in icons
                orderby
                    item.Width ascending
                select
                    item
            )
            .FirstOrDefault();

            return icon;
        }
        /// <summary>Gets the largest icon.</summary>
        /// <param name="icon">The list of icons.</param>
        /// <returns>The largest icon.</returns>
        public static Icon GetLargest(this IEnumerable<Icon> icons)
        {
            var icon =
            (
                from
                    item in icons
                orderby
                    item.Width descending
                select
                    item
            )
            .FirstOrDefault();

            return icon;
        }
    }
    /// <summary>Represents the header of a Windows (multi) icon.</summary>
    internal class MultiIconHeader
    {
        /// <summary>The byte size of a single icon header.</summary>
        public const int ByteSize = 2 + 2 + 2;

        /// <summary>Initializes a new instance of the Tjip.Drawing.MultiIconHeader class.</summary>
        public MultiIconHeader()
        {
            this.Type = 1;
        }

        public short Reserved { get; set; }
        public short Type { get; set; }
        public short Count { get; set; }
    }

    /// <summary>Extenion methods for MultiIconHeader.</summary>
    internal static class MultiIconHeaderExtensions
    {
        /// <summary>Reads a Windows (multi) icon header from the current stream
        /// and advances the current position of the stream by six bytes.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public static MultiIconHeader ReadMultiIconHeader(this BinaryReader reader)
        {
            var header = new MultiIconHeader()
            {
                Reserved = reader.ReadInt16(),
                Type = reader.ReadInt16(),
                Count = reader.ReadInt16(),
            };
            return header;
        }

        /// <summary>Writes a Windows (multi) icon header to the current stream
        /// and advances the current position of the stream by six bytes.
        /// </summary>
        /// <param name="writer">The writer.</param>
        /// <param name="header">The Windows multi icon header to write.</param>
        public static void Write(this BinaryWriter writer, MultiIconHeader header)
        {
            writer.Write(header.Reserved);
            writer.Write(header.Type);
            writer.Write(header.Count);
        }
    }
    /// <summary>Represents the entry of a Windows (multi) icon.</summary>
    internal class MultiIconEntry
    {
        /// <summary>The byte size of a single icon entry.</summary>
        public const int ByteSize = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4;

        /// <summary>Initializes a new instance of the Tjip.Drawing.MultiIconEntry class.</summary>
        public MultiIconEntry() { }

        public byte Width { get; set; }
        public byte Height { get; set; }
        public byte ColorCount { get; set; }
        public byte Reserved { get; set; }
        public short Planes { get; set; }
        public short BitCount { get; set; }
        public int BytesInRes { get; set; }
        public int ImageOffset { get; set; }
    }

    /// <summary>Extenion methods for MultiIconEntry.</summary>
    internal static class MultiIconEntryrExtensions
    {
        /// <summary>Reads a Windows (multi) icon entry from the current stream
        /// and advances the current position of the stream by sixteen bytes.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public static MultiIconEntry ReadMultiIconEntry(this BinaryReader reader)
        {
            var entry = new MultiIconEntry()
            {
                Width = reader.ReadByte(),
                Height = reader.ReadByte(),
                ColorCount = reader.ReadByte(),
                Reserved = reader.ReadByte(),
                Planes = reader.ReadInt16(),
                BitCount = reader.ReadInt16(),
                BytesInRes = reader.ReadInt32(),
                ImageOffset = reader.ReadInt32(),
            };
            return entry;
        }

        /// <summary>Reads a Windows icon from the current stream
        /// and advances the current position of the stream to the end of the
        /// Windows icon in the stream.
        /// </summary>
        /// <param name="reader">The reader.</param>
        public static Icon ReadIcon(this BinaryReader reader, MultiIconHeader header, MultiIconEntry entry)
        {
            const short ICON_STREAM_START = 1;
            const int ICON_STREAM_OFFSET = 22;

            using (var newIcon = new MemoryStream())
            {
                using (var writer = new BinaryWriter(newIcon))
                {
                    // Write it
                    writer.Write(header.Reserved);
                    writer.Write(header.Type);
                    writer.Write(ICON_STREAM_START);
                    writer.Write(entry.Width);
                    writer.Write(entry.Height);
                    writer.Write(entry.ColorCount);
                    writer.Write(entry.Reserved);
                    writer.Write(entry.Planes);
                    writer.Write(entry.BitCount);
                    writer.Write(entry.BytesInRes);
                    writer.Write(ICON_STREAM_OFFSET);

                    // Grab the icon
                    byte[] tmpBuffer = new byte[entry.BytesInRes];
                    reader.BaseStream.Position = entry.ImageOffset;
                    reader.Read(tmpBuffer, 0, entry.BytesInRes);
                    writer.Write(tmpBuffer);

                    // Finish up
                    writer.Flush();
                    newIcon.Position = 0;
                    return new Icon(newIcon);
                }
            }
        }

        /// <summary>Writes a Windows (multi) icon entry to the current stream
        /// and advances the current position of the stream by sixteen bytes.
        /// </summary>
        /// <param name="writer">The writer.</param>
        /// <param name="entry">The Windows multi icon entry to write.</param>
        public static void Write(this BinaryWriter writer, MultiIconEntry entry)
        {
            writer.Write(entry.Width);
            writer.Write(entry.Height);
            writer.Write(entry.ColorCount);
            writer.Write(entry.Reserved);
            writer.Write(entry.Planes);
            writer.Write(entry.BitCount);
            writer.Write(entry.BytesInRes);
            writer.Write(entry.ImageOffset);
        }
    }
}

It works perfectly. The only thing I still need to solve is the conversion of PNG24 to ICO:

var icon = Icon.FromHandle(new Bitmap("some_pgn24.png").GetHicon());

This results in an icon that does not have an alpha-channel. When I solved this, I will inform you.

Een echte beproeving was echter een weekendje zeilen met liefje en ex-huisgenoot en goede vriend E. Houd de wonden maar droog op een zeilboot, beweeg je met je verstijfde lijf maar eens op een schip, en ontzie je gekwetste zijde. Het is gelukt. Aan de andere kant: echt veel bewegingsruimte was er niet in het vooronder, dus het op een zijde liggen bleek geen kunst…

Het was een mooie dag op de Bult vandaag. De eerste ronde reed ik de bult op weg. Vier ronde lang bleef ik dat. Daarna handhaafde ik mij soepel in het peloton. Na een tweede uitval was ik minder gelukkig: Bij het bijhalen tikte de eerste renner van het peloton m’n stuur aan. Voor ik er erg in had was ik afgestapt. Iets te hard helaas.

Gelukkig hebben we de foto’s nog: