Billedsegmentering ved hjælp af opencv

I de foregående tutorials har vi brugt OpenCV til grundlæggende billedbehandling og udført nogle avancerede billedredigeringsoperationer. Som vi ved, er OpenCV Open Source Commuter Vision Library, der har C ++, Python og Java-grænseflader og understøtter Windows, Linux, Mac OS, iOS og Android. Så det kan let installeres i Raspberry Pi med Python og Linux-miljø. Og Raspberry Pi med OpenCV og tilsluttet kamera kan bruges til at oprette mange realtids billedbehandlingsapplikationer som ansigtsgenkendelse, ansigtslås, genstandssporing, bilnummerpladesporing, hjemmesikkerhedssystem osv. I denne vejledning lærer vi, hvordan man gør billedsegmentering ved hjælp af OpenCV. De operationer, vi skal udføre, er anført nedenfor:

Segmentering og konturer
Hierarki og hentningstilstand
Tilnærmede konturer og finde deres konvekse skrog
Conex Skrog
Matchende kontur
Identifikation af figurer (cirkel, rektangel, trekant, firkant, stjerne)
Linjedetektion
Blob detektion
Filtrering af klatterne - tæller cirkler og ellipser

1. Segmentering og konturer

Billedsegmentering er en proces, hvor vi deler billeder i forskellige regioner. Mens konturerne er de kontinuerlige linjer eller kurver, der afgrænser eller dækker en genstands fulde grænse i et billede. Og her bruger vi billedsegmenteringsteknik kaldet konturer til at udtrække delene af et billede.

Også konturer er meget vigtige i

Objektdetektion
Formanalyse

Og de har meget bredt anvendelsesområde fra den virkelige verdens billedanalyse til medicinsk billedanalyse som i MR'er

Lad os vide, hvordan man implementerer konturer i opencv ved at udtrække konturer af firkanter.

import cv2 import numpy som np

Lad os indlæse et simpelt billede med 3 sorte firkanter

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

Gråtone

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

Find dåse kanter

kantet = cv2.Canny (grå, 30.200) cv2.imshow ('dåsige kanter', kantet) cv2.waitKey (0)

Find konturer

# Brug en kopi af dit billede, f.eks. - edged.copy (), da det at finde konturer ændrer billedet # vi skal tilføje _ før konturerne som et tomt argument på grund af opgradering af OpenCV-version _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('dåsige kanter efter konturering', kantet) cv2.waitKey (0)

Udskrivning af konturfilen for at vide, hvad konturer består af

print (konturer) print ('Antal konturer fundet =' + str (len (konturer)))

Tegn alle konturer

# brug -1 som den 3. parameter til at tegne alle konturerne cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Konsol output -],],], …,],],]], dtype = int32), matrix (],],

], …,

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

Antal konturer fundet = 3. Så vi har fundet i alt tre konturer.

Nu, i ovenstående kode, havde vi også udskrevet konturfilen ved hjælp af , denne fil fortæller, hvordan disse konturer ser ud, som den er trykt i ovenstående konsoloutput.

I ovenstående konsoloutput har vi en matrix, der ligner koordinater for x, y-punkter. OpenCV gemmer konturer i en lister over lister. Vi kan simpelthen vise ovenstående konsoloutput som følger:

KONTUR 1 KONTUR 2 KONTUR 3

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

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

Når vi nu bruger længdefunktionen på konturfilen, får vi længden lig med 3, det betyder, at der var tre lister over lister i den fil, dvs. tre konturer.

Forestil dig nu, at KONTUR 1 er det første element i denne matrix, og at listen indeholder en liste over alle koordinaterne, og disse koordinater er de punkter langs konturerne, som vi lige så, som de grønne rektangulære felter.

Der er forskellige metoder til at gemme disse koordinater, og disse kaldes tilnærmelsesmetoder, grundlæggende er tilnærmelsesmetoder af to typer

cv2.CHAIN_APPROX_NONE
cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE gemmer alle grænsepunkter, men vi har ikke nødvendigvis brug for alle grænsepunkter, hvis punktet danner en lige linje, behøver vi kun startpunktet og slutpunktet på den linje.

