OpenCV Edge Detection i Python med cv2.Canny()

Introduktion

Kantgenkendelse er noget, vi gør naturligt, men det er ikke så nemt, når det kommer til at definere regler for computere. Mens forskellige metoder er blevet udtænkt, blev den herskende metode udviklet af John F. Canny i 1986., og er passende navngivet Canny-metoden.

Det er hurtigt, ret robust og fungerer næsten det bedste, det kunne fungere for den type teknik, det er. I slutningen af ​​guiden ved du, hvordan du udfører kantdetektion i realtid på videoer og producerer noget i stil med:

Canny Edge Detection

Hvad er Canny-metoden? Den består af fire forskellige operationer:

• Gaussisk udglatning
• Beregningsgradienter
• Ikke-Max undertrykkelse
• Hysterese Tærskelværdi

Gaussisk udglatning bruges som det første trin til at "stryge" inputbilledet og dæmpe støjen, hvilket gør det endelige output meget renere.

Billedgradienter har været i brug i tidligere applikationer til kantdetektion. Mest bemærkelsesværdigt er Sobel- og Scharr-filtre afhængige af billedgradienter. Sobel-filteret koger ned til to kerner (Gx , Gy), hvor Gx registrerer vandrette ændringer, mens Gy registrerer lodrette ændringer:

G

x

=

[

-
1

0

+
1

-
2

0

+
2

-
1

0

+
1

]

G

y

=

[

-
1

-
2

-
1

0

0

0

+
1

+
2

+
1

]

Når du skubber dem hen over et billede, vil de hver især "samle" (fremhæve) linjerne i deres respektive retning. Scharr kerner fungerer på samme måde med forskellige værdier:

G

x

=

[

+
3

0

-
3

+
10

0

-
10

+
3

0

-
3

]

G

y

=

[

+
3

+
10

+
3

0

0

0

-
3

-
10

-
3

]

Disse filtre vil, når de først er foldet over billedet, producere feature maps:

Billedkredit: Davidwkennedy

For disse feature maps kan du beregne gradient størrelse , gradient orientering – altså hvor intens ændringen er (hvor sandsynligt er det, at noget er en kant) og i hvilken retning ændringen peger. Da Gy betegner den lodrette ændring (Y-gradient), og Gx betegner den vandrette ændring (X-gradient) – kan du beregne størrelsen ved blot at anvende Pythagoras sætning, for at få hypotenusen af ​​trekanten dannet af "venstre" og "rigtige" retninger:

$$
{G} ={sqrt {{{G} _{x}}^{2}+{{G} _{y}}^{2}}}
$$

Ved at bruge størrelsen og orienteringen kan du fremstille et billede med dets kanter fremhævet:

Billedkredit: Davidwkennedy

Men - du kan se, hvor meget støj der også blev opfanget fra murstenenes tecture! Billedgradienter er meget følsomme over for støj. Dette er grunden til, at Sobel- og Scharr-filtre blev brugt som komponenten, men ikke den eneste tilgang i Cannys metode. Gaussisk udjævning hjælper også her.

Ikke-Max undertrykkelse

Et bemærkelsesværdigt problem med Sobel-filteret er, at kanterne ikke er helt klare. Det er ikke som om nogen tog en blyant og tegnede en streg for at skabe lineart af billedet. Kanterne er normalt ikke så klare på billeder, da lyset gradvist diffunderer. Vi kan dog finde den fælles linje i kanterne og undertrykke resten af ​​pixels omkring den, hvilket i stedet giver en ren, tynd adskillelseslinje. Dette er kendt som Non-Max-undertrykkelse! De ikke-maks. pixels (dem, der er mindre end den, vi sammenligner dem med i et lille lokalt felt, såsom en 3×3-kerne) bliver undertrykt. Konceptet er anvendeligt til flere opgaver end dette, men lad os binde det til denne sammenhæng for nu.

Hysterese Tærskelværdi

