Bildsegmentering med opencv

I de tidigare självstudierna har vi använt OpenCV för grundläggande bildbehandling och gjort några avancerade bildredigeringsåtgärder. Som vi vet är OpenCV Open Source Commuter Vision Library som har C ++, Python och Java-gränssnitt och stöder Windows, Linux, Mac OS, iOS och Android. Så det kan enkelt installeras i Raspberry Pi med Python och Linux-miljö. Och Raspberry Pi med OpenCV och ansluten kamera kan användas för att skapa många realtidsbildbearbetningsapplikationer som ansiktsavkänning, ansiktslås, föremålsspårning, bilnummerplåtsdetektering, hemskyddssystem etc. I denna handledning lär vi oss hur man gör bildsegmentering med OpenCV. De åtgärder vi ska utföra listas nedan:

• Segmentering och konturer
• Hierarki och hämtningsläge
• Ungefärliga konturer och hitta deras konvexa skrov
• Conex Skrov
• Matchande kontur
• Identifiera former (cirkel, rektangel, triangel, kvadrat, stjärna)
• Linjedetektering
• Blobdetektering
• Filtrering av klumpar - räknar cirklar och ellipser

1. Segmentering och konturer

Bildsegmentering är en process genom vilken vi delar upp bilder i olika regioner. Medan konturerna är de kontinuerliga linjerna eller kurvorna som binder eller täcker hela objektets gräns i en bild. Och här kommer vi att använda bildsegmenteringsteknik som kallas konturer för att extrahera delarna av en bild.

Konturer är också mycket viktiga i

• Objektdetektering
• Formanalys

Och de har ett mycket brett användningsområde från den verkliga bildanalysen till medicinsk bildanalys som i MR

Låt oss veta hur man implementerar konturer i opencv, genom att extrahera konturer av rutor.

importera cv2 importera numpy som np

Låt oss ladda en enkel bild med tre svarta rutor

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

Gråskala

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

Hitta kanytiga kanter

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

Hitta konturer

#använd en kopia av din bild, t.ex. - edged.copy (), eftersom att hitta konturer ändrar bilden # vi måste lägga till _ före konturerna som ett tomt argument på grund av uppgradering av OpenCV-versionen _, konturer, hierarki = cv2.findContours (kantad, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ("kany kanter efter konturering", kantad) cv2.waitKey (0)

Skriva ut konturfilen för att veta vad konturerna består av

skriv ut (konturer) tryck ('Antal konturer hittades =' + str (len (konturer)))

Rita alla konturer

#använd -1 som den tredje parametern för att rita alla konturerna cv2.drawContours (bild, konturer, -1, (0,255,0), 3) cv2.imshow ('konturer', bild) cv2.waitKey (0) cv2. destroyAllWindows ()

Konsolutgång -],],], …,],],]], dtype = int32), array (],],

], …,

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

Antal konturer hittade = 3. Så vi har hittat totalt tre konturer.

Nu, i ovanstående kod hade vi också skrivit ut konturfilen med , den här filen berättar hur dessa konturer ser ut, som skrivs ut i konsolutgången ovan.

I konsolutgången ovan har vi en matris som ser ut som koordinater för x, y-punkter. OpenCV lagrar konturer i listor med listor. Vi kan helt enkelt visa ovanstående konsolutgång enligt följande:

KONTUR 1 KONTUR 2 KONTUR 3

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

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

Nu när vi använder längdfunktionen på konturfilen får vi längden lika med 3, det betyder att det fanns tre listor med listor i den filen, dvs tre konturer.

Tänk dig nu att KONTUR 1 är det första elementet i den matrisen och den listan innehåller en lista över alla koordinater och dessa koordinater är punkterna längs konturerna som vi just såg, som de gröna rektangulära rutorna.

Det finns olika metoder för att lagra dessa koordinater och dessa kallas approximationsmetoder, i princip är approximationsmetoder av två typer

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE lagrar alla gränspunkter, men vi behöver inte nödvändigtvis alla gränspunkter, om punkten bildar en rak linje behöver vi bara startpunkten och slutpunkten på den linjen.

