Star Recognition Using Computer Vision (OpenCV): 11 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:39

Denna instruktör kommer att beskriva för dig hur du skapar ett datorvisionsprogram för att automatiskt identifiera stjärnmönster i en bild. Metoden använder biblioteket OpenCV (Open-Source Computer Vision) för att skapa en uppsättning utbildade HAAR-kaskader som kan användas för att känna igen specifika stjärnmönster. Även om den här guiden är i samband med stjärnmönsterigenkänning, kan OpenCV -processen jag beskriver tillämpas även på andra applikationer - så det kommer förhoppningsvis att vara användbart!

Projektet sammanfattas i denna video:

Varför skrev jag detta instruerbart?

1. Jag tror att den metod för identifiering av stjärnmönster som jag utvecklar har potential att tillämpas på ett brett spektrum av amatörastronomiprojekt - oavsett om det är teleskoporientering, automatisk bildklassificering eller till och med en stjärnsensor på en öppen källkod eller amatör CubeSat.
2. Det finns många bra OpenCV -instruktioner här, men trots det tyckte jag att det var en mycket svår process att lära sig inledningsvis, så jag hoppas att den här guiden kommer att vara en bra referens för andra som vill träna HAAR -klassificerare för OpenCV (inte nödvändigtvis att göra med astronomi kanske!).
3. Jag är inte utbildad programmerare själv, så det här projektet drev verkligen min förståelse. Förhoppningsvis genom att skriva detta instruerbara andra, mer erfarna skapare kommer att inspireras att arbeta med detta koncept och bidra till GitHub och detta instruerbart via kommentarer på denna sida.
4. Amatörastronomi och orienteringsmetoder är ett stort intresse för mig, se min tidigare instruerbara med en Arduino Star-Finder för teleskop.

Omslagsfotot av denna Instructable är av en koncept 3U CubeSat -design som jag deltog i designen av. Jag använde den för att illustrera detta instruerbart eftersom den ursprungliga tillämpningen av datorsynstjärnigenkänningssystemet skulle vara för en orienteringssensor för amatörtillverkade CubeSats, med en Raspberry Pi V2-kamera. Jag tror att det finns många andra potentiella applikationer för datorigenkänning, men jag tycker att det här är det coolaste!

En liten ordlista:

Att lära sig om datorsyn görs långsammare av den dumma mängden specialtermer som används, så jag ska definiera några för oss här:

Cascade - En klassificerare som är utbildad för att identifiera ett specifikt målobjekt.

Fiducial Marker - En markör som lägger till en visuell referenspunkt till en bild.

HAAR - Haarliknande funktioner är en typ av bildfunktion som används för klassificeringsträning.

OpenCV - Open Source Computer Vision, ett bibliotek med datorsynverktyg.

Stellarium - Astronomiprogramvara med öppen källkod.

Steg 1: Krav

OpenCV är ett Linux -baserat bibliotek, så även om det förmodligen är möjligt att använda det bra på Windows, kommer du att ha mycket lättare att köra det i en Linux -miljö (ta detta från mig och många dagar försöker få det att fungera fullt ut Windows!). Som ett experiment laddade jag ner och körde OpenCV på min Raspberry Pi 3B+, vilket var framgångsrikt, även om klassificeringsträning är en mycket RAM -intensiv process, så om du vill göra det i vilken hastighet som helst, är den rekommenderade vägen att anlita en Linux Virtual Server (vilket faktiskt kan vara förvånansvärt billigt) i några dagar/veckor/månader och använd det som en dedikerad miljö för att köra klassificeringsträningen. Du kommer att kunna styra servern från en Windows -dator med en SSH -klient som Putty. När kaskaderna har tränats med VPS kan de laddas ner till din Windows -dator och Python kan användas för att köra bildigenkänningsprogrammet i en Windows -miljö.

Linux virtuell server:

