Bildesegmentering ved hjelp av opencv

I de foregående opplæringene har vi brukt OpenCV for grunnleggende bildebehandling og gjort noen forhåndsredigeringsoperasjoner. Som vi vet er OpenCV Open Source Commuter Vision Library som har C ++, Python og Java-grensesnitt og støtter Windows, Linux, Mac OS, iOS og Android. Så det kan enkelt installeres i Raspberry Pi med Python og Linux-miljø. Og Raspberry Pi med OpenCV og tilkoblet kamera kan brukes til å lage mange sanntids bildebehandlingsapplikasjoner som ansiktsgjenkjenning, ansiktslås, gjenstandssporing, registreringsnummer for bilnummer, sikkerhetssystem for hjemmet osv. I denne opplæringen vil vi lære at hvordan du gjør bildesegmentering ved hjelp av OpenCV. Operasjonene vi skal utføre er listet opp nedenfor:

• Segmentering og konturer
• Hierarki og hentemodus
• Omtrentlige konturer og finne deres konvekse skrog
• Conex Hull
• Matchende kontur
• Identifisere figurer (sirkel, rektangel, trekant, firkant, stjerne)
• Linjedeteksjon
• Blob deteksjon
• Filtrering av klatter - teller sirkler og ellipser

1. Segmentering og konturer

Bildesegmentering er en prosess der vi deler bilder i forskjellige regioner. Mens konturene er de kontinuerlige linjene eller kurvene som binder eller dekker den fulle grensen til et objekt i et bilde. Og her vil vi bruke bildesegmenteringsteknikk kalt konturer for å trekke ut delene av et bilde.

Også konturer er veldig viktige i

• Objektdeteksjon
• Formanalyse

Og de har veldig bredt bruksområde fra den virkelige verdens bildeanalyse til medisinsk bildeanalyse, slik som i MR

La oss vite hvordan du implementerer konturer i opencv, ved å trekke ut konturer av firkanter.

import cv2 import numpy as np

La oss laste inn et enkelt bilde med 3 svarte firkanter

image = cv2.imread ('squares.jpg') cv2.imshow ('input image', image) cv2.waitKey (0)

Gråtone

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

Finn søte kanter

kantet = cv2.Canny (grå, 30.200 ) cv2.imshow ('canny edge', kantet) cv2.waitKey (0)

Finne konturer

# bruk en kopi av bildet ditt, f.eks - edged.copy (), siden det å finne konturer endrer bildet # vi må legge til _, før konturene som et tomt argument på grunn av oppgradering av OpenCV-versjonen _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('sprø kanter etter konturering', kantet) cv2.waitKey (0)

Skriver ut konturfilen for å vite hva konturene består av

print (contours) print ('Antall konturer funnet =' + str (len (contours)))

Tegn alle konturer

# bruk -1 som den tredje parameteren for å tegne alle konturene cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Konsollutgang -],],], …,],],]], dtype = int32), matrise (],],

], …,

],],]], dtype = int32), array (],],], …,],],]], dtype = int32)]

Antall konturer funnet = 3. Så vi har funnet totalt tre konturer.

Nå, i ovennevnte kode, hadde vi også skrevet ut konturfilen ved hjelp av , denne filen forteller hvordan disse konturene ser ut, som skrevet ut over konsollutgangen.

I konsollutgangen ovenfor har vi en matrise som ser ut som koordinater for x, y poeng. OpenCV lagrer konturer i en liste over lister. Vi kan ganske enkelt vise konsollutgangen ovenfor som følger:

KONTUR 1 KONTUR 2 KONTUR 3

], array (], array (],],],],],],],

…,…,…,],],],],],],]], dtype = int32),]], dtype = int32),]], dtype = int32)]

Når vi bruker lengdefunksjonen på konturfilen, får vi lengden lik 3, det betyr at det var tre lister med lister i den filen, dvs. tre konturer.

Tenk deg KONTUR 1 er det første elementet i matrisen, og den listen inneholder en liste over alle koordinatene, og disse koordinatene er punktene langs konturene vi nettopp så, som de grønne rektangulære boksene.

Det er forskjellige metoder for å lagre disse koordinatene, og disse kalles tilnærmingsmetoder, i utgangspunktet er tilnærmingsmetoder av to typer

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE lagrer alt grensepunktet, men vi trenger ikke nødvendigvis alle grensepunktene. Hvis punktet danner en rett linje, trenger vi bare startpunktet og sluttpunktet på den linjen.