cv2.CHAIN_APPROX_SIMPLE ger istället bara start- och slutpunkterna för de avgränsande konturerna, resultatet är mycket effektivare lagring av konturinformation.

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

I ovanstående kod är cv2.RETR_EXTERNAL hämtningsläget medan cv2.CHAIN_APPROX_NONE är

tillnärmningsmetoden.

Så vi har lärt oss om konturer och approximationsmetod, låt oss nu utforska hierarki och hämtningsläge.

2. Hierarki och hämtningsläge

Hämtningsläge definierar hierarkin i konturer som subkonturer, eller extern kontur eller alla konturer.

Nu finns det fyra hämtningslägen sorterade på hierarkityperna.

cv2.RETR_LIST - hämtar alla konturer.

cv2.RETR_EXTERNAL - hämtar endast externa eller yttre konturer.

cv2.RETR_CCOMP - hämtar alla i en 2-nivå hierarki.

cv2.RETR_TREE - hämtar alla i en fullständig hierarki.

Hierarki lagras i följande format

Låt oss nu illustrera skillnaden mellan de två första hämtningslägena, cv2.RETR_LIST och cv2.RETR_EXTERNAL.

importera cv2 importera numpy som np

Låter oss ladda en enkel bild med tre svarta rutor

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

Gråskala

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

Hitta Canny Edges

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

Hitta konturer

#använd en kopia av din bild, t.ex. - edged.copy (), eftersom att hitta konturer ändrar bilden # vi måste lägga till _ före konturerna som ett tomt argument på grund av uppgradering av den öppna cv-versionen _, konturer, hierarki = cv2.findContours (kantad, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('dåsiga kanter efter konturering', kantad) cv2.waitKey (0)

Skriva ut konturfilen för att veta vad konturerna består av.

skriv ut (konturer) tryck ('Antal konturer hittades =' + str (len (konturer)))

Rita alla konturer

#använd -1 som den tredje parametern för att rita alla konturer cv2.drawContours (bild, konturer, -1, (0,255,0), 3) cv2.imshow ('konturer', bild) cv2.waitKey (0) cv2. förstöra AllWindows

importera cv2 importera numpy som np

Låter oss ladda en enkel bild med tre svarta rutor

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

Gråskala

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

Hitta kanytiga kanter

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

Hitta konturer

#använd en kopia av din bild, t.ex. - edged.copy (), eftersom att hitta konturer ändrar bilden # vi måste lägga till _ före konturerna som ett tomt argument på grund av uppgradering av den öppna cv-versionen _, konturer, hierarki = cv2.findContours (kantad, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('kany kanter efter konturering', kantad) cv2.waitKey (0)

Skriva ut konturfilen för att veta vad konturerna består av.

skriv ut (konturer) tryck ('Antal konturer hittades =' + str (len (konturer)))

Rita alla konturer

#använd -1 som den tredje parametern för att rita alla konturerna cv2.drawContours (bild, konturer, -1, (0,255,0), 3) cv2.imshow ('konturer', bild) cv2.waitKey (0) cv2. destroyAllWindows ()

Så genom demonstrationen av ovanstående koder kunde vi tydligt se skillnaden mellan cv2.RETR_LIST och cv2.RETR_EXTERNNAL , i cv2.RETR_EXTERNNAL beaktas endast de yttre konturerna medan de inre konturerna ignoreras.

Medan i cv2.RETR_LIST tas också hänsyn till inre konturer.

3. Ungefärliga konturer och hitta deras konvexa skrov

I ungefärliga konturer approximeras en konturform över en annan konturform, vilket kanske inte liknar den första konturformen.

För approximering använder vi approxPolyDP- funktionen av openCV som förklaras nedan

cv2.approxPolyDP (kontur, approximationsnoggrannhet, stängd)

Parametrar:

• Kontur - är den individuella konturen vi vill approximera.
• Ungefärlig noggrannhet - viktig parameter för att bestämma approximationens noggrannhet, litet värde ger exakt approximation, stora värden ger mer generisk information. En bra tumregel är mindre än 5% av konturens omkrets.
• Stängt - ett booleskt värde som anger om den ungefärliga konturen kan vara öppen eller stängd.