En Linux Virtual Server (VPS) behövs för att utföra HAAR -kaskadträningsprocesser. Ursprungligen anställde jag en server med 8 GB RAM och Ubuntu 16.04.6 (LTS) x64, och senare en andra för att fördubbla hastigheten med vilken jag kunde träna kaskader, även om du bara behöver minst en

Programvara:

• Stellarium - det här är virtuellt planetarium/astronomi programvara, fritt tillgängligt. Den kommer att användas för att samla simulerade stjärnbilder för användning vid testning.
• Kitt - Detta är en SSH -klient som används för att styra VPS via kommandoraden.
• WinSCP - detta används för att utföra filöverföring från Windows -datorn.

Steg 2: VPS -installation

Det finns en liten installationsprocess för att få VPS igång. Första gången kan det ta ett tag för dig, men det är inte för svårt om du följer stegen noga. Denna handledning var en bra referens för mig, jag rekommenderar att du läser detta också medan du arbetar igenom det här instruerbara. Det täcker specifikationerna för linux -kommandona rad för rad, vilket är nödvändigt att följa till punkt och pricka.

I grova drag innebär processen:

1. Skapande av Linux -server med korrekt Ubuntu -version.
2. Uppgradering och uppdatering av servern.
3. Skapande av en arbetsyta -katalog där OpenCV är installerat.
4. Installation av några väsentliga saker, nämligen en kompilator, olika bibliotek och Python -bindningar.

Efter det här stadiet är du redo att börja förbereda dig för träningsprocessen.

Steg 3: Processen

Hela datorsynprocessen med HAAR -kaskader är ganska förvirrande först, så det här steget beskriver logiken lite mer detaljerat:

Grundläggande process

1. Det finns en negativ bilduppsättning som består av flera tusen bilder som inte innehåller objektet av intresse. Detta måste laddas upp till VPS.
2. En enda positiv bild skapas som innehåller objektet av intresse. Detta måste också laddas upp till VPS.
3. Den enda positiva bilden förvrängs, förvrängs, roteras etc. av en uppsättning valda parametrar och läggs över på ett urval av de negativa bilderna. Detta är ett artificiellt sätt att skapa en stor positiv dataset från en enda bild. (För andra verkliga applikationer, som att identifiera en katt, kan du helt enkelt använda flera tusen bilder av katter, men den här metoden är inte alltid lämplig om du inte har en så stor uppsättning positiva bilder. Det artificiella tillvägagångssättet som används här kommer att vara mindre effektiv, men det är det enda alternativet för ett användningsfall som detta).
4. En träningsprocess körs, som fungerar i etapper. Varje etapp kommer att träna en kaskad för att identifiera olika funktioner av HAAR-typ i bilduppsättningarna. Varje etapp tar exponentiellt längre tid att slutföra, och klassificerarens effektivitet ökar för varje gång (det är också möjligt att överträna bara så att du vet!).
5. En enda tränad kaskad kommer att kunna leta efter ett enda målobjekt. Om du vill identifiera flera unika objekt behöver du en utbildad kaskad för varje. I detta fall tränade jag cirka 50 olika kaskader för unika stjärnmönster, för att skapa en uppsättning som skulle kunna täcka norra himmelsfären.
6. Slutligen används ett detekteringsprogram som kör varje kaskad av en uppsättning mot en inmatningsbild. Kaskaden letar efter sitt givna målobjekt i inmatningsbilden.
7. Om det lyckas identifieras målobjektet i inmatningsbilden.

n.b. om den används i ett satellitorienteringssammanhang till exempel skulle en bild tas med en inbyggd kamera. De ljusaste stjärnorna i den bilden kommer att identifieras och markörer överlagras i dessa positioner. Denna bild presenteras sedan för uppsättningen utbildade kaskader, som testar om ingångsbilden innehåller något av målobjekten. Om en sann positiv detekteras, upptäcks vinkelpositionen för en känd konstellation i förhållande till satellitkroppens axlar.