cv2.CHAIN_APPROX_SIMPLE giver i stedet kun start- og slutpunkterne for de afgrænsende konturer, resultatet er meget mere effektiv opbevaring af konturinformation.

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

I ovenstående kode er cv2.RETR_EXTERNAL hentningstilstand, mens cv2.CHAIN_APPROX_NONE er

tilnærmelsesmetoden.

Så vi har lært om konturer og tilnærmelsesmetode, lad os nu undersøge hierarki og hentningstilstand.

2. Hierarki og hentningstilstand

Hentningstilstand definerer hierarkiet i konturer som underkonturer eller ekstern kontur eller alle konturer.

Nu er der fire hentningstilstande sorteret efter hierarkityperne.

cv2.RETR_LIST - henter alle konturer.

cv2.RETR_EXTERNAL - henter kun eksterne eller ydre konturer.

cv2.RETR_CCOMP - henter alle i et 2-niveau hierarki.

cv2.RETR_TREE - henter alle i et fuldt hierarki.

Hierarki gemmes i følgende format

Lad os nu illustrere forskellen mellem de to første hentningstilstande, cv2.RETR_LIST og cv2.RETR_EXTERNAL.

import cv2 import numpy som np

Lad os indlæse et simpelt billede med 3 sorte firkanter

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

Gråtone

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

Find Canny Edges

kantet = cv2.Canny (grå, 30.200) cv2.imshow ('dåsige kanter', kantet) cv2.waitKey (0)

Find konturer

# brug en kopi af dit billede, f.eks. - edged.copy (), da det at finde konturer ændrer billedet # vi skal tilføje _ før konturerne som et tomt argument på grund af opgradering af den åbne cv-version _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('dåsige kanter efter konturering', kantet) cv2.waitKey (0)

Udskrivning af konturfilen for at vide, hvad konturer består af.

print (konturer) print ('Antal konturer fundet =' + str (len (konturer)))

Tegn alle konturer

import cv2 import numpy som np

Lad os indlæse et simpelt billede med 3 sorte firkanter

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

Gråtone

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

Find dåse kanter

kantet = cv2.Canny (grå, 30.200) cv2.imshow ('dåsige kanter', kantet) cv2.waitKey (0)

Find konturer

# brug en kopi af dit billede, f.eks. - edged.copy (), da det at finde konturer ændrer billedet # vi skal tilføje _ før konturerne som et tomt argument på grund af opgradering af den åbne cv-version _, konturer, hierarki = cv2.findContours (kantet, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('dåsige kanter efter konturering', kantet) cv2.waitKey (0)

Udskrivning af konturfilen for at vide, hvad konturer består af.

print (konturer) print ('Antal konturer fundet =' + str (len (konturer)))

Tegn alle konturer

Så gennem demonstrationen af ovenstående koder kunne vi tydeligt se forskellen mellem cv2.RETR_LIST og cv2.RETR_EXTERNNAL , i cv2.RETR_EXTERNNAL tages kun de ydre konturer i betragtning, mens de indre konturer ignoreres.

Mens der i cv2.RETR_LIST der også tages hensyn til indre konturer.

3. Tilnærmelse af konturer og finde deres konvekse skrog

I tilnærmede konturer tilnærmes en konturform over en anden konturform, hvilket muligvis ikke ligner den første konturform.

Til tilnærmelse bruger vi approxPolyDP- funktion af openCV, som forklares nedenfor

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

Parametre:

Kontur - er den individuelle kontur, vi ønsker at tilnærme.
Tilnærmelsesnøjagtighed - vigtig parameter til bestemmelse af nøjagtigheden af tilnærmelse, lille værdi giver nøjagtig tilnærmelse, store værdier giver mere generisk information. En god tommelfingerregel er mindre end 5% af konturens omkreds.
Lukket - en boolsk værdi, der angiver, om den omtrentlige kontur kan være åben eller lukket.

Lad os prøve at tilnærme en simpel figur af et hus

