En nybörjarguide till bildbehandling med OpenCV och Python

Återutgiven av Platon

anhängare: 0

Denna artikel publicerades som en del av Data Science Blogathon

Beskrivning

Det kan vara mycket information gömd inuti en bild och vi kan tolka den på olika sätt och perspektiv. Så vad är en bild och hur hanterar man en bild? Med enkla ord kan vi säga att en bild är en visuell representation av något och den skulle lätt kunna hanteras med hjälp av datorseende (ur ett maskininlärningsperspektiv). Hur är det med videor? En video kan beskrivas som en inspelning av en rörlig uppsättning bilder eller kontinuerliga ramar. Men vi kan hantera videor med datorseende i en annan blogg! 🙂

Vissa av er kanske redan känner till Computer Vision vid det här laget och kan hoppa över det här stycket, och men för dem som inte har en aning om det kan Computer Vision, mest känd i den förkortade formen 'CV', sägas som ett fält i Artificiell intelligens som extraherar användbara informellt alla domäner i denna moderna tid, inklusive det medicinska området, fordonsindustrin, tillverkning, jordbruk, etc.

Bild 1

Som människa, som för närvarande läser det här inlägget, skulle du kunna skilja mellan de saker eller element som finns i en bild. Men hur är det med maskiner? Kunde de se och tänka för att särskilja det på egen hand? NEJ? låt oss sedan få din maskin att göra det.

I den här bloggen kommer du att bekanta dig med grunderna i datorseende med python.

Jag tror att du redan har installerat Python Shell/Jupyter Notebook/PyCharm eller Visual Studio Code (för att nämna några) för att programmera i python. Låt oss installera det mycket använda paketet (OpenCV) för att komma igång med och vi kommer att köra koderna i varje cell i en Jupyter Notebook.

Installerar OpenCV-paketet för bildförbehandling

OpenCV är ett förbyggt bibliotek (paket) med öppen källkod endast för CPU som används i stor utsträckning för datorseende, maskininlärning och bildbehandlingsapplikationer. Den stöder ett bra utbud av programmeringsspråk inklusive Python.

Installera OpenCV-paketet med:

pip installera opencv-python

pip installera opencv-contrib-python

Kör något av dessa kommandon på din terminal eller om du använder Anaconda Navigator - Jupyter Notebook kan du ändra "pip" med kommandot "conda" och installera detsamma.

Importera paketet

Vad är ett paket i Python? Ett paket i Python är en samling moduler som innehåller förskrivna skript. Dessa paket hjälper oss att importera moduler helt eller till och med individuellt. Vi kan importera paketet genom att anropa modulen "cv2" så här:

importera cv2

Läser en bild

Digitala bilder skulle kunna klassificeras i; färgbilder, gråskalebilder, binära bilder och multispektrala bilder. En färgbild innehåller färginformationen för varje pixel. Bilder som har gråtoner som sin enda färg är gråskalebilder medan en binär bild har exakt två färger, mestadels svarta och vita pixlar. Multispektrala bilder är bilder som fångar bilddata som sträcker sig över det elektromagnetiska spektrumet inom någon specifik våglängd.

Låt oss gå tillbaka till kodningsdelen och läsa en bild, till exempel visas bilden nedan:

Detta är en bild av en mandrill. Jag läser just nu bilden från min lokala katalog.

# cv2.imread(sökväg_till_bild_med_filtillägg, flagga)

Användningskoden ser ut så här:

img = cv2.imread("mandrill.jpg", 1)

Här använder vi "imread" -metoden för cv2-paketet för att läsa bilden och den första parametern motsvarar sökvägen till bilden med dess filnamn och tillägg, och den andra är flaggan som du kan ställa in som talar om vägen, hur man läser i bilden. Om du vill kan du byta ut den absoluta sökvägen till bilden här och prova att läsa den från din lokala dator eller till och med från internet! Om bilden finns i din nuvarande arbetskatalog behöver du bara ange bildnamnet med dess tilläggstyp.

När det gäller den andra parametern, om du vill läsa den som en gråskalebild, kan du ange parametern till 0, -1 för att läsa bilden som oförändrad (läser bilden som alfa- eller transparenskanal om den finns där) och som standard är det 1, som en färgbild. Du kan också prova andra parametrar från denna länk:

https://docs.opencv.org/4.5.2/d8/d6a/group__imgcodecs__flags.html#ga61d9b0126a3e57d9277ac48327799c80

under ImreadModes.

Egenskaper för en bild

Form:

Varje bild har en form. Längden på gränserna som bilden visar kan kallas formen, dvs höjden och bredden. Nu när du vet hur man läser en bild, vad sägs om att vi kontrollerar bildens form?

print(img.shape)

är det grundläggande sättet att skriva ut bildens form, men vi kan extrahera formen med:

h, w, c = img.shape print("Bildens mått är:nnHöjd:", h, "pixelsnWidth:", w, "pixelsnAntal kanaler:", c)