Steg 4: Negativ och positiv

Negativ

En riktigt viktig aspekt av kaskadträning är att ha en så stor uppsättning negativa bilder som möjligt. Vi pratar tusentals, helst tiotusentals bilder. Det spelar egentligen ingen roll vad de innehåller, målet är bara att ge olika visuella uppgifter. Classifier Training -mappen innehåller en mängd olika negativa bilddatauppsättningar som jag har sammanställt. Ursprungligen bestod dessa enbart av simulerade stjärnfältbilder hämtade från Stellarium, men jag utökade senare datauppsättningen med så många randomiserade bilder som jag kunde hitta (ja, inklusive mina semesterbilder …). Den största datamängden där innehåller nästan 9000 bilder, vilket var den största jag har skapat hittills. Genom att använda detta sparar du dig att kompilera dina egna.

Positiva

Den positiva bilden (det är målstjärnmönstret som kaskaden tränas att känna igen) börjar som en skärmdump av ett stjärnmönster i Stellarium. Ett pythonprogram identifierar sedan de ljusaste stjärnorna i bilden och överlagrar markörer (förklaras senare i denna instruerbara) på dessa stjärnpositioner. Denna bild krymps sedan till 50x50 pixlar. Detta är litet, men träningstiden som krävs för kaskaderna kommer att öka exponentiellt när denna storlek ökar, och det är därför en bra kompromiss mellan kvalitet och tid.

Steg 5: Stellarium Control

Stellarium Scripts -mappen i GitHub -förvaret innehåller tre program som jag skrev för att styra användningen av Stellarium. Om du vill använda dem placerar du dem i skriptmappen i din Stellarium -installationsmapp. För att köra dem kan du öppna skriptfönstret från Stellarium -menyn, eller bara genom att dubbelklicka på programmet i skriptmappen, vilket startar Stellarium och omedelbart kör det valda programmet.

avhandling_4 och avhandling_5 tar cirka 2000 bilder var och en av de norra respektive södra, himmelska halvklotet. Dessa användes för att bilda databaser med negativa bilder, för att träna den positiva bilden mot. Skillnaden mellan norr och söder var ett enkelt sätt att säkerställa att målet (positivt) stjärnmönster inte skulle finnas i den negativa datamängden genom att träna stjärnmönster på norra halvklotet mot södra himmelsfärs bilduppsättning och vice versa. (Om en positiv bild också finns i den negativa bilduppsättningen påverkar det klassificerarens kvalitet).

thesis_setup är också användbart - detta ställer in Stellarium för att vara lämpligt för att ta bilder - bilderna som används för att simulera en vy från rymden. Det gör åtgärder som att dölja menyer, rutnät, etiketter etc automatiskt för att du inte behöver varje gång du vill ta en bild.

Steg 6: Rocket Man

De första kaskaderna jag tränade kunde inte korrekt identifiera några stjärnmönster. De var mycket opålitliga och var mycket benägna att falska positiva. Mitt antagande var att stjärnfältbilderna från Stellarium (i princip bara vita prickar på svart bakgrund) inte innehöll tillräckligt med visuell information för att innehålla tillräckligt med funktioner av HAAR-typ för framgångsrik klassificeringsträning. Jag tror att det var sent på kvällen, men jag bestämde mig för att prova tanken på att skriva ett program för att automatiskt placera en liten miniatyrbild över platsen för varje ljus stjärna i en stjärna fältbild.

Elton

Detta var ett dumt test, men genom att lägga till en liten bild av Elton Johns ansikte till varje ljusstjärneställe, träna klassificeraren mot denna positiva bild och sedan köra kaskaderna mot originalbilden, var det mycket mycket mer effektivt att korrekt hitta rätt mönster. Jag visste att jag var på något!

Steg 7: Fiducial Markers