import numpy som np import cv2

Indlæs billedet, og opbevar 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 billedet

grå = cv2.cvtColor (billede, cv2.COLOR_BGR2GRAY) ret, tærskel = cv2.tærskel (grå, 127.255, cv2.THRESH_BINARY_INV)

Find konturer

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

Iterer gennem hver kontur og beregner deres afgrænsende 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 gennem hver kontur og beregner den omtrentlige kontur

for c i konturer:

#beregn nøjagtighed som en procentdel af nøjagtigheden af konturens omkreds = 0,03 * cv2.arcLength (c, True) ca. = cv2.approxPolyDP (c, nøjagtighed, True) cv2.drawContours (billede,, 0, (0,255,0), 2) cv2.imshow ('Ca. polyDP', billede) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konveks skrog

Konveks skrog er dybest set de ydre kanter, repræsenteret ved at tegne linjer over en given figur.

Det kan være den mindste polygon, der kan passe omkring selve objektet.

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

Tærskelbillede

ret, tærske = cv2.tærskel (grå, 176,255,0)

Find konturer

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

Sorter konturerne efter område, og fjern derefter den største rammekontur

n = len (konturer) -1 konturer = sorteret (konturer, nøgle = cv2.contourArea, reverse = False)

Iterer gennem konturerne og tegner konveks skrog

for c i konturer:

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

5. Matchende kontur efter former

cv2.matchShapes (konturskabelon, konturmetode, metodeparameter)

Output - matchværdi (lavere værdi betyder en tættere match)

konturskabelon - Dette er vores referencekontur, som vi prøver at finde i et nyt billede.

kontur - Den individuelle kontur, vi kontrollerer mod.

Metode - Konturtilpasningstype (1,2,3).

metode parameter - lad være alene som 0,0 (ikke brugt i python opencv)

import cv2 import numpy som np

Indlæs formskabelonen eller referencebilledet

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

Indlæs målbilledet med de figurer, vi prøver at matche

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

Tærskel begge billederne først, før du bruger cv2.findContours

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

Find konturer i skabelonen

_, konturer, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # vi har brug for at sortere konturerne efter område, så vi kan fjerne den største kontur, der er

Billedoversigt

sorted_contours = sorteret (konturer, nøgle = cv2.contourArea, reverse = True) # vi ekstraherer den næststørste kontur, som vil være vores skabelon kontur tempelate_contour = konturer # udtræk konturerne fra det andet målbillede _, konturer, hierarki = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) til c i konturer: #iterate gennem hver kontur i målbilledet og brug cv2.matchShape til at sammenligne konturform match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") #if matchværdi er mindre end 0,15, hvis match <0,16: nærmeste_kontur = c andet: nærmeste_kontur = cv2.drawContours (mål,, - 1, (0,255,0), 3) cv2.imshow ('output',mål) cv2.waitKey (0) cv2.destroyAllWindows ()

Konsol output -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0,11101058276281539

Der er tre forskellige metoder med forskellige matematikfunktioner, vi kan eksperimentere med hver metode ved blot at erstatte cv2.matchShapes (tempelate_contour, c, 1, 0.0) metodeværdier, der varierer fra 1,2 og 3, for hver værdi får du forskellige match værdier i konsoloutput.

6. Identifikation af figurer (cirkel, rektangel, trekant, firkant, stjerne)

OpenCV kan også bruges til automatisk at detektere forskellige typer former fra billedet. Ved at bruge nedenstående kode vil vi være i stand til at registrere cirkel, rektangel, trekant, firkant og stjerner fra billedet.

import cv2 import numpy som np

Indlæs og derefter billeder i grå skala

billede = cv2.imread ('shapes.jpg') grå = cv2.cvtColor (billede, cv2.COLOR_BGR2GRAY) cv2.imshow ('identificerende figurer', billede) cv2.waitKey (0) ret, thresh = cv2.threshold (grå 127,255,1)

Uddrag 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 (billede,, 0, (0,255, 0), - 1)