Låt oss försöka approximera en enkel figur av ett hus

importera numpy som np import cv2

Ladda bilden och behåll en kopia

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

Gråskala och binära bilden

grå = cv2.cvtColor (bild, cv2.COLOR_BGR2GRAY) ret, trösk = cv2.tröskel (grå, 127,255, cv2.THRESH_BINARY_INV)

Hitta konturer

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

Iterera genom varje kontur och beräkna deras avgränsande rektangel

för 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)

Iterera genom varje kontur och beräkna ungefär konturen

för c i konturer:

#beräkna noggrannhet som procent av noggrannheten för konturens omkrets = 0,03 * cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, precision, True) cv2.drawContours (bild,, 0, (0,255,0), 2) cv2.imshow ('Ca polyDP', bild) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konvex skrov

Konvex skrov är i princip de yttre kanterna, representerade av att rita linjer över en viss figur.

Det kan vara den minsta polygonen som kan passa runt själva objektet.

importera cv2 importera numpy som np image = cv2.imread ('star.jpg') grå = cv2.cvtColor (bild, cv2.COLOR_BGR2GRAY) cv2.imshow ('originalbild', bild) cv2.waitKey (0)

Tröskelvärde bilden

ret, trösk = cv2.tröskel (grå, 176,255,0)

Hitta konturer

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

Sortera konturerna efter område och ta sedan bort den största ramkonturen

n = len (konturer) -1 konturer = sorterade (konturer, nyckel = cv2.contourArea, omvänd = Falsk)

Iterera genom konturerna och dra det konvexa skrovet

för c i konturer:

skrov = cv2.convexHull (c) cv2.drawContours (bild,, 0, (0,255,0), 2) cv2.imshow ('konvex skrov', bild) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Matcha konturen efter former

cv2.matchShapes (konturmall, konturmetod, metodparameter)

Output - matchningsvärde (lägre värde betyder en närmare matchning)

konturmall - Detta är vår referenskontur som vi försöker hitta i en ny bild.

kontur - Den individuella konturen vi kontrollerar mot.

Metod - Typ av konturmatchning (1,2,3).

metodparameter - lämna ensam som 0,0 (används inte i python opencv)

importera cv2 importera numpy som np

Ladda formmallen eller referensbilden

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

Ladda målbilden med de former vi försöker matcha

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

Tröskelvärden för båda bilderna först innan du använder cv2.findContours

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

Hitta konturer i mallen

_, konturer, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # vi behöver sortera konturerna efter område så att vi kan ta bort den största konturen som är

Bildkontur

sorted_contours = sorted (contours, key = cv2.contourArea, reverse = True) # vi extraherar den näst största konturen som blir vår mallkontur tempelate_contour = konturer # extraherar konturerna från den andra målbilden _, konturer, hierarki = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) för c in konturer: #iterate genom varje kontur i målbilden och användning cv2.matchShape att jämföra de konturform match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") #if matchvärde är mindre än 0,15 om matchning <0,16: närmast_kontur = c annat: närmast_kontur = cv2.drawContours (mål,, - 1, (0,255,0), 3) cv2.imshow ('output',mål) cv2.waitKey (0) cv2.destroyAllWindows ()

Konsolutgång -

0.16818605122199104

0.19946910256158912

0,188949760627309664

0,11101058276281539

Det finns tre olika metoder med olika matematiska funktioner, vi kan experimentera med varje metod genom att bara ersätta cv2.matchShapes (tempelate_contour, c, 1, 0.0) metodvärden som varierar från 1,2 och 3, för varje värde får du olika matchningar värden i konsolutgång.

6. Identifiera former (cirkel, rektangel, triangel, kvadrat, stjärna)

OpenCV kan också användas för att automatiskt upptäcka olika typer av former från bilden. Genom att använda koden nedan kommer vi att kunna upptäcka cirkel, rektangel, triangel, kvadrat och stjärnor från bilden.

importera cv2 importera numpy som np

Ladda och sedan gråskalebilder