Mange ikke-kanter kan og vil sandsynligvis blive vurderet som kanter på grund af lysforhold, materialerne i billedet osv. På grund af de forskellige årsager til disse fejlberegninger - det er svært at foretage en automatiseret vurdering af, hvad en kant bestemt er og ikke er. 't. Du kan tærskelgradienter og kun inkludere de stærkere, forudsat at "rigtige" kanter er mere intense end "falske" kanter.

Thresholding fungerer på nogenlunde samme måde som normalt – hvis gradienten er under en lavere tærskel, skal du fjerne den (nulstille den), og hvis den er over en given toptærskel, behold den. Alt mellem den nedre og øvre grænse er i "gråzonen". Hvis en kant mellem tærsklerne er forbundet med en endelig kant (dem over tærsklen) – de betragtes også som kanter. Hvis de ikke er forbundet, er de sandsynligvis arficater af en fejlberegnet kant.

Det er hysterese-tærskel! Faktisk hjælper det med at rydde op i det endelige output og fjerne falske kanter, afhængigt af hvad du klassificerer som en falsk kant. For at finde gode tærskelværdier vil du generelt eksperimentere med forskellige nedre og øvre grænser for tærsklerne eller bruge en automatiseret metode, såsom Otsus metode eller Triangle-metoden.

Lad os indlæse et billede og gråtone det (Canny, ligesom Sobel/Scharr kræver, at billeder skal gråskaleres):

import cv2
import matplotlib.pyplot as plt

img = cv2.imread('finger.jpg', cv2.IMREAD_GRAYSCALE)
img_blur = cv2.GaussianBlur(img, (3,3), 0)

plt.imshow(img_blur, cmap='gray')

Nærbilledet af en finger vil tjene som et godt testgrundlag for kantdetektion – det er ikke let at skelne et fingeraftryk fra billedet, men vi kan anslå et.

Kantregistrering på billeder med cv2.Canny()

Cannys algoritme kan anvendes ved hjælp af OpenCV's Canny() metode:

cv2.Canny(input_img, lower_bound, upper_bound)

Det kan være svært at finde den rigtige balance mellem den nedre og øvre grænse. Hvis begge er lave – har du få kanter. Hvis den nedre grænse er lav og den øvre er høj – vil du have støj. Hvis begge er høje og tæt på hinanden – har du få kanter. Det rigtige sted har lige nok mellemrum mellem grænserne og har dem på den rigtige skala. Eksperiment!

Inputbilledet bliver sløret ved hjælp af Canny-metoden, men ofte vil du have gavn af at sløre det før det går også ind. Metoden anvender en 5×5 Gaussisk sløring på inputtet, før du går igennem resten af ​​operationerne, men selv med denne sløring kan der stadig sive noget støj igennem, så vi har sløret billedet, før det føres ind i algoritmen:

edge = cv2.Canny(img_blur, 20, 30)

fig, ax = plt.subplots(1, 2, figsize=(18, 6), dpi=150)
ax[0].imshow(img, cmap='gray')
ax[1].imshow(edge, cmap='gray')

Dette resulterer i:

Værdierne for 20 , 30 her er ikke vilkårlige – jeg har testet metoden på forskellige parametre og valgt et sæt, der så ud til at give et anstændigt resultat. Kan vi prøve at automatisere dette?

Automatiseret tærskelværdi for cv2.Canny()?

Kan du finde et optimalt sæt tærskelværdier? Ja, men det virker ikke altid. Du kan lave din egen beregning for en god værdi og derefter justere intervallet med en sigma omkring denne tærskel:

lower_bound = (1-sigma)*threshold
upper_bound = (1+sigma)*threshold

Hvornår sigma, er sige, 0.33 – grænserne bliver 0.66*threshold , 1.33*threshold, hvilket tillader et ~1/3-område omkring det. Men at finde threshold er det, der er sværere. OpenCV giver os Otsus metode (fungerer fantastisk til bi-modale billeder) og Triangle-metoden. Lad os prøve dem begge ud, samt tage en simpel median af pixelværdierne som den tredje mulighed:

otsu_thresh, _ = cv2.threshold(img_blur, 0, 255, cv2.THRESH_OTSU)
triangle_thresh, _ = cv2.threshold(img_blur, 0, 255, cv2.THRESH_TRIANGLE)
manual_thresh = np.median(img_blur)

def get_range(threshold, sigma=0.33):
    return (1-sigma) * threshold, (1+sigma) * threshold

otsu_thresh = get_range(otsu_thresh)
triangle_thresh = get_range(triangle_thresh)
manual_thresh = get_range(manual_thresh)

print(f"Otsu's Threshold: {otsu_thresh} nTriangle Threshold: {triangle_thresh} nManual Threshold: {manual_thresh}")

Dette resulterer i:

Otsu's Threshold: (70.35, 139.65) 
Triangle Threshold: (17.419999999999998, 34.58) 
Manual Threshold: (105.18999999999998, 208.81)

Disse er ret forskellige! Ud fra de værdier, vi har set før, kan vi forudse, at trekantmetoden fungerer bedst her. Den manuelle tærskel er ikke særlig informeret, da den kun tager medianpixelværdien og ender med at have en høj basistærskel, som multipliceres yderligere til et bredt område for dette billede. Otsus metode lider mindre under dette, men lider ikke desto mindre.

Hvis vi kører Canny() metode med disse tærskelintervaller:

edge_otsu = cv2.Canny(img_blur, *otsu_thresh)
edge_triangle = cv2.Canny(img_blur, *triangle_thresh)
edge_manual = cv2.Canny(img_blur, *manual_thresh)

fig, ax = plt.subplots(1, 3, figsize=(18, 6), dpi=150)
ax[0].imshow(edge_otsu, cmap='gray')
ax[1].imshow(edge_triangle, cmap='gray')
ax[2].imshow(edge_manual, cmap='gray')

Dette resulterer i:

Trekantmetoden fungerede ret godt her! Dette er ingen garanti for, at det også vil fungere godt i andre tilfælde.

Edge-detektion i realtid på videoer med cv2.Canny()

Lad os endelig anvende Canny edge-detektion på en video i realtid! Vi viser videoen, der behandles (hver frame, efterhånden som den er færdig) ved hjælp af cv2.imshow() som viser et vindue med den ramme, vi gerne vil vise. Vi gemmer dog også videoen i en MP4-fil, der senere kan inspiceres og deles.

For at indlæse en video ved hjælp af OpenCV, bruger vi VideoCapture() metode. Hvis vi går ind 0 – den optager fra det aktuelle webcam, så du også kan køre koden på dit webcam! Hvis du indtaster et filnavn, indlæses filen:

def edge_detection_video(filename):
    cap = cv2.VideoCapture(filename)
    
    fourcc = cv2.VideoWriter_fourcc(*'MP4V')
    out = cv2.VideoWriter('output.mp4', fourcc, 30.0, (int(cap.get(3)), int(cap.get(4))), isColor=False)
    
    while cap.isOpened():
        (ret, frame) = cap.read()
        if ret == True:
            frame = cv2.GaussianBlur(frame, (3, 3), 0)
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
            edge = cv2.Canny(frame, 50, 100)
            out.write(edge)
            cv2.imshow('Edge detection', edge)
        else:
            break

        if cv2.waitKey(10) & 0xFF == ord('q'):
            break

    cap.release()
    out.release()
    cv2.destroyAllWindows()

edge_detection_video('secret_video.mp4')

VideoWriter accepterer flere parametre - outputfilnavnet, FourCC (fire codec-koder, der angiver det codec, der bruges til at kode videoen), framerate og opløsningen som en tuple. For ikke at gætte eller ændre størrelsen på videoen – vi har brugt bredden og højden af ​​den originale video, opnået gennem VideoCapture instans, der indeholder data om selve videoen, såsom bredde, højde, det samlede antal billeder osv.

Mens optagelsen er åbnet, forsøger vi at læse den næste ramme med cap.read(), som returnerer en resultatkode og den næste ramme. Resultatkoden er True or False, der angiver tilstedeværelsen af ​​den næste ramme eller mangel på samme. Først når der er en ramme, vil vi forsøge at behandle den yderligere, ellers vil vi bryde løkken. For hver gyldig ramme kører vi den gennem en gaussisk sløring, konverterer den til gråtoner, kører cv2.Canny() på det og skriv det ved hjælp af VideoWriter til disken, og vis vha cv2.imshow() for en live-visning.

