Sterrenherkenning met behulp van Computer Vision (OpenCV) - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Deze instructable beschrijft hoe u een computervisieprogramma kunt maken om automatisch sterpatronen in een afbeelding te identificeren. De methode gebruikt de OpenCV-bibliotheek (Open-Source Computer Vision) om een reeks getrainde HAAR-cascades te creëren die kunnen worden gebruikt om specifieke sterpatronen te herkennen. Hoewel deze gids in de context van sterpatroonherkenning is, kan het OpenCV-proces dat ik beschrijf ook worden toegepast op andere toepassingen - dus hopelijk zal het nuttig zijn!

Het project wordt samengevat in deze video:

Waarom heb ik dit instructable geschreven?

1. De identificatiemethode voor sterpatronen die ik aan het ontwikkelen ben, kan volgens mij worden toegepast op een breed scala aan amateurastronomieprojecten - of dat nu telescooporiëntatie, automatische beeldclassificatie of zelfs uiteindelijk een stersensor op een open source of amateur CubeSat is.
2. Er zijn hier veel goede OpenCV-instructables, maar toch vond ik het in eerste instantie een heel moeilijk proces om te leren, dus ik hoop dat deze gids een goede referentie zal zijn voor andere mensen die HAAR-classifiers voor OpenCV willen trainen (niet per se te maken met astronomie misschien!).
3. Ik ben zelf geen getrainde programmeur, dus dit project heeft mijn begrip enorm vergroot. Hopelijk zullen door het schrijven van dit Instructable andere, meer ervaren, makers worden geïnspireerd om aan dit concept te werken en bij te dragen aan de GitHub en dit instructable via opmerkingen op deze pagina.
4. Amateurastronomie en oriëntatiemethoden zijn een grote interesse van mij, zie mijn vorige instructable met een Arduino Star-Finder voor telescopen.

De omslagfoto van deze Instructable is van een concept 3U CubeSat-ontwerp waaraan ik heb deelgenomen. Ik gebruikte het om dit instructable te illustreren, aangezien de oorspronkelijke toepassing van het computer vision-sterherkenningssysteem een oriëntatiesensor voor amateur-gemaakte CubeSats zou zijn, met behulp van een Raspberry Pi V2-camera. Er zijn veel andere potentiële toepassingen van computervisie-sterherkenning, geloof ik, maar ik denk dat dit de coolste is!

Een kleine woordenlijst:

Leren over computervisie wordt langzamer gemaakt door de stomme hoeveelheid specialistische termen die worden gebruikt, dus ik zal er hier een aantal voor ons definiëren:

Cascade - Een classifier die is getraind om een specifiek doelobject te identificeren.

Fiducial Marker - Een markering die een visueel referentiepunt aan een afbeelding toevoegt.

HAAR - Haarachtige kenmerken zijn een type afbeelding dat wordt gebruikt voor classificatietraining.

OpenCV - Open Source Computer Vision, een bibliotheek met tools voor computervisie.

Stellarium - Open Source astronomiesoftware.

Stap 1: Vereisten

OpenCV is een op Linux gebaseerde bibliotheek, dus hoewel het zogenaamd mogelijk is om het goed op Windows te gebruiken, zul je het veel gemakkelijker hebben om het in een Linux-omgeving te gebruiken (neem dit van mij aan en een heleboel dagen proberen om het volledig te laten werken op Ramen!). Als experiment heb ik OpenCV gedownload en uitgevoerd op mijn Raspberry Pi 3B+, wat succesvol was, hoewel classificatietraining een zeer RAM-intensief proces is, dus als je het op elke snelheid wilt doen, is de aanbevolen route om een Linux Virtual Server te huren (wat eigenlijk verrassend goedkoop kan zijn) voor een paar dagen/weken/maanden en gebruik dat als een speciale omgeving om de classificatietraining uit te voeren. U kunt de server besturen vanaf een Windows-pc met behulp van een SSH-client zoals Putty. Nadat de cascades zijn getraind met behulp van de VPS, kunnen ze worden gedownload naar uw Windows-pc en kan Python worden gebruikt om het beeldherkenningsprogramma in een Windows-omgeving uit te voeren.

Linux virtuele server:

Een Linux Virtual Server (VPS) is nodig om de HAAR-cascadetrainingsprocessen uit te voeren. Aanvankelijk huurde ik een server met 8 GB RAM en Ubuntu 16.04.6 (LTS) x64, en later een tweede om de snelheid te verdubbelen waarmee ik cascades kon trainen, hoewel je er maar minimaal één nodig hebt

