En begyndervejledning til billedbehandling med OpenCV og Python

Genudgivet af Platon

Abonnenter: 0

Denne artikel blev offentliggjort som en del af Data Science Blogathon

Introduktion

Der kunne være en masse information gemt inde i et billede, og vi kunne fortolke det på forskellige måder og perspektiver. Så hvad er et billede, og hvordan skal man håndtere et billede? Med enkle ord kan vi sige, at et billede er en visuel repræsentation af noget, og det kunne nemt håndteres ved hjælp af computersyn (fra et maskinlæringsperspektiv). Hvad med videoer? En video kan beskrives som en optagelse af et bevægeligt sæt billeder eller kontinuerlige billeder. Men vi kan håndtere videoer ved hjælp af computersyn i en anden blog! 🙂

Nogle af jer kender måske allerede til Computer Vision nu og kan springe dette afsnit over, og for dem, der ikke har en idé om det, kan Computer Vision, mest kendt i den forkortede form 'CV', siges som et felt i Kunstig intelligens, der udtrækker nyttige informelle domæner i denne moderne æra, inklusive det medicinske område, bilindustrien, fremstilling, landbrug osv.

Billedbehandling med OpenCV | computersyn

Billede 1

Som et menneske, der i øjeblikket læser dette indlæg, ville du være i stand til at skelne mellem de ting eller elementer, der er til stede i et billede. Men hvad med maskiner? Kunne de se og tænke for at skelne det alene? INGEN? så lad os få din maskine til at gøre det.

I denne blog vil du gøre dig bekendt med det grundlæggende i computersyn ved hjælp af python.

Jeg tror, du allerede har installeret Python Shell/Jupyter Notebook/PyCharm eller Visual Studio Code (for at nævne nogle få) for at programmere i python. Lad os installere den meget brugte pakke (OpenCV) for at komme i gang med, og vi kommer til at køre koderne i hver celle i en Jupyter Notebook.

Installation af OpenCV-pakke til billedforbehandling

OpenCV er et forudbygget, open source-CPU-kun-bibliotek (pakke), der er meget udbredt til computersyn, maskinlæring og billedbehandlingsapplikationer. Det understøtter et godt udvalg af programmeringssprog inklusive Python.

Installer OpenCV-pakken ved hjælp af:

pip installer opencv-python

pip installer opencv-contrib-python

Kør en af disse kommandoer på din terminal, eller hvis du bruger Anaconda Navigator - Jupyter Notebook, kan du ændre "pip" med kommandoen "conda" og installere det samme.

Import af pakken

Hvad er en pakke i Python? En pakke i Python er en samling af moduler, der indeholder forudskrevne scripts. Disse pakker hjælper os med at importere moduler helt eller endda individuelt. Vi kan importere pakken ved at kalde "cv2" modulet sådan her:

importere cv2

Læsning af et billede

Digitale billeder kunne klassificeres i; farvebilleder, gråtonebilleder, binære billeder og multispektrale billeder. Et farvebillede inkluderer farveoplysningerne for hver pixel. Billeder med gråtoner som deres eneste farve er gråtonebilleder, mens et binært billede har præcis to farver, for det meste sorte og hvide pixels. Multispektrale billeder er billeder, der fanger billeddata, der spænder over det elektromagnetiske spektrum inden for en bestemt bølgelængde.

Lad os vende tilbage til kodningsdelen og læse et billede, for eksempel er billedet vist nedenfor:

læse billede | Billedbehandling med OpenCV

Dette er et billede af en mandrill. Jeg læser i øjeblikket billedet fra min lokale mappe.

# cv2.imread(sti_til_billede_med_filudvidelse, flag)

Brugskoden ser sådan ud:

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

Her bruger vi "imread"-metoden i cv2-pakken til at læse billedet, og den første parameter svarer til stien til billedet med dets filnavn og udvidelse, og den anden er det flag, du kan indstille, som fortæller vejen, hvordan man læser i billedet. Hvis du vil, kan du erstatte den absolutte vej til billedet her og prøve at læse det fra din lokale computer eller endda fra internettet! Hvis billedet er til stede i din nuværende arbejdsmappe, behøver du kun at angive billednavnet med dets filtypenavn.

For så vidt angår den anden parameter, hvis du kan lide at læse det som et gråtonebillede, kan du angive parameteren til 0, -1 for at læse billedet som uændret (læser billedet som alfa- eller transparenskanal, hvis det er der) og som standard er det 1, som et farvebillede. Du kan også prøve andre parametre fra dette link:

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

under ImreadModes.