för att få en bättre förståelse.

För färg och oförändrat läge skulle det returnera 3 värden inklusive höjd, bredd och antalet kanaler som finns i bilden. Om du har använt gråskaleläget skulle formen vara 2, vilket kommer att returnera bildens höjd och bredd, men då behöver du bara använda h- och w-variabler (exkludera med “c” ), annars kanske du får ett värdefel som säger "inte tillräckligt med värden för att packa upp (förväntat 3, fick 2)".

Typ:

Vi kan veta typen av bilden med hjälp av "typ" -metoden. Att använda denna metod hjälper oss att veta hur bilddata representeras. Kör koden enligt följande:

print(typ(img))

Resultatet kan bli så här:

som bildtyp. Det är en flerdimensionell behållare med föremål av samma typ och storlek. Du kan referera mer till den N-dimensionella arrayen på följande länk:

https://numpy.org/doc/stable/reference/arrays.ndarray.html

Datatypen för bilden du just har läst:

Eftersom bilden är en N-dimensionell array kan vi kontrollera bildens datatyp:

print(img.dtype)

Bildpixelvärden:

Vi kan tänka på en bild som en uppsättning små prover. Dessa sampel kallas pixlar. För en bättre förståelse, försök zooma in på en bild så mycket som möjligt. Vi kan se samma uppdelat i olika rutor. Dessa är pixlarna och när de kombineras tillsammans bildar de en bild.

Ett av de enkla sätten att representera en bild är i form av en matris. Vi kan till och med skapa en bild med hjälp av en matris och spara den! Kommer att visa dig hur, senare i detta inlägg. Ta en titt på den här bilden nedan:

Bildpixelvärden | Bildbehandling med OpenCV

Bild 2

Den här bilden är snarare ett exempel på hur matrisrepresentationen av en bild ser ut. Till vänster finns en bild av Lincoln, i mitten är pixelvärdena märkta med siffror från 0 till 255, som anger deras intensitet eller ljusstyrka och till höger bildar siffrorna i matrisen sig själva. Varje värde i matrisen motsvarar en pixel, som är det minsta informationselementet som finns i en bild. Kolla in bildpixelvärdena genom att bara skriva ut variabeln som du laddade bilden!

print (img)

Bildupplösning:

Bildupplösning kan definieras som antalet pixlar som finns i en bild. Bildkvaliteten ökar när antalet pixlar ökar. Vi har sett tidigare, formen på bilden som ger antalet rader och kolumner. Detta kan sägas som upplösningen för den bilden. Några av standardupplösningarna är som nästan alla vet är 320 x 240 pixlar (mest lämplig på enheter med små skärmar), 1024 x 768 pixlar (lämpligt att se på vanliga datorskärmar), 720 x 576 pixlar (bra att se på standardupplösnings-TV uppsättningar med bildförhållande 4:3), 1280 x 720 pixlar (för visning på bredbildsskärmar), 1280 x 1024 pixlar (bra för visning i helskärmsstorlek på LCD-skärmar med 5:4 bildförhållande), 1920 x 1080 pixlar (för visning på HD-tv) och nu har vi till och med 4K-, 5K- och 8K-upplösningar som är 3840 x 2160 pixlar, 5120 × 2880 pixlar respektive 7,680 4,320 x XNUMX XNUMX pixlar som stöds av ultrahögupplösta skärmar och tv-apparater.

När vi multiplicerar antalet kolumner och antalet rader kan vi få det totala antalet pixlar som finns i bilden. Till exempel, i en 320 x 240 bild är det totala antalet pixlar som finns i den 76,800 XNUMX pixlar.

Visa bilden

Låt oss se hur du visar bilden i ett fönster. För det måste vi skapa ett GUI-fönster för att visa bilden på skärmen. Den första parametern måste vara titeln på GUI-fönstret, specificerad i strängformat. Vi kan visa bilden i ett popup-fönster med metoden cv2.imshow(). Men när du försöker stänga den kan du känna dig fast med fönstret. Så för att bekämpa det kan vi använda en enkel "waitKey" -metod. Prova denna koddel i ny cell:

cv2.imshow('Mandrill', img) k = cv2.waitKey(0) om k == 27 eller k == ord('q'): cv2.destroyAllWindows()

Här har vi specificerat parametern '0' i "waitKey" för att hålla fönstret öppet tills vi stänger det. (Du kan också ange tiden i millisekunder, istället för 0, och ange hur lång tid den ska öppnas.) Efter det kan vi tilldela variabeln att verka för att stänga fönstret när vi trycker på 'ESC'-tangenten eller tangenten ' q'. Metoden cv2.destroAllWindows() används för att stänga eller ta bort GUI-fönster från skärmen/minnet.

Sparar bilden

Innan du sparar bilden, vad sägs om att konvertera bilden till gråskala och sedan spara den? Konvertera bilden till gråskala med:

grå = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Nu kan vi spara bilden:

cv2.imwrite('Mandrill_grey.jpg', grå)

och kontrollera bilden som sparas i den aktuella arbetskatalogen. Den första parametern motsvarar namnet på filen där bilden ska sparas och den andra parametern är variabeln som innehåller bilden (pixelinformation).

Extrahera bildens bitplan och rekonstruera dem

Vi kan dela upp en bild i olika nivåer av bitplan. Dela till exempel en bild i 8-bitars (0-7) plan, där de sista planen innehåller majoriteten av informationen för en bild.

Bild 3

För att göra detta kan vi importera ytterligare två paket:

importera matplotlib.pyplot som plt importera numpy som np

Om du får ett felmeddelande när du importerar något av paketen kan du installera dem med:

conda installera -c conda-forge matplotlib conda installera -c anaconda numpy

Nu definierar vi en funktion för att extrahera vart och ett av bildens 8-nivåbitplan.

def extract_bit_plane(cd): # extraherar alla bitar en efter en # från 1:a till 8:e i variabeln # från c1 till c8 respektive c1 = np.mod(cd, 2) c2 = np.mod(np.floor(cd/2) , 2) c3 = np.mod(np.floor(cd/4), 2) c4 = np.mod(np.floor(cd/8), 2) c5 = np.mod(np.floor(cd/16) ), 2) c6 = np.mod(np.floor(cd/32), 2) c7 = np.mod(np.floor(cd/64), 2) c8 = np.mod(np.floor(cd/) 128), 2) # kombinerar bilden igen för att bilda ekvivalent med den ursprungliga gråskalebilden cc = 2 * (2 * (2 * c8 + c7) + c6) # rekonstruerar bilden med 3 mest signifikanta bitplan to_plot = [cd, c1, c2 , c3, c4, c5, c6, c7, c8, cc] fig, axes = plt.subplots(nrows=2, ncols=5,figsize=(10, 8), subplot_kw={'xticks': [], ' yticks': []}) fig.subplots_adjust(hspace=0.05, wspace=0.05) för axe, i i zip(axes.flat, to_plot): ax.imshow(i, cmap='gray') plt.tight_layout() plt.show() returnerar cc

Nu är vi redo att anropa funktionen.

reconstructed_image = extract_bit_plane(grå)

Vi har rekonstruerat bilden (nästan liknande) med hjälp av de tre sista bitplanen, dvs. det sjätte, sjunde och åttonde planet. Och resultatet ser ut så här:

rekonstruera bild | Bildbehandling med OpenCV

Vad sägs om att vi konstruerar en liten bild på egen hand? Låt oss prova det nu!

Konstruera en liten syntetisk bild

Vi kan försöka skapa en syntetisk bild som innehåller fyra koncentriska kvadrater med fyra olika pixelintensitetsvärden,

40, 80, 160 och 220.

con_img = np.zeros([256, 256]) con_img[0:32, :] = 40 # övre raden con_img[:, :32] = 40 #vänster kolumn con_img[:, 224:256] = 40 # höger kolumn con_img[224:, :] = 40 # nedre rad con_img[32:64, 32:224] = 80 # övre raden con_img[64:224, 32:64] = 80 # vänster kolumn con_img[64:224, 192: 224] = 80 # höger kolumn con_img[192:224, 32:224] = 80 # nedre rad con_img[64:96, 64:192] = 160 # övre raden con_img[96:192, 64:96] = 160 # vänster kolumn con_img[96:192, 160:192] = 160 # höger kolumn con_img[160:192, 64:192] = 160 # nedre rad con_img[96:160, 96:160] = 220 plt.imshow(con_img)

Den resulterande bilden skulle se ut så här:

Vi kan titta på hur vi använder olika filter och transformationer på bilder i en annan artikel.

Tack för att du läser artikeln.

Bild 4

Lägg gärna till dina förslag under kommentarerna och dela om du gillar den här artikeln. Den kompletta Python-programmeringskoden i Jupyter Notebook, som nämns i den här artikeln är tillgänglig på mitt Github-förråd:

https://github.com/jissdeodates/Beginner-s-Guide-to-Computer-Vision

Referenser:

Bild 1 – https://seevisionc.blogspot.com/2013/09/computer-vision-is-everywhere.html
Bild 2- https://towardsdatascience.com/everything-you-ever-wanted-to-know-about-computer-vision-heres-a-look-why-it-s-so-awesome-e8a58dfb641e
Image 3- https://nptel.ac.in/content/storage2/courses/117104069/chapter_8/8_13.html
Bild 4- https://memegenerator.net/instance/21508026/willy-wonka-oh-so-you-created-a-computer-vision-algorithm-you-must-never-lose-the-remote

https://docs.opencv.org/4.5.2/d1/dfb/intro.html

https://docs.opencv.org/4.5.2/db/deb/tutorial_display_image.html

Media som visas i denna artikel ägs inte av Analytics Vidhya och används efter författarens gottfinnande.