cv2.CHAIN_APPROX_SIMPLE gir i stedet bare start- og sluttpunktene til avgrensningskonturene, resultatet er mye mer effektiv lagring av konturinformasjon.

_, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

I koden ovenfor er cv2.RETR_EXTERNAL hentemodus mens cv2.CHAIN_APPROX_NONE er

tilnærmingsmetoden.

Så vi har lært om konturer og tilnærmingsmetode, la oss nå utforske hierarki og hentemodus.

2. Hierarki og hentemodus

Hentingsmodus definerer hierarkiet i konturer som subkonturer, eller ekstern kontur eller alle konturene.

Nå er det fire hentemodus sortert på hierarkitypene.

cv2.RETR_LIST - henter alle konturene.

cv2.RETR_EXTERNAL - henter bare eksterne eller ytre konturer.

cv2.RETR_CCOMP - henter alt i et 2-nivå hierarki.

cv2.RETR_TREE - henter alle i et fullstendig hierarki.

Hierarki lagres i følgende format

La oss nå illustrere forskjellen mellom de to første hentemodusene, cv2.RETR_LIST og cv2.RETR_EXTERNAL.

import cv2 import numpy as np

Lar oss laste et enkelt bilde med 3 sorte firkanter

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image', image) cv2.waitKey (0)

Gråtone

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

Finn Canny Edges

kantet = cv2.Canny (grå, 30.200 ) cv2.imshow ('canny edge', kantet) cv2.waitKey (0)

Finne konturer

# bruk en kopi av bildet ditt, f.eks - edged.copy (), siden det å finne konturer endrer bildet # vi må legge til _ før konturene som et tomt argument på grunn av oppgradering av den åpne cv-versjonen _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('tøffe kanter etter konturering', kantet) cv2.waitKey (0)

Skriver ut konturfilen for å vite hva konturene består av.

print (contours) print ('Antall konturer funnet =' + str (len (contours)))

Tegn alle konturer

# bruk -1 som den tredje parameteren for å tegne alle konturene cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows

import cv2 import numpy as np

Lar oss laste et enkelt bilde med 3 sorte firkanter

image = cv2.imread ('square donut.jpg') cv2.imshow ('input image', image) cv2.waitKey (0)

Gråtone

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

Finn søte kanter

kantet = cv2.Canny (grå, 30.200 ) cv2.imshow ('canny edge', kantet) cv2.waitKey (0)

Finne konturer

# bruk en kopi av bildet ditt, f.eks - edged.copy (), siden det å finne konturer endrer bildet # vi må legge til _ før konturene som et tomt argument på grunn av oppgradering av den åpne cv-versjonen _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('sprø kanter etter konturering', kantet) cv2.waitKey (0)

Skriver ut konturfilen for å vite hva konturene består av.

print (contours) print ('Antall konturer funnet =' + str (len (contours)))

Tegn alle konturer

# bruk -1 som den tredje parameteren for å tegne alle konturene cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Så gjennom demonstrasjonen av kodene ovenfor kunne vi tydelig se forskjellen mellom cv2.RETR_LIST og cv2.RETR_EXTERNNAL , i cv2.RETR_EXTERNNAL blir bare de ytre konturene tatt i betraktning mens de indre konturene blir ignorert.

Mens i cv2.RETR_LIST blir det også tatt hensyn til indre konturer.

3. Tilnærming av konturer og finne deres konvekse skrog

I omtrentlige konturer tilnærmes en konturform over en annen konturform, noe som kanskje ikke ligner mye på den første konturformen.

For tilnærming bruker vi approxPolyDP funksjon av openCV som er forklart nedenfor

cv2.approxPolyDP (kontur, tilnærmelsesnøyaktighet, lukket)

Parametere:

• Kontur - er den individuelle konturen vi ønsker å tilnærme.
• Tilnærming nøyaktighet - viktig parameter for å bestemme nøyaktigheten av tilnærming, liten verdi gir presis tilnærming, store verdier gir mer generell informasjon. En god tommelfingerregel er mindre enn 5% av konturens omkrets.
• Stengt - en boolsk verdi som angir om den omtrentlige konturen kan være åpen eller lukket.

La oss prøve å tilnærme en enkel figur av et hus

importer numpy som np import cv2

