Deze post is een vervolg op Autonoom parkeren – Hardware Keuze
Voor het waarnemen van het voertuig wordt een Kinect gebruikt. Met dit apparaat is het mogelijk om een videobeeld te verkrijgen of diepte te meten. Daarnaast bevat het apparaat ook een microfoon-array om geluid op te nemen.
Om het voertuig te detecteren heb ik gekozen om gebruik te maken van het videobeeld die de Kinect levert. Dit videobeeld is in kleur en heeft een resolutie van 640 bij 480 pixels. Deze resolutie is groot genoeg om mijn voertuig te detecteren op enkele meters afstand. Aangezien in mijn geval de afstand tussen het bord en de Kinect circa 1.40 -1.60 meter is voldoet deze resolutie aan de gewenste nauwkeurigheid. Om het voertuig te onderscheiden heb ik gekozen om op mijn voertuig een rood velletje te plaatsen. Rood is namelijk een ‘harde’ kleur en is relatief makkelijker te onderscheiden met een RGB waarde. In mijn algoritme ben ik dus op zoek naar een ‘rode’ vlek in het beeld.
Na het downloaden en installeren van de SDK voor de Kinect kan je eenvoudig met C# de sensoren van de Kinect uitlezen. Met behulp van een AllFramesReady-Event (een event die wordt opgeroepen wanneer de beelden val alle sensoren tegelijkertijd klaar zijn) vang ik het ColorFrame op (een kleuren plaatje) van de CMOS sensor ( sensor om afbeelding te kunnen maken). Om deze ColorFrame uit te lezen moet ik het eerst converteren naar een byte array. Zo heb ik alle bytes die de afbeelding omschrijven in één verzameling. De Kinect maakt gebruik van RGBA waardes om de kleur van een enkele pixel te beschrijven. RGBA staat voor Red, Green, Blue en Alpha. Dit betekent dus dat het byte array 640*480*4 = 1228800 bytes bevat waarvan elke vier bytes bij elkaar de kleur van één pixel omschrijven.
In mijn algoritme zoek ik naar rode pixels. Deze pixels worden ‘goedgekeurd’ aan de hand van de RGBA waarde . Natuurlijk zit hier een marge op om het fluctueren van de lichtsterkte op het bord op te vangen. Door de meest geringe licht verandering kan een RGBA waarde namelijk sterk veranderen. Ondanks deze marge is te zien dat sommige pixels in het ene ColorFrame wel wordt goed gekeurd en in het andere ColorFrame niet. hierdoor krijg je gerafelde zijden aan de rand van het voertuig. Daarom heb ik ervoor gekozen om op blokniveau te gaan werken. In mijn algoritme deel ik mijn beeld in in blokken van tien bij tien pixels. Minstens 80% (oftewel 80 pixels) moeten rood zijn om de desbetreffende blok als rood te markeren. Hierdoor is het verspringen van pixels of blokken minimaal geworden.
Omdat er nergens anders op het bord rode vlakken zijn die eventueel goedgekeurd zouden kunnen worden ga ik er dus vanuit dat de gevonden blokken bij elkaar moeten liggen. in een later stadium van mijn programma zal dit wel worden bepaald. Van alle rode blokken neem ik de uiterste coördinaten. Om visueel aan te geven welke waardes het programma heeft gevonden laat ik mijn algoritme een vierkant tekenen in het byte array om de twee uiterste waardes heen. Verder reken ik aan de hand van deze uiterste coördinaten het middelpunt uit. Dit middelpunt neem ik als huidige positie van het voertuig.
Echter, er kunnen aan een positie alleen geen route berekeningen gedaan worden aangezien er geen strikte weg gevolgd moet worden ( het gehele terrein kan gebruikt worden voor manoeuvres). Om de benodigde stuurrichting te bepalen moet de draaihoek van het voertuig bekend zijn. Ook is het belangrijk om te weten wat de voor en achterkant is. Daarom heb ik twee extra kleuren geïntroduceerd; één voor de voorkant en één voor de achterkant. Op het rode vlak zijn dus twee kleine vlakjes geplakt met een andere kleur. Op dit moment is dat blauw en wit. Deze vlakjes zijn ongeveer net zo groot als een virtueel blok van tien bij tien pixels. Hierdoor ontstond het verspring effect weer: Als het witte of blauwe vlakje precies tussen twee virtuele blokken in lag werd telkens een ander blok goedgekeurd. Dit zorgt voor een onnauwkeurige meting van de draaihoek wat een belangrijk gegeven is voor het sturen van het voertuig. Om deze nauwkeurigheid te vergroten zoekt het algoritme in het getekende vierkant naar blauwe en witte blokken van vijf bij vijf pixels in plaats van naar blokken van tien bij tien pixels. Van deze gevonden blokken wordt het gemiddelde berekend per kleur. Vervolgens wordt met behulp van de twee gevonden coördinaten de draaihoek berekend. De afbeelding wordt dus geanalyseerd met twee detailniveaus: eerst grof om het voertuig te vinden en vervolgens nauwkeuriger in het vierkant om de hoek te bepalen.
Hieronder is een screenshot te zien van het programma wat op de computer draait. Normaal gesproken hangt de Kinect iets hoger en dus is het beeld wat de camera kan zien ‘meer uitgezoomd’ dan hier nu te zien is. Het rode blokje geeft de gewenste locatie aan. De twee groene vlakjes geven de uiterste hoeken aan van de gevonden rode blokjes en de licht blauwe vlakken geven de markeringen aan die op het voertuig zijn aangebracht. Deze kleuren worden over de originele afbeelding heen getekend.
“Connection Tab”
Hierin staat de connect button om verbinding te maken met het voertuig via Bluetooth. Wanneer er een verbinding is verdwijnt de connect-button en verschijnt er een diconnect-button.
Om verbinding te maken zal het programma een seriële poort aan maken. Vervolgens zal hij een handshake-poging uitvoeren om te controleren of de verbinding bruikbaar is. Indien de handshake succesvol is zal het programma in staat zijn commando’s te sturen over deze verbinding.
“Speed Value”
Aan de hand van deze slider is de begin waarde van de motoren aan te passen. Hoe hoger de waarde met hoe meer kracht hij zal starten. Hoe hoger de waarde gekozen word hoe groter de afwijking in het begin zal zijn ( de motoren hebben een afwijken van meer dan 20 procent ). Wanneer de startwaarde laag is zal het programma de kracht beter uitbalanceren omdat een afwijking vroegtijdig wordt aangepast. Indien er over wordt gegaan op handmatige besturing is een hoge waarde wel aan te raden anders komt het voertuig mogelijk niet van zijn plaats.
“Drive to Point”
Onder deze tab zijn drie buttons te vinden. Wanneer op “Start” wordt gedrukt zal het voertuig zich gaan verplaatsen naar zijn doel. “Force Stop” zal het voertuig laten stoppen en “Reset” zal de ingevoerde waarden weer 0 maken.
“Current position”
Huidige positie van het voertuig
“Destination”
Doel coördinaat, deze kan worden gekozen door met de muis te klikken op het beeld van de Kinect die erboven wordt weergeven. Visueel zal het programma een rood blokje tekenen op dit coördinaat.
“Level of Detail”
Detail niveau waarop moet worden geanalyseerd en getekend. Gekozen kan worden tussen blokken van 5, 10 of 20 pixels breed.
“Current Angle”
Huidige draaihoek van het voertuig. In dit geval staat het voertuig precies recht en horizontaal ten opzichte van de Kinect en dus is de hoek 0 graden.
“Destination Angle”
Hoek ten opzichte van het doel coördinaat
“Calculation Speed”
Snelheid van het analyseren van één frame
“Offset Top & Bottom”
Indien het beeld groter is dan het bord kan er een marge worden ingesteld. Deze marge wordt zwart getekend in de afbeelding en zal niet meegenomen worden in de analyse.
The post Autonoom parkeren – Detectie algoritme & Programma appeared first on ICT Blog.