Software:

• Stellarium - dit is virtuele planetarium-/astronomiesoftware, vrij verkrijgbaar. Het zal worden gebruikt om gesimuleerde sterbeelden te verzamelen voor gebruik bij het testen.
• Putty - Dit is een SSH-client die wordt gebruikt om de VPS via de opdrachtregel te besturen.
• WinSCP - dit wordt gebruikt om bestandsoverdracht uit te voeren vanaf de Windows-pc.

Stap 2: VPS-configuratie

Er is een klein installatieproces om de VPS in gebruik te nemen. De eerste keer kan het even duren voor je, maar het is niet al te lastig als je de stappen nauwkeurig volgt. Deze tutorial was een geweldige referentie voor mij, ik zou je aanraden dit ook te lezen terwijl je aan deze instructable werkt. Het behandelt de details van de linux-commando's regel voor regel, wat nodig is om tot op de letter te volgen.

Het proces omvat grofweg:

1. Creatie van Linux-server met de juiste Ubuntu-versie.
2. Upgraden en bijwerken van de server.
3. Creatie van een werkruimtemap, waarin OpenCV wordt geïnstalleerd.
4. Installatie van enkele essentiële zaken, namelijk een compiler, verschillende bibliotheken en Python-bindingen.

Na deze fase ben je klaar om je voor te bereiden op het trainingsproces.

Stap 3: Het proces

Het hele proces van computervisie met HAAR-cascades is in het begin nogal verwarrend, dus deze stap beschrijft de logica in iets meer detail:

Basisproces