find konturcenter for at placere tekst i midten

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (billede, 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 firesidede polygon er firkantet eller rektangel

# cv2.boundingRect returnerer venstre bredde og højde i pixels, startende fra det øverste # venstre hjørne, for kvadrat ville det være omtrent det samme, hvis abs (wh) <= 3: form_navn = "firkant" # find konturcenter for at placere tekst ved center cv2.drawContours (billede,, 0, (0,125,255), - 1) cv2.putText (billede, formnavn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) andet: form_navn = "Reaktangel" # find konturcenter for at placere tekst i centrum cv2.drawContours (billede,, 0, (0,0,255), - 1) M = cv2.momenter (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (billede, 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 = 'cirkel' cv2.drawContours (billede,, 0, (0,255,255), -1) M = cv2.momenter (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (billede, formnavn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identificerende figurer', billede) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Linjedetektion

Linjedetektion er meget vigtigt koncept i OpenCV og har en lovende anvendelse i den virkelige verden. Autonome biler bruger linjedetekteringsalgoritmer til detektering af baner og veje.

I linjedetektering beskæftiger vi os med to algoritmer,

Hough Line Algoritme
Probalistisk Hough Line-algoritme.

Du har muligvis husket repræsentationen af linjen fra gymnasiets matematik med ligningen, y = mx + c.

Imidlertid er linjen i OpenCV repræsenteret på en anden måde

Ligningen over ρ = xcosӨ + ysincosӨ er OpenCV-repræsentationen af linjen, hvor ρ er den vinkelrette linjeafstand fra oprindelsen, og Ө er vinklen dannet af den normale af denne linie til oprindelsen (målt i radianer, hvor 1pi radianer / 180 = 1 grad).

OpenCV-funktionen til detektion af linje er angivet som

cv2.HoughLines (binært billede, ρ nøjagtighed, Ө nøjagtighed, tærskel), hvor tærsklen er minimumstemme for at den kan betragtes som en linje.

Lad os nu opdage linjer til et feltbillede ved hjælp af opencv-linjens funktion.

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

Gråskala og dåse kanter ekstraheret

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

Kør Hough-linjer ved hjælp af rho-nøjagtighed på 1 pixel

#theta-nøjagtighed på (np.pi / 180), som er 1 grad # linjetærskel er indstillet til 240 (antal punkter på linjen) linjer = cv2.HoughLines (kanter, 1, np.pi / 180, 240) # vi gentager gennem hver linje og konverter til formatet # kræves af cv2.lines (dvs. kræver slutpunkter) for i i området (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 (billede, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough linjer', billede) cv2.waitKey (0) cv2.destroyAllWindows ()

Lad os gentage ovenstående linjedetektion med anden algoritme med sandsynlig Hough-linje.

Ideen bag den sandsynlige Hough-linje er at tage en tilfældig delmængde af punkter, der er tilstrækkelige til linjedetektion.

OpenCV-funktionen til probabilistisk Hough-linje er repræsenteret som cv2.HoughLinesP (binært billede, ρ-nøjagtighed, Ө nøjagtighed, tærskel, minimum linjelængde, maks. Linjeafstand)

Lad os nu opdage bokslinjer ved hjælp af sandsynlige Hough-linjer.

import cv2 import numpy som np

Gråskala og dåse kanter ekstraheret

image = cv2.imread ('box.jpg') grå = cv2.cvtColor (billede, cv2.COLOR_BGR2GRAY) kanter = cv2.Canny (grå, 50,150, apertureSize = 3) # igen bruger vi den samme rho og theta nøjagtighed # dog, vi angiver en minimumstemme (pts langs linjen) på 100 # og min linjelængde på 5 pixels og maks. afstand mellem linjerne på 10 pixels linjer = cv2.HoughLinesP (kanter, 1, np.pi / 180,100,100,10) for i i rækkevidde (0, len (linjer)): for x1, y1, x2, y2 i linjer: cv2.line (billede, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Blob-detektion

Blobs kan beskrives som en gruppe af tilsluttede pixels, som alle deler en fælles ejendom. Metoden til brug af OpenCV-blobdetektor er beskrevet gennem dette flowdiagram.

Til tegning af nøglepunkterne bruger vi cv2.drawKeypoints, som tager følgende argumenter.

cv2.drawKeypoints (inputbillede, tastatur, blank_output_array, farve, flag)

hvor i flagene 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 set intet andet end en efter en matrix af nuller

Lad os nu udføre detekteringen af klatter på et billede af solsikker, hvor klatterne ville være de centrale dele af blomsten, da de er almindelige blandt alle blomsterne.

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

Opsæt detektor med standardparametre

detektor = cv2.SimpleBlobDetector_create ()

Registrer klatter

tastatur = detektor.detect (billede)

Tegn opdagede klatter som røde cirkler

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS sørger for, at #størrelse af cirkel svarer til størrelsen på blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (billede, tastatur, blank, (0,255,255), cv2.DRAW_S)

Vis tastatur

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

Selvom koden fungerer fint, men nogle af klatterne går glip af på grund af ujævn størrelse på blomsterne, da blomsterne foran er store sammenlignet med blomsterne i slutningen.

9. Filtrering af klatter - tæller cirkler og ellipser

Vi kan bruge parametre til at filtrere klatterne i henhold til deres form, størrelse og farve. Til brug af parametre med blobdetektor bruger vi OpenCV's funktion

cv2.SimpleBlobDetector_Params ()

Vi vil se filtrering af klatterne ved hovedsageligt disse fire parametre, der er anført nedenfor:

Areal

params.filterByArea = Sand / falsk params.minArea = pixels params.maxArea = pixels

Cirkularitet

params.filterByCircularity = Sand / falsk params.minCircularity = 1 er perfekt, 0 er modsat

Konveksitet - Areal af blob / område med konveks skrog

params.filterByConvexity = Sand / falsk params.minConvexity = Areal

Inerti

params.filterByInertia = Sand / falsk params.minInertiaRatio = 0,01

Lad os nu prøve at filtrere klatter efter ovennævnte parametre

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

Initialiser detektoren ved hjælp af standardparametre

detektor = cv2.SimpleBlobDetector_create ()

Registrer klatter

tastatur = detektor.detect (billede)

Tegn klatter på vores billede som røde cirkler

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 = "total antal blobs" + str (len (tastatur)) cv2.putText (klatter, tekst, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Vis billede med blob-tastaturer

cv2.imshow ('blob ved hjælp af standardparametre', blobs) cv2.waitKey (0)

Indstil vores filtreringsparametre

#initialize parameterindstilling ved hjælp af cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Indstil områdefiltreringsparametre

params.filterByArea = Ægte params.minArea = 100

Indstil parametre for filtrering af cirkularitet

params.filterByCircularity = Ægte params.minCircularity = 0,9

Indstil parameter for konveksitetsfiltrering

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

Indstil parameter for inertifiltrering

params.filterByInertia = Ægte params.minInertiaRatio = 0,01

Opret detektor med parameter

detektor = cv2.SimpleBlobDetector_create (params)

Registrer klatter

tastatur = detektor.detect (billede)

Tegn klatter på billederne som røde cirkler

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 = "total antal cirkulæ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 af cirkulære klatter', klatter) cv2.waitKey (0) cv2.destroyAllWindows ()

Så dette er, hvordan billedsegmentering kan udføres i Python-OpenCV. For at få en god underdrivelse af computersyn og OpenCV, skal du gennemgå tidligere artikler (Kom godt i gang med Python OpenCV og Image Manipulations i Python OpenCV, så kan du gøre noget sejt med Computer Vision.

Billedsegmentering ved hjælp af opencv

1. Segmentering og konturer

2. Hierarki og hentningstilstand

3. Tilnærmelse af konturer og finde deres konvekse skrog

4. Konveks skrog

5. Matchende kontur efter former

6. Identifikation af figurer (cirkel, rektangel, trekant, firkant, stjerne)

7. Linjedetektion

8. Blob-detektion

9. Filtrering af klatter - tæller cirkler og ellipser

Valg af editor