bild = cv2.imread ('shapes.jpg') grå = cv2.cvtColor (bild, cv2.COLOR_BGR2GRAY) cv2.imshow ('identifierande former', bild) cv2.waitKey (0) ret, thresh = cv2.threshold (grå 127,255,1)

Extrahera konturer

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

För cnt i konturer:

Få ungefärliga polygoner ca = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) om len (approx) == 3: shape_name = "Triangle" cv2.drawContours (bild,, 0, (0,255, 0), - 1)

hitta konturcentrum för att placera text i mitten

M = cv2. Ögonblick (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (bild, formnamn, (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.moment (cnt) cx = int (M / M) cy = int (M / M)

Kontrollera om den fyrsidiga polygonen är kvadratisk eller rektangel

# cv2.boundingRect returnerar den vänstra bredden och höjden i pixlar, med början från det övre # vänstra hörnet, för kvadrat skulle det vara ungefär samma om abs (wh) <= 3: form_namn = "kvadrat" # hitta konturcentrum för att placera text vid center cv2.drawContours (image,, 0, (0,125,255), - 1) cv2.putText (image, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) annat: shape_name = "Reactangle" # hitta konturcentrum för att placera text i mitten cv2.drawContours (bild,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (bild, formnamn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (ungefär) == 10: formnamn = 'stjärna' cv2.drawContours (image,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, form_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (approx)> = 15: formnamn = 'cirkel' cv2.drawContours (bild,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (bild, formnamn, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identifierande former', bild) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Linjedetektering

Linjedetektering är ett mycket viktigt koncept i OpenCV och har en lovande användning i den verkliga världen. Autonoma bilar använder linjedetekteringsalgoritmer för detektering av körfält och vägar.

I raddetektering kommer vi att hantera två algoritmer,

• Hough Line-algoritm
• Probalistisk Hough Line-algoritm.

Du kanske har kommit ihåg representationen av linje från gymnasiematematik med ekvationen, y = mx + c.

Men i OpenCV-linjen representeras av ett annat sätt

Ekvationen ovanför ρ = xcosӨ + ysincosӨ är OpenCV-representationen av linjen, varvid ρ är det vinkelräta avståndet för linjen från ursprunget och Ө är den vinkel som bildas av denna linjens normala mot ursprunget (uppmätt i radianer, varvid 1pi radianer / 180 = 1 grad).

OpenCV-funktionen för detektering av linje ges som

cv2.HoughLines (binariserad bild, ρ-noggrannhet, Ө noggrannhet, tröskel), där tröskeln är minsta röst för att den ska betraktas som en linje.

Låt oss nu upptäcka rader för en ruta med hjälp av Hough-linjefunktionen i opencv.

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

Gråskala och dunkla kanter extraheras

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

Kör Hough-linjer med rho-noggrannhet på 1 pixel

#theta-noggrannhet för (np.pi / 180) som är 1 grad # linjetröskel är inställd på 240 (antal punkter på linjen) linjer = cv2.HoughLines (kanter, 1, np.pi / 180, 240) # vi itererar genom varje rad och konvertera till formatet # erfordras av cv2.lines (dvs. kräver slutpunkter) för i inom intervallet (0, len (rader)): för rho, theta i rader: 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 (bild, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough linjer', bild) cv2.waitKey (0) cv2.destroyAllWindows ()

Låt oss nu upprepa ovanstående raddetektering med annan algoritm för probabilistisk Hough-linje.

Idén bakom den probabilistiska Hough-linjen är att ta en slumpmässig delmängd av punkter tillräckligt för linjedetektering.

OpenCV-funktionen för probabilistisk Hough-linje representeras som cv2.HoughLinesP (binärbild, ρ-noggrannhet, Ө noggrannhet, tröskel, minsta linjelängd, max linjeavstånd)

Låt oss nu upptäcka rutor med hjälp av probabilistiska Hough-linjer.

importera cv2 importera numpy som np

Gråskala och dunkla kanter extraherade

bild = cv2.imread ('box.jpg') grå = cv2.cvtColor (bild, cv2.COLOR_BGR2GRAY) kanter = cv2.Canny (grå, 50,150, apertureSize = 3) # igen använder vi samma rho och theta noggrannhet # dock, vi anger en minsta röst (poäng längs linjen) på 100 # och min linjelängd på 5 pixlar och max gap mellan raderna på 10 pixlar linjer = cv2.HoughLinesP (kanter, 1, np.pi / 180,100,100,10) för i i intervall (0, len (rader)): för x1, y1, x2, y2 i rader: cv2.line (bild, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistic hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Blobdetektering

Blobs kan beskrivas som en grupp anslutna pixlar som alla delar en gemensam egendom. Metoden för att använda OpenCV-blobdetektor beskrivs genom detta flödesschema.

För att rita nyckelpunkterna använder vi cv2.drawKeypoints som tar följande argument.

cv2.drawKeypoints (inmatningsbild, knappsatser, blank_utmatningsarray, färg, flaggor)

var i flaggorna kunde vara

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

och tomt här är i princip ingenting annat än en efter en matris av nollor

Låt oss nu utföra upptäckten av klumpar på en bild av solrosor, där klumparna skulle vara de centrala delarna av blomman, eftersom de är vanliga bland alla blommor.

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

Ställ in detektor med standardparametrar

detektor = cv2.SimpleBlobDetector_create ()

Upptäck klumpar

tangentpunkter = detektor.detekt (bild)

Rita upptäckta klumpar som röda cirklar

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS säkerställ att #storleken på cirkeln motsvarar storleken på blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (bild, tangentpunkter, blank, (0,255,255), cv2.DRAW_AT)

Visa knappar

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

Även om koden fungerar bra men några av klumparna saknas på grund av ojämna blommor, eftersom blommorna framåt är stora jämfört med blommorna i slutet.

9. Filtrering av klumpar - Räknar cirklar och ellipsar

Vi kan använda parametrar för att filtrera klumparna efter form, storlek och färg. För att använda parametrar med blobdetektor använder vi OpenCV: s funktion

cv2.SimpleBlobDetector_Params ()

Vi kommer att se filtreringen av blobbarna med huvudsakligen dessa fyra parametrar som anges nedan:

Område

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

Cirkularitet

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

Konvexitet - Areal för blob / area av konvex skrov

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

Tröghet

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

Låt oss nu försöka filtrera blobs efter ovan nämnda parametrar

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

Initiera detektorn med standardparametrar

detektor = cv2.SimpleBlobDetector_create ()

Upptäck klumpar

tangentpunkter = detektor.detekt (bild)

Rita blobbar på vår bild som röda cirklar

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 antal blobbar" + str (len (tangentpunkter)) cv2.putText (blobs, text, (20550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Visa bild med blob-knappar

cv2.imshow ('blob använder standardparametrar', blobs) cv2.waitKey (0)

Ställ in våra filtreringsparametrar

#initialize parameterinställning med cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Ställ in parametrar för områdesfiltrering

params.filterByArea = Sann params.minArea = 100

Ställ in parametrar för filtrering av cirkularitet

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

Ställ in parametern för konvexitetsfiltrering

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

Ställ in tröghetsfiltreringsparameter

params.filterByInertia = Sann params.minInertiaRatio = 0,01

Skapa detektor med parameter

detektor = cv2.SimpleBlobDetector_create (params)

Upptäck klumpar

tangentpunkter = detektor.detekt (bild)

Rita blobbar på bilderna som röda cirklar

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (bild, tangentpunkter, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "totalt antal cirkulära blobbar" + str (len (tangentpunkter)) cv2.putText (blobs, text, (20550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Visa klumpar

cv2.imshow ('filtrering av cirkulära blobbar', blobbar) cv2.waitKey (0) cv2.destroyAllWindows ()

Så detta är hur bildsegmentering kan göras i Python-OpenCV. För att få en bra underdrift av datorns syn och OpenCV, gå igenom tidigare artiklar (Komma igång med Python OpenCV och Image Manipulations i Python OpenCV och du kommer att kunna göra något coolt med Computer Vision.