1. Er bestaat een dataset met negatieve afbeeldingen, bestaande uit enkele duizenden afbeeldingen die het object van interesse niet bevatten. Dit moet worden geüpload naar de VPS.
2. Er wordt één enkel positief beeld gecreëerd dat het object van belang bevat. Dit moet ook worden geüpload naar de VPS.
3. Het enkele positieve beeld wordt vervormd, kromgetrokken, geroteerd, enz. door een reeks gekozen parameters en over een selectie van de negatieve beelden gelegd. Dit is een kunstmatige manier om uit één afbeelding een grote positieve dataset te maken. (Voor andere toepassingen in de echte wereld, zoals het identificeren van een kat, kunt u eenvoudig enkele duizenden afbeeldingen van katten gebruiken, maar deze methode is niet altijd geschikt als u niet zo'n groot aantal positieve afbeeldingen hebt. De kunstmatige benadering die hier wordt gebruikt zal minder effectief zijn, maar het is de enige optie voor een use-case als deze).
4. Er wordt een trainingsproces doorlopen, dat in fasen werkt. Elke fase zal een cascade trainen om verschillende HAAR-achtige kenmerken binnen de afbeeldingensets te identificeren. Elke fase duurt exponentieel langer om te voltooien en de effectiviteit van de classifier neemt elke keer toe (het is ook mogelijk om te overtrainen, zodat je het weet!).
5. Een enkele getrainde cascade zal in staat zijn om naar een enkel doelobject te zoeken. Als u meerdere unieke objecten wilt identificeren, heeft u voor elk een getrainde cascade nodig. In dit geval heb ik ongeveer 50 verschillende cascades getraind voor unieke sterpatronen, om een set te creëren die het noordelijk hemelhalfrond zou kunnen bestrijken.
6. Ten slotte wordt een detectieprogramma gebruikt dat elke cascade van een set tegen een invoerbeeld uitvoert. De cascade zoekt naar het opgegeven doelobject in de invoerafbeelding.
7. Als dit lukt, wordt het doelobject geïdentificeerd in de invoerafbeelding.

nb als het bijvoorbeeld wordt gebruikt in een satellietoriëntatiecontext, zou een beeld worden vastgelegd met een camera aan boord. De helderste sterren in die afbeelding zullen worden geïdentificeerd en er zullen markeringen op die posities worden aangebracht. Dit beeld wordt vervolgens gepresenteerd aan de reeks getrainde cascades, die zal testen om te zien of het invoerbeeld een van de doelobjecten bevat. Als een echte positieve wordt gedetecteerd, wordt de hoekpositie van een bekende constellatie ontdekt ten opzichte van de assen van het satellietlichaam.

Stap 4: Negatieven en positieven

minpunten

Een echt belangrijk aspect van cascadetraining is om een zo groot mogelijke dataset met negatieve beelden te hebben. We hebben het over duizenden, idealiter tienduizenden afbeeldingen. Het maakt niet echt uit wat ze bevatten, het doel is alleen om een verscheidenheid aan visuele informatie te bieden. De map Classifier Training bevat een verscheidenheid aan verschillende negatieve afbeeldingsdatasets die ik heb samengesteld. Aanvankelijk bestonden deze uitsluitend uit gesimuleerde sterrenveldafbeeldingen die waren verzameld uit Stellarium, maar later heb ik de dataset uitgebreid met zoveel gerandomiseerde afbeeldingen als ik kon vinden (ja, inclusief mijn vakantiefoto's …). De grootste dataset daar bevat bijna 9000 afbeeldingen, de grootste die ik tot nu toe heb gemaakt. Door dit te gebruiken, bespaart u het zelf samenstellen.

Positieven

Het positieve beeld (dat is het doelsterpatroon dat de cascade zal leren herkennen) begint als een screenshot van een sterpatroon in Stellarium. Een python-programma identificeert vervolgens de helderste sterren in de afbeelding en plaatst markeringen (later uitgelegd in deze instructie) op deze sterposities. Deze afbeelding wordt vervolgens verkleind tot 50x50 pixels. Dit is klein, maar de trainingstijd die nodig is voor de cascades zal exponentieel toenemen naarmate deze omvang toeneemt, en dit is dus een goed compromis tussen kwaliteit en tijd.

Stap 5: Stellarium-besturing

De map Stellarium Scripts van de GitHub-repository bevat drie programma's die ik heb geschreven om het gebruik van Stellarium te regelen. Om ze te gebruiken, plaatst u ze in de scriptmap van uw Stellarium-installatiemap. Om ze uit te voeren, kunt u het scriptvenster openen vanuit het Stellarium-menu, of gewoon door te dubbelklikken op het programma in de scriptmap, waardoor Stellarium wordt gestart en het geselecteerde programma onmiddellijk wordt uitgevoerd.

thesis_4 en thesis_5 leggen ongeveer 2000 beelden vast, elk van de respectievelijke noordelijke en zuidelijke hemelhelften. Deze werden gebruikt om databases van negatieve beelden te vormen, om het positieve beeld tegen te trainen. Het onderscheid tussen noord en zuid was een eenvoudige manier om ervoor te zorgen dat het beoogde (positieve) sterpatroon niet aanwezig zou zijn in de negatieve dataset door sterpatronen op het noordelijk halfrond te trainen tegen de afbeeldingsdataset van het zuidelijk hemelhalfrond en vice versa. (Als er ook een positieve afbeelding aanwezig is in de negatieve afbeeldingsgegevensset, heeft dit invloed op de kwaliteit van de classificatie).

thesis_setup is ook handig - dit stelt Stellarium in om geschikt te zijn voor het vastleggen van afbeeldingen - de afbeeldingen die worden gebruikt om een uitzicht vanuit de ruimte te simuleren. Het voert automatisch acties uit zoals het verbergen van menu's, rasterlijnen, labels, enz. om u te besparen elke keer dat u een afbeelding wilt pakken.

Stap 6: Rocket Man

De eerste cascades die ik trainde, waren niet in staat om sterpatronen correct te identificeren. Ze waren erg onbetrouwbaar en waren erg vatbaar voor valse positieven. Mijn veronderstelling was dat de sterrenveldbeelden van Stellarium (eigenlijk alleen maar witte stippen op een zwarte achtergrond) in feite niet voldoende visuele informatie bevatten om genoeg HAAR-achtige kenmerken te bevatten voor een succesvolle classificatietraining. Ik denk dat het laat in de nacht was, maar ik besloot het idee uit te proberen om een programma te schrijven om automatisch een kleine miniatuurafbeelding over de locatie van elke heldere ster in een sterveldafbeelding te plaatsen.

Elton

Dit was een domme test, maar door een kleine foto van Elton John's gezicht toe te voegen aan elke heldere sterlocatie, de classifier te trainen tegen dit positieve beeld en vervolgens de cascades tegen het originele beeld te laten lopen, was het veel effectiever om de juiste juiste patroon. Ik wist dat ik iets op het spoor was!

Stap 7: vaste markeringen

Hoewel de 'Eltons' de theorie bewezen, had ik een markering nodig die volledige rotatiesymmetrie had, zodat het sterpatroon er hetzelfde uit zou zien, ongeacht in welke richting het werd gepresenteerd. Ik heb een reeks markertypes getest en ontdekte dat het type rechtsonder het meest effectief was, met de contrasterende zwart-witte ringen. Het python-programma dat wordt gepresenteerd in de positieve map van de GitHub-repo laat zien hoe de helderste sterren in een bepaalde afbeelding worden geïdentificeerd, en deze markeringen worden automatisch over die posities gelegd. We hebben nu een weergave gemaakt van de belangrijkste sterpatronen waartegen getraind kan worden.

Stap 8: De Cascades gebruiken

Als je een reeks cascades hebt getraind, moet je weten hoe je ze kunt gebruiken om een object in een afbeelding te identificeren!

Kijk in de map Star Identification van de GitHub, waar je het programma cascade_test19.py vindt. Dit programma met de pakkende naam haalt een reeks cascades uit een bepaalde map en voert ze allemaal uit tegen een invoerbeeld en rapporteert over de gemaakte detecties. De functie 'detectMultiScale' is de kern hiervan en er zijn verschillende argumenten voor nodig die het detectieproces definiëren. Het wijzigen hiervan is van cruciaal belang voor de prestaties van de cascadeclassificatie, en meer discussie hierover vindt u in de volgende stap, waar we bekijken hoe u valse positieven kunt elimineren.

Dit zou kunnen worden toegepast in een satellietoriëntatiesysteem door de pixelwaarde in het midden van het begrenzingsvak te correleren met de Ra/Dec-hemelcoördinaat van het geïdentificeerde sterpatroon, en dit vervolgens te correleren met de hoekverplaatsing vanuit het midden van het beeld (camera as). Hieruit kan, met behulp van begrip van de lensvervorming (benaderd tot een gnomonische projectie), de hoek van de satelliet worden gevonden uit slechts twee positieve identificaties.

Stap 9: Hoe positief te blijven over valse positieven?

Deze twee afbeeldingen tonen de resultaten van het testen van de cascadeset tegen een identieke afbeelding, maar met verschillende parameters. Het is duidelijk dat de eerste afbeelding de echte identificatie bevat, maar ook een enorm aantal valse positieven, terwijl de tweede afbeelding alleen de juiste identificatie bevat.

Het programma cascade_test19.py in de map Star Identification van de GitHub-repo gebruikt twee methoden om de resultaten te sorteren. Ten eerste stelt de detectMultiScale-functie een minimum- en maximumgrootte van het resultaat in dat kan worden gevonden, wat logisch is, aangezien de geschatte grootte van het doelsterpatroon binnen het venster (voor de gegeven lens en vergroting - mijn gesimuleerde Stellarium-afbeeldingen gebruiken de eigenschappen van de Raspberry Pi V2 Camera) bekend is. Ten tweede selecteert de code het resultaat met het grootste selectiekader (binnen de vorige limieten). Bij het testen bleek dit het echte positieve te zijn. Ten derde stelt het programma een minimum 'levelWeights' (effectief 'betrouwbaarheidswaarde') in die vereist is om deze ID als een echt positief te behandelen. Door deze methode waren de cascades effectief in het vinden van het juiste resultaat.

Naast de afbeeldingen van het sterrenveld heb ik dit ook getest met foto's van mijn bureau, bijvoorbeeld, waarbij ik cascades trainde om mijn notitieboekje, mok enz. te identificeren, om te oefenen met het elimineren van valse positieven. De bovenstaande methoden werkten onder alle omstandigheden goed, wat bemoedigend was.

Stap 10: Discussie

Gebieden voor verbetering

Dit is een complex project voor mij geweest en heeft mijn begrip van het onderwerp echt vergroot. Het heeft in totaal enkele maanden bijna fulltime werk gekost om het project zover te krijgen dat ik het met u kan delen, maar er is nog veel meer werk te doen om de prestaties van de methode te verbeteren. Zoals het er nu uitziet, kan het goed functioneren binnen bepaalde beperkingen. Ik heb geprobeerd vast te stellen op welke gebieden extra werk nodig is, en hopelijk kan ik daar de komende maanden tijd aan besteden. Zij zijn:

Hoek - Dit is een complex gebied, het idee dat de resultaten van de classifiers rotatie-invariant moeten zijn, d.w.z. het moet betrouwbaar het doelsterpatroon identificeren, ongeacht de hoek waaronder het wordt gepresenteerd van het beeld dat het doelsterpatroon bevat. Een cascade die is getraind met behulp van een invoerbeeld in een enkele oriëntatie, kan dat beeld niet in willekeurige oriëntaties identificeren, dus er moet een variantie van de positieve beeldhoek in het trainingsproces worden geïntroduceerd om cascades te trainen die een bereik op invoerhoeken kunnen accepteren. De parameter 'maxzangle' in de cascade-trainingscommando's neemt een argument in radialen, dat een limiet regelt van de hoek waarin het ingevoerde positieve beeld zal worden overlapt op de geleverde negatieve beelden, dus de resulterende positieve beeldset zal een reeks oriëntaties bevatten van het positieve imago. Echter, naarmate deze maxzangle toeneemt, zal de acceptatieratio (in het algemeen kwaliteit) van de cascade sterk afnemen. Ik denk dat de oplossing is om cascades te trainen met behulp van een aanzienlijk grotere database met negatieve afbeeldingen dan ik gebruikte om ervoor te zorgen dat een cascadeclassificatie van goede kwaliteit kan worden gemaakt, zelfs met een grote oriëntatiespreiding.

Een andere mogelijke oplossing zou zijn om een aantal cascades te trainen voor een specifiek doel, waarbij elke cascade een bepaald deel van een volledige 360 graden rotatie regeert. Op die manier kan de kwaliteit van elke cascade op een hoog niveau worden gehouden, maar aan de andere kant zal dit resulteren in veel meer cascades, en dus zal het identificatieproces langzamer verlopen.

De parameter 'levelWeight', een waarde die wordt geleverd door de functie 'detectMultiScale', is analoog aan een betrouwbaarheidswaarde in de uitgevoerde detectie. Door dit te bestuderen, werd de bovenstaande grafiek gemaakt, die laat zien hoe het vertrouwen van positieve identificatie sterk afneemt naarmate de oriëntatie van het beeld in beide richtingen toeneemt, wat de gedachten bevestigt dat dit een zwak punt is.

Pixelplaatsing - Een veel eenvoudiger, maar ook problematisch punt is dat van de pixelplaatsing, geïllustreerd door de volgende twee afbeeldingen, die een vergrote weergave van een sterafbeelding tonen, zodat de afzonderlijke pixels van twee sterren duidelijk te zien zijn. Het erosieproces dat in het programma wordt gebruikt om alle sterren, behalve de helderste, van de afbeelding te verwijderen, houdt de eerste ster en verwijdert de tweede, ondanks dat ze even helder zijn. De reden hiervoor is dat de eerste ster gecentreerd is op een pixel, terwijl de tweede dat niet is. De erosiefunctie verwijdert concentrische ringen van pixels rond de centrale pixel van een groep, en dus zal de eerste ster de centrale pixel de erosiefunctie laten overleven, maar de tweede ster zal volledig uit het beeld worden verwijderd. Daarom worden referentiemarkeringen alleen op de eerste ster geplaatst, en niet op de tweede. Dit zal inconsistenties veroorzaken met betrekking tot welke heldere sterren in een bepaald sterrenveld markers zullen ontvangen (en dus worden vergeleken met de getrainde classifiers) - daarom is het mogelijk dat een juiste positieve waarneming niet mogelijk zal zijn.

Stap 11: Laatste woord

Bedankt voor het lezen van mijn instructable, ik hoop dat je dit project intrigerend vond. Het was een heel interessant proces om eraan te werken, het is meer dan een jaar geleden dat ik aan het concept begon te werken, en ik ben bemoedigd door de resultaten tot nu toe. Uit de literatuur die ik heb gelezen, is dit een vrij origineel concept, en met meer ontwikkeling kan het zeker worden toegepast in een reeks toepassingen voor amateurastronomie of meer.

Dit project was een steile leercurve voor mij, en daarom hoop ik dat sommige lezers met meer programmeerervaring geïnspireerd kunnen worden om bij te dragen aan de voortzetting van het project via de GitHub-pagina, en we kunnen doorgaan met het ontwikkelen van deze open-source tool. Ik kijk ernaar uit om eventuele opmerkingen te lezen, maar stel alsjeblieft niet te veel moeilijke vragen!

Tweede plaats in de ruimte-uitdaging