Last inn bildet og oppbevar en kopi

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('original image', orig_image) cv2.waitKey (0)

Gråtone og binær bildet

grå = cv2.cvtColor (bilde, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.terskel (grå, 127,255, cv2.THRESH_BINARY_INV)

Finn konturer

_, konturer, hierarki = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Iterer gjennom hver kontur og beregne deres begrensende rektangel

for c i konturer: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (orig_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.imshow ('Bounding rect', orig_image) cv2.waitKey (0)

Iterer gjennom hver kontur og beregner den omtrentlige konturen

for c i konturer:

#beregn nøyaktighet som en prosent av nøyaktig kontur omkrets = 0,03 * cv2.arcLength (c, True) ca = cv2.approxPolyDP (c, nøyaktighet, True) cv2.drawContours (bilde,, 0, (0,255,0), 2) cv2.imshow ('Ca polyDP', image) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konveks skrog

Konveks skrog er i utgangspunktet ytterkantene, representert ved å tegne linjer over en gitt figur.

Det kan være den minste polygonen som kan passe rundt selve gjenstanden.

importer cv2 import numpy som np image = cv2.imread ('star.jpg') grå = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('original image', image) cv2.waitKey (0)

Terskel bildet

ret, trøske = cv2. terskel (grå, 176,255,0)

Finn konturer

_, konturer, hierarki = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Sorter konturene etter område og fjern deretter den største rammekonturen

n = len (konturer) -1 konturer = sortert (konturer, nøkkel = cv2.contourArea, revers = False)

Iterer gjennom konturene og tegner konveks skrog

for c i konturer:

skrog = cv2.convexHull (c) cv2.drawContours (bilde,, 0, (0,255,0), 2) cv2.imshow ('konveks skrog', bilde) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Matchende kontur etter former

cv2.matchShapes (konturmal, konturmetode, metodeparameter)

Utgang - samsvarverdi (lavere verdi betyr nærmere samsvar)

konturmal - Dette er vår referansekontur som vi prøver å finne i et nytt bilde.

kontur - Den individuelle konturen vi sjekker mot.

Metode - Type konturtilpasning (1,2,3).

metodeparameter - la alene som 0,0 (ikke benyttet i python OpenCV)

import cv2 import numpy as np

Last inn formmalen eller referansebildet

mal = cv2.imread ('star.jpg', 0) cv2.imshow ('mal', mal) cv2.waitKey (0)

Last inn målbildet med figurene vi prøver å matche

mål = cv2.imread ('shapestomatch.jpg') grå = cv2.cvtColor (mål, cv2.COLOR_BGR2GRAY)

Terskel begge bildene først før du bruker cv2.findContours

ret, thresh1 = cv2.threshold (mal, 127,255,0) ret, thresh2 = cv2.threshold (grå, 127,255,0)

Finn konturer i malen

_, konturer, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # vi trenger å sortere konturene etter område slik at vi kan fjerne den største konturen som er

Bildeskisse

sorted_contours = sorted (contours, key = cv2.contourArea, reverse = True) # vi trekker ut den nest største konturen som vil være vår malkontur tempelate_contour = contours #extract the contours from the second target image _, contours, hierarchy = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) for c i konturer: #iterate gjennom hver kontur i målbildet og bruk cv2.matchShape for å sammenligne konturform match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") #if samsvarverdi er mindre enn 0,15 hvis samsvar <0,16: nærmeste_kontur = c annet: nærmeste_kontur = cv2.drawContours (mål,, - 1, (0,255,0), 3) cv2.imshow ('output',mål) cv2.waitKey (0) cv2.destroyAllWindows ()

Konsollutgang -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

Det er tre forskjellige metoder med forskjellig matematikkfunksjon, vi kan eksperimentere med hver metode ved å bare erstatte cv2.matchShapes (tempelate_contour, c, 1, 0.0) metodeverdier som varierer fra 1,2 og 3, for hver verdi får du forskjellig samsvar verdier i konsollutdata.

6. Identifisere figurer (sirkel, rektangel, trekant, firkant, stjerne)

OpenCV kan også brukes til å oppdage forskjellige typer former automatisk fra bildet. Ved å bruke koden nedenfor vil vi kunne oppdage sirkel, rektangel, trekant, firkant og stjerner fra bildet.

import cv2 import numpy as np

Last inn bilder og deretter gråskala

image = cv2.imread ('shapes.jpg') grå = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('identififying forms', image) cv2.waitKey (0) ret, thresh = cv2.threshold (grå, 127,255,1)

Pakk ut konturer

_, konturer, hierarki = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

For cnt i konturer:

Få omtrentlige polygoner ca = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) hvis len (approx) == 3: shape_name = "Triangle" cv2.drawContours (image,, 0, (0,255, 0), - 1)

finn kontursenter for å plassere tekst i sentrum

M = cv2.momenter (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (bilde, formnavn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (ca.) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Kontroller om den firesidige polygonen er firkantet eller rektangel

# cv2.boundingRect returner venstre bredde og høyde i piksler, startende fra det øverste # venstre hjørnet, for kvadrat ville det være omtrent det samme hvis abs (wh) <= 3: form_navn = "firkant" # finn kontursenter for å plassere tekst ved midt cv2.drawContours (bilde,, 0, (0,125,255), - 1) cv2.putText (bilde, formnavn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) annet: shape_name = "Reactangle" # finn kontursenter for å plassere tekst i midten cv2.drawContours (bilde,, 0, (0,0,255), - 1) M = cv2.momenter (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (bilde, formnavn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (ca.) == 10: formnavn = 'stjerne' cv2.drawContours (image,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (ca.)> = 15: formnavn = 'sirkel' cv2.drawContours (bilde,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identifisere former', bilde) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Linjedeteksjon

Linjedeteksjon er veldig viktig begrep i OpenCV, og har en lovende bruk i den virkelige verden. Autonome biler bruker linjedeteksjonsalgoritmer for påvisning av kjørefelt og veier.

I linjedeteksjon vil vi håndtere to algoritmer,

• Hough Line-algoritme
• Probalistisk Hough Line-algoritme.

Du har kanskje husket representasjonen av linje fra videregående matematikk med ligningen, y = mx + c.

Imidlertid er OpenCV-linjen representert på en annen måte

Ligningen over ρ = xcosӨ + ysincosӨ er OpenCV-representasjonen av linjen, hvor ρ er den vinkelrette avstanden til linjen fra opprinnelsen og Ө er vinkelen som er dannet av den normale av denne linjen til opprinnelsen (målt i radianer, hvor 1pi radianer / 180 = 1 grad).

OpenCV-funksjonen for deteksjon av linje er gitt som

cv2.HoughLines (binarisert bilde, ρ nøyaktighet, Ө nøyaktighet, terskel), hvor terskelen er minimumstemme for at den skal betraktes som en linje.

La oss nå oppdage linjer for et boksbilde ved hjelp av Hough-linjefunksjonen til opencv.

importer cv2 import numpy som np image = cv2.imread ('box.jpg')

Gråskala og søte kanter ekstrahert

grå = cv2.cvtColor (bilde, cv2.COLOR_BGR2GRAY) kanter = cv2.Canny (grå, 100.170, apertureSize = 3)

Kjør Hough-linjer med rho-nøyaktighet på 1 piksel

#theta-nøyaktighet på (np.pi / 180) som er 1 grad #linjeterskel er satt til 240 (antall punkter på linjen) linjer = cv2.HoughLines (kanter, 1, np.pi / 180, 240) #we iterate gjennom hver linje og konverter til formatet # kreves av cv2.lines (dvs. krever sluttpunkter) for i innen rekkevidde (0, len (linjer)): for rho, theta i linjer: a = np.cos (theta) b = np.sin (theta) x0 = a * rho y0 = b * rho x1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (bilde, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough linjer', image) cv2.waitKey (0) cv2.destroyAllWindows ()

La oss nå gjenta over linjedeteksjon med annen algoritme med sannsynlig Hough-linje.

Ideen bak den sannsynlige Hough-linjen er å ta en tilfeldig delmengde av punkter som er tilstrekkelig for linjedeteksjon.

OpenCV-funksjonen for sannsynlig Hough-linje er representert som cv2.HoughLinesP (binarisert bilde, ρ nøyaktighet, Ө nøyaktighet, terskel, minimum linjelengde, maks linjeavstand)

La oss nå oppdage bokselinjer ved hjelp av sannsynlige Hough-linjer.

import cv2 import numpy as np

Gråtone og søte kanter ekstrahert

image = cv2.imread ('box.jpg') grå = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) kanter = cv2.Canny (grå, 50,150, apertureSize = 3) # igjen bruker vi samme rho og theta nøyaktigheter # hvor som helst, spesifiserer vi en minimumstemme (poeng langs linjen) på 100 # og min linjelengde på 5 piksler og maks gap mellom linjene på 10 pikslinjer = cv2.HoughLinesP (kanter, 1, np.pi / 180,100,100,10) for i i rekkevidde (0, len (linjer)): for x1, y1, x2, y2 i linjer: cv2.line (bilde, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Bloddeteksjon

Blobs kan beskrives som en gruppe tilkoblede piksler som alle deler en felles eiendom. Metoden for å bruke OpenCV blob detektor er beskrevet gjennom dette flytskjemaet.

For å tegne nøkkelpunktene bruker vi cv2.drawKeypoints som tar følgende argumenter.

cv2.drawKeypoints (input image, keypoints, blank_output_array, color, flags)

hvor i flaggene kunne være

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

og tomt her er stort sett ingenting annet enn en og en matrise med nuller

La oss nå utføre oppdagelsen av klatter på et bilde av solsikker, hvor klattene ville være de sentrale delene av blomsten, ettersom de er vanlige blant alle blomstene.

import cv2 import numpy as np image = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

Sett opp detektor med standardparametere

detektor = cv2.SimpleBlobDetector_create ()

Oppdag klatter

tastatur = detektor.detect (bilde)

Tegn oppdagede klatter som røde sirkler

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS sørger for at #størrelsen på sirkelen tilsvarer størrelsen på blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,255), cv2.DRAW_AT)

Vis tastatur

cv2.imshow ('blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Selv om koden fungerer bra, men noen av klattene blir savnet på grunn av ujevne størrelser på blomstene, siden blomstene foran er store sammenlignet med blomstene på slutten.

9. Filtrering av klatter - teller sirkler og ellipser

Vi kan bruke parametere for å filtrere klattene i henhold til form, størrelse og farge. For å bruke parametere med blob detektor bruker vi OpenCVs funksjon

cv2.SimpleBlobDetector_Params ()

Vi ser filtrering av blobs etter hovedsakelig disse fire parametrene som er oppført nedenfor:

Område

params.filterByArea = True / False params.minArea = piksler params.maxArea = piksler

Sirkularitet

params.filterByCircularity = True / False params.minCircularity = 1 er perfekt, 0 er motsatt

Konveksitet - Areal med klatt / område med konveks skrog

params.filterByConvexity = True / False params.minConvexity = Areal

Treghet

params.filterByInertia = True / False params.minInertiaRatio = 0.01

La oss nå prøve å filtrere klatter etter ovennevnte parametere

importer cv2 import numpy som np image = cv2.imread ('blobs.jpg') cv2.imshow ('original image', image) cv2.waitKey (0)

Initialiser detektoren ved hjelp av standardparametere

detektor = cv2.SimpleBlobDetector_create ()

Oppdag klatter

tastatur = detektor.detect (bilde)

Tegn klatter på bildet vårt som røde sirkler

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "totalt antall blobs" + str (len (tastatur)) cv2.putText (klatter, tekst, (20550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Vis bilde med blob-tastatur

cv2.imshow ('blob ved hjelp av standardparametere', blobs) cv2.waitKey (0)

Angi filtreringsparametrene

#initialize parameter setting ved hjelp av cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Still inn områdefiltreringsparametere

params.filterByArea = Ekte params.minArea = 100

Angi filtreringsparametere for sirkularitet

params.filterByCircularity = Ekte params.minCircularity = 0,9

Angi parameter for konveksitetsfiltrering

params.filterByConvexity = Falske params.minConvexity = 0,2

Angi treghetsfiltreringsparameter

params.filterByInertia = Ekte params.minInertiaRatio = 0.01

Lag detektor med parameter

detektor = cv2.SimpleBlobDetector_create (params)

Oppdag klatter

tastatur = detektor.detect (bilde)

Tegn klatter på bildene som røde sirkler

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "totalt antall sirkulære blobs" + str (len (tastatur)) cv2.putText (klatter, tekst, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Vis klatter

cv2.imshow ('filtrering av sirkulære blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Så dette er hvordan bildesegmentering kan gjøres i Python-OpenCV. For å få god undervurdering av datasyn og OpenCV, gå gjennom tidligere artikler (Komme i gang med Python OpenCV og Image Manipulations i Python OpenCV, så vil du kunne gjøre noe kult med Computer Vision.