Även om 'Eltons' bevisade teorin, behövde jag en markör som hade full rotationssymmetri, så att stjärnmönstret skulle se likadant ut oavsett i vilken orientering det presenterades. Jag testade en rad markörtyper och fann att typen längst ner till höger var mest effektiv med de kontrasterande svarta och vita ringarna. Pythonprogrammet som presenteras i den positiva mappen i GitHub -repot visar hur de ljusaste stjärnorna i en given bild identifieras, och dessa markörer överlagras automatiskt i dessa positioner. Vi har nu skapat en representation av de nyckelstjärnmönster som kan tränas mot.

Steg 8: Använda kaskaderna

När du har tränat en uppsättning kaskader måste du veta hur du använder dem för att identifiera ett objekt i en bild!

Titta på mappen Star Identification i GitHub, där du hittar cascade_test19.py -programmet. Detta fängslande program tar en uppsättning kaskader från en given mapp och kör dem alla mot en inmatningsbild och rapporterar om upptäckten som gjorts. Funktionen 'detectMultiScale' är kärnan i detta, och det krävs en mängd olika argument som definierar detekteringsprocessen. Att ändra dessa är avgörande för kaskadklassificatorns prestanda, och mer diskussion om detta finns i följande steg, där vi tittar på hur man eliminerar falska positiva.

Detta kan tillämpas i ett satellitorienteringssystem genom att korrelera pixelvärdet i mitten av avgränsningsrutan till Ra/Dec -himmelska koordinaten för det identifierade stjärnmönstret och sedan korrelera detta med vinkelförskjutningen från bildens mitt (kamera axel). Från detta, med hjälp av en förståelse av linsförvrängningen (approximerad till en gnonisk projektion), kan satellitens vinkel hittas från bara två positiva identifieringar.

Steg 9: Hur man håller sig positiv till falska positiva

Dessa två bilder visar resultaten av att testa kaskaduppsättningen mot en identisk bild, men med olika parametrar. Det är uppenbart att den första bilden innehåller den sanna identifieringen, men också ett enormt antal falska positiva, medan den andra bilden endast innehåller den korrekta identifieringen.

Cascade_test19.py -programmet i mappen Star Identification i GitHub -repo använder två metoder för att sortera resultaten. För det första ställer detectMultiScale -funktionen in ett Miminum- och Maximalt resultatstorlek som kan hittas, vilket är förnuftigt, eftersom den ungefärliga storleken på målstjärnmönstret i fönstret (för givet objektiv och förstoring - mina simulerade Stellarium -bilder använder egenskaperna för Raspberry Pi V2 Camera) är känd. För det andra kommer koden att välja resultatet med den största avgränsningsrutan (inom de tidigare gränserna). Vid testning befanns detta vara det sanna positiva. För det tredje anger programmet ett minimum 'levelWeights' (effektivt 'konfidensvärde') som krävs för att behandla detta ID som ett riktigt positivt. Med denna metod var kaskaderna effektiva för att hitta rätt resultat.

Förutom stjärnfältbilderna testade jag också detta mot bilder på mitt skrivbord, till exempel träningskaskader för att identifiera min anteckningsbok, mugg etc., för att träna på att eliminera falska positiva. Ovanstående metoder fungerade bra under alla omständigheter vilket var uppmuntrande.

Steg 10: Diskussion

Områden för förbättring

Detta har varit ett komplext projekt för mig och har verkligen drivit min förståelse av ämnet. Det har inneburit totalt flera månader nästan heltidsarbete för att få projektet till den här punkten när jag kan dela det med dig, men det finns mycket mer arbete att göra för att förbättra metodens prestanda. Som det ser ut kan det fungera bra inom vissa begränsningar. Jag har arbetat med att identifiera vilka områden som behöver ytterligare arbete och kommer förhoppningsvis att kunna lägga tid på att ta itu med dessa under de kommande månaderna. Dom är:

Vinkel - Detta är ett komplext område, tanken på att resultaten av klassificerarna måste vara rotationsvariant, dvs det ska tillförlitlighet identifiera målstjärnans mönster oavsett i vilken vinkel den presenteras vid bilden som innehåller målstjärnmönstret. En kaskad som tränas med en inmatningsbild i en enda orientering kommer inte att kunna identifiera den bilden i slumpmässiga riktningar, så variansen av den positiva bildvinkeln måste införas i träningsprocessen för att träna kaskader som kan acceptera ett intervall på inmatningsvinklar. Parametern 'maxzangle' i kaskadträningskommandona tar ett argument i radianer, som styr en gräns för vinkeln att den inmatade positiva bilden kommer att läggas över på de negativa bilderna som tillhandahålls, så den resulterande positiva bilduppsättningen kommer att innehålla en rad orienteringar av den positiva bilden. Men när denna maxzangle ökar kommer acceptansförhållandet (i stort sett kvalitet) för kaskaden att minska kraftigt. Jag tror att lösningen är att träna kaskader med en betydligt större databas med negativa bilder än vad jag använde för att säkerställa att en kaskadklassificerare av god kvalitet kan skapas även med en stor orienteringsspridning.

En annan potentiell lösning skulle vara att träna ett antal kaskader för ett specifikt mål, varje kaskad som styr en viss del av en fullständig 360 graders rotation. På så sätt kan kvaliteten på varje kaskad bibehållas på en hög nivå, men å andra sidan kommer detta att resultera i mycket fler kaskader, och därmed kommer identifieringsprocessen att bli långsammare.

Parametern 'levelWeight', som är ett värde som tillhandahålls av funktionen 'detectMultiScale', är analogt med ett konfidensvärde i detekteringen som har gjorts. Genom att studera detta skapades ovanstående graf, som visar hur förtroendet för positiv identifiering minskar kraftigt när bildens orientering ökar åt båda hållen, vilket bekräftar tankarna att detta är en svag punkt.

Pixelplacering - En mycket enklare men också problematisk punkt är pixelplacering, illustrerad av följande två bilder, som visar en förstorad vy av en stjärnbild, så att de enskilda pixlarna på två stjärnor kan ses tydligt. Erosionsprocessen som används i programmet för att skrubba alla utom de ljusaste stjärnorna från bilden kommer att behålla den första stjärnan och kasta den andra, trots att de är lika ljusa. Anledningen till detta är att den första stjärnan är centrerad på en pixel, medan den andra inte är som sådan. Erosionsfunktionen avlägsnar koncentriska ringar av pixlar från runt den centrala pixeln i en grupp, och så kommer den första stjärnan att få den centrala pixeln att överleva erosionsfunktionen, men den andra stjärnan kommer att tas bort helt från bilden. Därför kommer fiducial markörer endast att placeras på den första stjärnan, och inte den andra. Detta kommer att orsaka inkonsekvenser för vilka ljusa stjärnor i ett givet stjärnfält kommer att ta emot markörer (och därmed jämföras med de utbildade klassificerarna) - därför är det möjligt att en korrekt positiv observation inte är möjlig.

Steg 11: Sista ordet

Tack för att du läste min instruerbara, jag hoppas att du tyckte att detta projekt var spännande. Det har varit en mycket intressant process att arbeta med det, det har gått över ett år sedan jag började arbeta med konceptet, och jag är uppmuntrad av resultaten till denna punkt. Från den litteratur jag läst är detta ett ganska originellt koncept, och med mer utveckling kan det säkert tillämpas i en rad applikationer för amatörastronomi eller mer.

Detta projekt var en brant inlärningskurva för mig, och därför hoppas jag att några läsare med mer programmeringserfarenhet kan inspireras att bidra till projektets fortsättning via GitHub-sidan, och vi kan fortsätta att utveckla detta verktyg för öppen källkod. Jag ser fram emot att läsa alla kommentarer du kan ha, men snälla ställ inte för många svåra frågor!

Tvåa i Space Challenge