Til sidst frigiver vi optagelsen og videoskriveren, da de begge arbejder med filer på disken og ødelægger alle eksisterende vinduer.

Når du kører metoden med en secret_video.mp4 input – du vil se et vindue pop op, og når det er færdigt, en fil i din arbejdsmappe:

Konklusion

I denne vejledning har vi taget et kig på, hvordan Canny-kantdetektion fungerer, og dens bestanddele – gaussisk udjævning, Sobel-filtre og billedgradienter, Non-Max-undertrykkelse og hysterese-tærskel. Endelig har vi undersøgt metoder til automatiseret tærskelområdesøgning for Canny edge-detektion med cv2.Canny(), og anvendte teknikken på en video, hvilket giver kantdetektion i realtid og gemmer resultaterne i en videofil.

Gå videre – Praktisk dyb læring til computersyn

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Kursus: "Praktisk dyb læring til computersyn med Python".

Endnu et kursus i computersyn?

Vi laver ikke klassificering af MNIST-cifre eller MNIST-mode. De tjente deres del for længe siden. For mange læringsressourcer fokuserer på grundlæggende datasæt og grundlæggende arkitekturer, før de lader avancerede black-box-arkitekturer bære byrden af ​​ydeevne.

Vi ønsker at fokusere på afmystificering, praktisk, forståelse, intuition , rigtige projekter. Vil gerne lære hvordan kan du gøre en forskel? Vi tager dig med på en tur fra den måde, vores hjerner behandler billeder på, til at skrive en deep learning-klassificerer for brystkræft i forskningsklasse til deep learning-netværk, der "hallucinerer", lærer dig principperne og teorien gennem praktisk arbejde, og udstyrer dig med knowhow og værktøjer til at blive ekspert i at anvende dyb læring til at løse computervision.

Hvad er der indenfor?

• De første principper for vision og hvordan computere kan læres at "se"
• Forskellige opgaver og anvendelser af computersyn
• Branchens værktøjer, der vil gøre dit arbejde lettere
• Finde, skabe og bruge datasæt til computervision
• Teorien og anvendelsen af ​​​​konvolutionelle neurale netværk
• Håndtering af domæneskift, samtidige forekomster og andre skævheder i datasæt
• Overfør Læring og udnyttelse af andres træningstid og beregningsressourcer til din fordel
• Opbygning og træning af en avanceret brystkræftklassificering
• Hvordan man anvender en sund dosis skepsis til mainstream ideer og forstår implikationerne af vidt anvendte teknikker
• Visualisering af et ConvNets "konceptrum" ved hjælp af t-SNE og PCA
• Casestudier af, hvordan virksomheder bruger computervisionsteknikker til at opnå bedre resultater
• Korrekt modelevaluering, latent rumvisualisering og identifikation af modellens opmærksomhed
• Udførelse af domæneforskning, bearbejdning af dine egne datasæt og etablering af modeltest
• Banebrydende arkitekturer, udviklingen af ​​ideer, hvad der gør dem unikke, og hvordan man implementerer dem
• KerasCV – et WIP-bibliotek til at skabe state of the art pipelines og modeller
• Hvordan man analyserer og læser papirer og implementerer dem selv
• Valg af modeller afhængigt af din applikation
• Oprettelse af en end-to-end machine learning pipeline
• Landskab og intuition på objektdetektion med hurtigere R-CNN'er, RetinaNets, SSD'er og YOLO
• Forekomst og semantisk segmentering
• Objektgenkendelse i realtid med YOLOv5
• Træning af YOLOv5 objektdetektorer
• Arbejde med transformere ved hjælp af KerasNLP (industristærkt WIP-bibliotek)
• Integrering af transformere med ConvNets for at generere billedtekster
• Deepdream
• Deep Learning model optimering til computer vision