Egenskaber for et billede

Form:

Hvert billede har en form. Længden af afgrænsninger, som billedet viser, kan omtales som formen, dvs. højden og bredden. Nu hvor du ved, hvordan man læser et billede, hvad med at vi tjekker formen på billedet?

print(img.shape)

er den grundlæggende måde at udskrive billedets form på, men vi kan udtrække formen ved at bruge:

h, w, c = img.shape print("Billedets dimensioner er:nnHøjde:", h, "pixelsnWidth:", w, "pixelsnAntal kanaler:", c)

for at få en bedre forståelse.

For farve og uændret tilstand ville den returnere 3 værdier inklusive højden, bredden og antallet af kanaler i billedet. Hvis du har brugt gråtonetilstanden, ville formen være 2, hvilket vil returnere højden og bredden af billedet, men så skal du kun bruge h- og w-variabler (ekskluder ved at bruge "c"), ellers får du måske en værdifejl, der siger "ikke nok værdier til at pakke ud (forventet 3, fik 2)".

Type:

Vi kan kende typen af billedet ved hjælp af "type" metoden. Brug af denne metode hjælper os med at vide, hvordan billeddataene er repræsenteret. Kør koden som følger:

print(type(img))

Resultatet kan blive sådan her:

som billedtype. Det er en multidimensionel beholder med genstande af samme type og størrelse. Du kan henvise mere til det N-dimensionelle array på følgende link:

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

Datatypen for det billede, du lige har læst:

Da billedet er en N-dimensional matrix, kan vi kontrollere billedets datatype:

print(img.dtype)

Billedpixelværdier:

Vi kan tænke på et billede som et sæt af små prøver. Disse eksempler kaldes pixels. For en bedre forståelse, prøv at zoome ind på et billede så meget som muligt. Vi kan se det samme opdelt i forskellige firkanter. Disse er pixels, og når de kombineres sammen danner de et billede.

En af de enkle måder at repræsentere et billede på er i form af en matrix. Vi kan endda oprette et billede ved hjælp af en matrix og gemme det! Vil vise dig hvordan senere i dette indlæg. Tag et kig på dette billede nedenfor:

Billedpixelværdier | Billedbehandling med OpenCV

Billede 2

Dette billede er snarere et eksempel på, hvordan matrixrepræsentationen af et billede ser ud. Til venstre er et billede af Lincoln, i midten er pixelværdierne mærket med tal fra 0 til 255, der angiver deres intensitet eller lysstyrke, og til højre danner tallene i matrix sig selv. Hver værdi i matrixen svarer til en pixel, som er det mindste informationselement, der findes i et billede. Tjek billedpixelværdierne ved blot at udskrive den variabel, som du indlæste billedet!

print (img)

Billedopløsning:

Billedopløsning kan defineres som antallet af pixels til stede i et billede. Kvaliteten af billedet øges, når antallet af pixels stiger. Vi har tidligere set formen på billedet, som giver antallet af rækker og kolonner. Dette kunne siges som opløsningen af det billede. Nogle af standardopløsningerne er, som næsten alle kender, er 320 x 240 pixels (mest velegnet på enheder med små skærme), 1024 x 768 pixels (passende at se på standard computerskærme), 720 x 576 pixels (god at se på standardopløsnings-tv sæt med 4:3 billedformat), 1280 x 720 pixels (til visning på widescreen-skærme), 1280 x 1024 pixels (godt til visning i fuld skærmstørrelse på LCD-skærme med 5:4 billedformat), 1920 x 1080 pixels (til visning på HD-tv'er) og nu har vi endda 4K, 5K og 8K opløsninger, som er henholdsvis 3840 x 2160 pixels, 5120 × 2880 pixels og 7,680 x 4,320 pixels understøttet af ultra high definition skærme og fjernsyn.

Når vi multiplicerer antallet af kolonner og antallet af rækker, kan vi få det samlede antal pixels til stede i billedet. For eksempel, i et 320 x 240 billede, er det samlede antal pixels til stede i det 76,800 pixels.

Visning af billedet

Lad os se, hvordan du viser billedet i et vindue. Til det skal vi oprette et GUI-vindue for at vise billedet på skærmen. Den første parameter skal være titlen på GUI-vinduets skærm, angivet i strengformat. Vi kan vise billedet i et pop-up vindue ved hjælp af cv2.imshow() metoden. Men når du prøver at lukke den, kan du føle dig fastlåst med vinduet. Så for at bekæmpe det, kan vi bruge en simpel "waitKey" metode. Prøv denne kodedel i en ny celle:

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

Her har vi specificeret parameteren '0' i "waitKey" for at holde vinduet åbent, indtil vi lukker det. (Du kan også angive tiden i millisekunder i stedet for 0 for at angive, hvor lang tid den skal åbnes.) Derefter kan vi tildele variablen til at fungere for at lukke vinduet, når vi trykker på 'ESC'-tasten eller tasten ' q'. Metoden cv2.destroAllWindows() bruges til at lukke eller slette GUI-vinduerne fra skærmen/hukommelsen.

Gemmer billedet

Før du gemmer billedet, hvad med at konvertere billedet til gråtoner og derefter gemme det? Konverter billedet til gråtoner ved hjælp af:

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

Nu kan vi gemme billedet:

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

og kontroller det billede, der gemmes i den aktuelle arbejdsmappe. Den første parameter svarer til navnet på den fil, hvori billedet skal gemmes, og den anden parameter er den variabel, der indeholder billedet (pixelinformation).

Udtrække billedbitplanerne og rekonstruere dem

Vi kan opdele et billede i forskellige niveauer af bitplaner. Opdel for eksempel et billede i 8-bit (0-7) planer, hvor de sidste par planer indeholder størstedelen af informationen for et billede.

Billede 3

For at gøre dette kan vi importere yderligere to pakker:

import matplotlib.pyplot som plt import numpy som np

Hvis du får en fejl under import af en af pakkerne, kan du installere dem ved at bruge:

conda install -c conda-forge matplotlib conda install -c anaconda numpy

Nu definerer vi en funktion til at udtrække hvert af billedets 8-niveau bitplaner.

def extract_bit_plane(cd): # udtrækker alle bit én efter én # fra 1. til 8. i variabel # fra henholdsvis c1 til c8 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) # kombinerer billede igen for at danne svarende til originalt gråtonebillede cc = 2 * (2 * (2 * c8 + c7) + c6) # rekonstruerer billede med 3 mest signifikante bitplaner to_plot = [cd, c1, c2 , c3, c4, c5, c6, c7, c8, cc] fig, akser = plt.subplots(nrows=2, ncols=5,figsize=(10, 8), subplot_kw={'xticks': [], ' yticks': []}) fig.subplots_adjust(hspace=0.05, wspace=0.05) for axe, i i zip(axes.flat, to_plot): ax.imshow(i, cmap='gray') plt.tight_layout() plt.show() returner cc

Nu er vi klar til at kalde funktionen.

rekonstrueret_billede = extract_bit_plane(grå)

Vi har rekonstrueret billedet (næsten ens) ved hjælp af de sidste tre bitplaner, dvs. det sjette, syvende og ottende plan. Og resultatet ser således ud:

rekonstruere billede | Billedbehandling med OpenCV

Hvad med at konstruere et lille billede på egen hånd? Lad os prøve det nu!

Konstruktion af et lille syntetisk billede

Vi kan prøve at generere et syntetisk billede, der indeholder fire koncentriske firkanter med fire forskellige pixelintensitetsværdier,

40, 80, 160 og 220.

con_img = np.zeros([256, 256]) con_img[0:32, :] = 40 # øvre række con_img[:, :32] = 40 #venstre kolonne con_img[:, 224:256] = 40 # højre kolonne con_img[224:, :] = 40 # nederste række con_img[32:64, 32:224] = 80 # øvre række con_img[64:224, 32:64] = 80 # venstre kolonne con_img[64:224, 192: 224] = 80 # højre kolonne con_img[192:224, 32:224] = 80 # nederste række con_img[64:96, 64:192] = 160 # øvre række con_img[96:192, 64:96] = 160 # venstre kolonne con_img[96:192, 160:192] = 160 # højre kolonne con_img[160:192, 64:192] = 160 # nederste række con_img[96:160, 96:160] = 220 plt.imshow(con_img)

Det resulterende billede ville se sådan ud:

Vi kan se på at bruge forskellige filtre og transformationer på billeder i en anden artikel.

Tak fordi du læste artiklen.

Billede 4

Du er velkommen til at tilføje dine forslag under kommentarerne og del, hvis du kan lide denne artikel. Den komplette Python-programmeringskode i Jupyter Notebook, nævnt i denne artikel, er tilgængelig på mit Github-lager:

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

Referencer:

Billede 1 – https://seevisionc.blogspot.com/2013/09/computer-vision-is-everywhere.html
Billede 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
Billede 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

Medierne vist i denne artikel ejes ikke af Analytics Vidhya og bruges efter forfatterens skøn.