Segmentácia obrazu pomocou opencv

V predchádzajúcich tutoriáloch sme použili OpenCV na základné spracovanie obrazu a vykonali sme niekoľko pokročilých úprav obrazu. Ako vieme, OpenCV je Open Source Commuter Vision Library, ktorá má rozhranie C ++, Python a Java a podporuje Windows, Linux, Mac OS, iOS a Android. Dá sa teda ľahko nainštalovať na Raspberry Pi s prostredím Python a Linux. A Raspberry Pi s OpenCV a pripojenou kamerou možno použiť na vytvorenie mnohých aplikácií na spracovanie obrazu v reálnom čase, ako je detekcia tváre, zámok tváre, sledovanie objektov, detekcia ŠPZ automobilov, domáci bezpečnostný systém atď. V tomto výučbe sa naučíme, ako to segmentácia obrazu pomocou OpenCV. Operácie, ktoré vykonáme, sú uvedené nižšie:

• Segmentácia a obrysy
• Hierarchia a režim vyhľadávania
• Približovanie kontúr a nájdenie ich konvexného trupu
• Conex Hull
• Zodpovedajúca kontúra
• Identifikačné tvary (kruh, obdĺžnik, trojuholník, štvorec, hviezda)
• Detekcia linky
• Detekcia blobov
• Filtrovanie guľôčok - počítanie kruhov a elips

1. Segmentácia a obrysy

Segmentácia obrázkov je proces, pomocou ktorého rozdeľujeme obrázky do rôznych oblastí. Zatiaľ čo kontúry sú súvislé čiary alebo krivky, ktoré ohraničujú alebo pokrývajú celú hranicu objektu v obraze. Na extrakciu častí obrázka použijeme techniku ​​segmentácie obrazu, ktorá sa nazýva kontúry.

Tiež kontúry sú veľmi dôležité v

• Detekcia objektu
• Analýza tvaru

A majú veľmi široké pole použitia od analýzy obrazu z reálneho sveta po analýzu medicínskeho obrazu, napríklad pri MRI

Poďme vedieť, ako implementovať obrysy v opencv, extrahovaním obrysov štvorcov.

import cv2 import numpy ako np

Načítajme jednoduchý obrázok s 3 čiernymi štvorcami

image = cv2.imread ('squares.jpg') cv2.imshow ('vstupný obrázok', obrázok) cv2.waitKey (0)

Odtiene sivej

šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY)

Nájdite ostré hrany

edged = cv2.Canny (šedá, 30 200) cv2.imshow ('hrany', hrany) cv2.waitKey (0)

Nájdenie kontúr

#použite kópiu vášho obrázka, napr. - edged.copy (), pretože nájdenie obrysov zmení obrázok # musíme pridať _, pred obrysy ako prázdny argument kvôli aktualizácii verzie OpenCV _, obrysy, hierarchia = cv2.findContours (hranami, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('hrany po kontúrovaní', hranami) cv2.waitKey (0)

Vytlačením súboru obrysov zistíte, z čoho sa skladá

print (contours) print ('Počet nájdených obrysov =' + str (len (obrysy))))

Nakreslite všetky kontúry

#use -1 ako tretí parameter na vykreslenie všetkých obrysov cv2.drawContours (obrázok, obrysy, -1, (0,255,0), 3) cv2.imshow ('obrysy', obrázok) cv2.waitKey (0) cv2. destruAllWindows ()

Výstup konzoly -],],], …,],],]], dtype = int32), pole (],],

], …,

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

Počet nájdených obrysov = 3. Našli sme teda celkovo tri kontúry.

Teraz vo vyššie uvedenom kóde, ktorý sme tiež vytlačili pomocou súboru obrysov , tento súbor hovorí, ako tieto obrysy vyzerajú, ako je vytlačené vo výstupe z konzoly.

Vo vyššie uvedenom výstupe z konzoly máme maticu, ktorá vyzerá ako súradnice bodov x, y. OpenCV ukladá kontúry do zoznamov zoznamov. Vyššie uvedený výstup na konzolu môžeme jednoducho zobraziť nasledovne:

OBRYS 1 OBRYS 2 OBRYS 3

], pole (], pole (],],],],],],],

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

Teraz, keď používame funkciu dĺžky na obrysovom súbore, dostaneme dĺžku rovnú 3, čo znamená, že v tomto súbore boli tri zoznamy zoznamov, tj. Tri obrysy.

Teraz si predstavte, že CONTOUR 1 je prvým prvkom v tomto poli a tento zoznam obsahuje zoznam všetkých súradníc a tieto súradnice sú bodmi pozdĺž obrysov, ktoré sme práve videli, ako zelené obdĺžnikové polia.

Existuje niekoľko metód na ukladanie týchto súradníc, ktoré sa nazývajú aproximačné metódy, v zásade sú aproximačné metódy dvoch typov

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE ukladá všetky hraničné body, ale nevyhnutne nepotrebujeme všetky hraničné body, ak bod tvorí priamku, potrebujeme iba začiatočný bod a konečný bod na tejto priamke.

cv2.CHAIN_APPROX_SIMPLE poskytuje iba začiatočný a konečný bod ohraničujúcich obrysov, výsledkom je oveľa efektívnejšie ukladanie informácií o kontúre.

_, contours, hierarchy = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

Vo vyššie uvedenom kóde je cv2.RETR_EXTERNAL režim načítania, zatiaľ čo cv2.CHAIN_APPROX_NONE je

metóda aproximácie.

Dozvedeli sme sa teda o kontúrach a metóde aproximácie, poďme teraz preskúmať režim hierarchie a načítania.

2. Režim hierarchie a načítania

Režim načítania definuje hierarchiu v kontúrach, ako sú kontúry, vonkajšie kontúry alebo všetky kontúry.

Teraz existujú štyri režimy vyhľadávania zoradené podľa typov hierarchie.

cv2.RETR_LIST - načíta všetky kontúry.

cv2.RETR_EXTERNAL - načíta iba vonkajšie alebo vonkajšie obrysy.

cv2.RETR_CCOMP - načíta všetko v dvojúrovňovej hierarchii.

cv2.RETR_TREE - načíta všetko v celej hierarchii.

Hierarchia je uložená v nasledujúcom formáte

Teraz si ukážeme rozdiel medzi prvými dvoma režimami načítania, cv2.RETR_LIST a cv2.RETR_EXTERNAL.

import cv2 import numpy ako np

Načítajme jednoduchý obrázok s 3 čiernymi štvorcami

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

Odtiene sivej

šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY)

Nájdite Canny Edges

edged = cv2.Canny (šedá, 30 200) cv2.imshow ('hrany', hrany) cv2.waitKey (0)

Hľadanie kontúr

#použite kópiu vášho obrázka, napr. - edged.copy (), pretože nájdenie kontúr zmení obrázok # musíme pridať _, pred kontúry ako prázdny argument kvôli aktualizácii otvorenej verzie cv _, kontúry, hierarchia = cv2.findContours (hrany, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('hrany po kontúrovaní', hrany) cv2.waitKey (0)

Vytlačením súboru obrysov zistíte, z čoho sa skladá.

print (contours) print ('Počet nájdených obrysov =' + str (len (obrysy))))

Nakreslite všetky kontúry

#use -1 ako tretí parameter na vykreslenie všetkých obrysov cv2.drawContours (obrázok, obrysy, -1, (0,255,0), 3) cv2.imshow ('obrysy', obrázok) cv2.waitKey (0) cv2. destruAllWindows

import cv2 import numpy ako np

Načítajme jednoduchý obrázok s 3 čiernymi štvorcami

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

Odtiene sivej

šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY)

Nájdite ostré hrany

edged = cv2.Canny (šedá, 30 200) cv2.imshow ('hrany', hrany) cv2.waitKey (0)

Nájdenie kontúr

#použite kópiu vášho obrázka, napr. - edged.copy (), pretože nájdenie kontúr zmení obrázok # musíme pridať _, pred kontúry ako prázdny argument kvôli aktualizácii otvorenej verzie cv _, kontúry, hierarchia = cv2.findContours (hranami, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('hrany po kontúrovaní', hranami) cv2.waitKey (0)

Vytlačením súboru obrysov zistíte, z čoho sa skladá.

print (contours) print ('Počet nájdených obrysov =' + str (len (obrysy))))

Nakreslite všetky kontúry

#use -1 ako tretí parameter na vykreslenie všetkých obrysov cv2.drawContours (obrázok, obrysy, -1, (0,255,0), 3) cv2.imshow ('obrysy', obrázok) cv2.waitKey (0) cv2. destruAllWindows ()

Takže prostredníctvom demonštrácie vyššie uvedených kódov sme mohli jasne vidieť rozdiel medzi cv2.RETR_LIST a cv2.RETR_EXTERNNAL , v cv2.RETR_EXTERNNAL sa zohľadňujú iba vonkajšie obrysy, zatiaľ čo vnútorné obrysy sú ignorované.

Zatiaľ čo v cv2.RETR_LIST sa zohľadňujú aj vnútorné obrysy.

3. Približovanie obrysov a hľadanie ich konvexného trupu

Pri približovaní obrysov sa tvar obrysu aproximuje iným tvarom obrysu, ktorý sa nemusí veľmi podobať prvému tvaru obrysu.

Pre priblíženie používame approxPolyDP funkciu OpenCV, ktoré sú popísané nižšie

cv2.aptxPolyDP (obrys, presnosť aproximácie, uzavretý)

Parametre:

• Obrys - je individuálny obrys, ktorý chceme priblížiť.
• Presnosť aproximácie - dôležitý parameter pri určovaní presnosti aproximácie, malá hodnota poskytuje presnú aproximáciu, veľká hodnota poskytuje všeobecnejšiu informáciu. Dobré pravidlo pre palec je menej ako 5% obvodu obrysu.
• Uzavreté - logická hodnota, ktorá určuje, či môže byť približný obrys otvorený alebo zatvorený.

Pokúsme sa priblížiť jednoduchú postavu domu

import numpy ako np import cv2

Vložte obrázok a uschovajte si kópiu

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('pôvodný obrázok', orig_image) cv2.waitKey (0)

Odtiene šedej a obrázok binarizujte

šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) ret, prah = cv2.threshold (šedá, 127 255, cv2.THRESH_BINARY_INV)

Nájdite kontúry

_, kontúry, hierarchia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Iterujte každý obrys a vypočítajte ich ohraničujúci obdĺžnik

pre c v kontúrach: 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)

Iterujte cez každý obrys a vypočítajte približne obrys

pre c v kontúrach:

#vypočítajte presnosť ako percento presnosti obvodu obrysu = 0,03 * cv2.arcLength (c, True) približne = cv2.aptxPolyDP (c, presnosť, True) cv2.drawContours (obrázok,, 0, (0,255,0), 2) cv2.imshow ('Približne polyDP', obrázok) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konvexný trup

Konvexný trup je v podstate vonkajší okraj, ktorý je znázornený nakreslením čiar nad daným obrázkom.

Môže to byť najmenší mnohouholník, ktorý sa zmestí okolo samotného objektu.

import cv2 import numpy ako np image = cv2.imread ('star.jpg') šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) cv2.imshow ('pôvodný obrázok', obrázok) cv2.waitKey (0)

Prah obrazu

ret, mlátiť = cv2.threshold (sivá, 176 255,0)

Nájdite kontúry

_, kontúry, hierarchia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Zoraďte obrysy podľa oblasti a potom odstráňte najväčší obrys rámu

n = len (obrysy) -1 obrysy = zoradené (obrysy, kľúč = cv2.contourArea, spät = False)

Iterujte cez obrysy a nakreslite konvexný trup

pre c v kontúrach:

hull = cv2.convexHull (c) cv2.drawContours (obrázok,, 0, (0,255,0), 2) cv2.imshow ('konvexný trup', obrázok) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Zhoda kontúry podľa tvarov

cv2.matchShapes (obrysová šablóna, obrysová metóda, parameter metódy)

Výstup - hodnota zhody (nižšia hodnota znamená užšiu zhodu)

obrysová šablóna - Toto je náš referenčný obrys, ktorý sa snažíme nájsť na novom obrázku.

kontúra - individuálna kontúra, proti ktorej kontrolujeme.

Metóda - Typ prispôsobenia obrysu (1,2,3).

parameter parameter - nechajte osamote 0,0 (nepoužíva sa v pythone opencv)

import cv2 import numpy ako np

Vložte šablónu tvaru alebo referenčný obrázok

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

Vložte cieľový obrázok do tvarov, ktoré sa snažíme zladiť

target = cv2.imread ('shapestomatch.jpg') šedá = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Pred použitím cv2.findContours prahovo obmedzte obidva obrázky

ret, thresh1 = cv2.threshold (šablóna, 127 255,0) ret, thresh2 = cv2.threshold (šedá, 127 255,0)

Nájdite kontúry v šablóne

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # musíme kontúry zoradiť podľa oblasti, aby sme mohli odstrániť najväčší obrys, ktorý je

Obrys obrázku

seřazené_obrysy = zoradené (obrysy, kľúč = cv2.contourArea, reverz = True) # extrahujeme druhý najväčší obrys, ktorý bude našou šablónou obrys tempelate_contour = obrysy # extrahujeme obrysy z druhého cieľového obrázka _, obrysy, hierarchia = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) pre c v obrysoch: # zopakujte každý obrys v cieľovom obrázku a pomocou cv2.matchShape porovnajte tvar obrysu = cv2.matchShapes (tempelate_contour, c, 1,0,0) tlačiť ("match") #if hodnota zhody je menšia ako 0,15, ak je zhoda <0,16: nearest_contour = c else: nearest_contour = cv2.drawContours (cieľ,, - 1, (0,255,0), 3) cv2.imshow ('output'), cieľ) cv2.waitKey (0) cv2.destroyAllWindows ()

Výstup na konzolu -

0,16818605122199104

0,19949910256158912

0,18949760627309664

0,11101058276281539

Existujú tri rôzne metódy s rôznymi matematickými funkciami, s každou metódou môžeme experimentovať tak, že nahradíme hodnoty metódy cv2.matchShapes (tempelate_contour, c, 1, 0,0), ktoré sa líšia od 1,2 do 3, za každú hodnotu získate inú zhodu hodnoty vo výstupe z konzoly.

6. Identifikácia tvarov (kruh, obdĺžnik, trojuholník, štvorec, hviezda)

OpenCV možno použiť aj na automatickú detekciu rôznych typov tvarov z obrázka. Použitím nižšie uvedeného kódu budeme môcť z obrázka zistiť kruh, obdĺžnik, trojuholník, štvorec a hviezdy.

import cv2 import numpy ako np

Načítajte a potom obrázky v škále šedej

image = cv2.imread ('tvary.jpg') šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) cv2.imshow ('identifikácia tvarov', obrázok) cv2.waitKey (0) ret, thresh = cv2.threshold (šedá, 127 255,1)

Extrahujte kontúry

_, kontúry, hierarchia = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Pre cnt v kontúrach:

Získajte približné mnohouholníky cca = cv2.aptxPolyDP (cnt, 0,01 * cv2.arcLength (cnt, True), True) ak len (cca) == 3: shape_name = "Triangle" cv2.drawContours (obrázok,, 0, (0,255, 0), - 1)

vyhľadajte obrysový stred a umiestnite text do stredu

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázok, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (približne) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Skontrolujte, či je štvorstranný polygón štvorcový alebo obdĺžnikový

# cv2.boundingRect vráti ľavú šírku a výšku v pixeloch, počínajúc od horného # ľavého rohu, pre štvorec by to bolo zhruba rovnaké, keby abs (wh) <= 3: shape_name = "štvorec" #find obrysový stred na umiestnenie textu na centrum cv2.drawContours (obrázok,, 0, (0,125 255), - 1) cv2.putText (obrázok, tvar_nazov, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" #find obrysový stred na umiestnenie textu do stredu cv2.drawContours (obrázok,, 0, (0,0255), - 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 (cca) == 10: shape_name = 'hviezda' cv2.drawContours (obrázok,, 0, (255 255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázok, tvar_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (približne)> = 15: shape_name = 'circle' cv2.drawContours (obrázok,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázok, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identifikácia tvarov', obrázok) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Detekcia linky

Detekcia liniek je v OpenCV veľmi dôležitým konceptom a má sľubné použitie v skutočnom svete. Autonómne vozidlá používajú na detekciu jazdných pruhov a ciest algoritmy detekcie čiary.

Pri detekcii liniek sa budeme zaoberať dvoma algoritmami,

• Algoritmus Hough Line
• Probalistický algoritmus Hough Line.

Možno ste si pamätali znázornenie priamky zo stredoškolskej matematiky pomocou rovnice, y = mx + c.

V OpenCV je však linka predstavovaná iným spôsobom

Rovnica nad ρ = xcosӨ + ysincosӨ je OpenCV reprezentácia priamky, kde ρ je kolmá vzdialenosť priamky od počiatku a Ө je uhol tvorený normálou tejto priamky k počiatku (merané v radiánoch, kde 1pi radiány / 180 = 1 stupeň).

Funkcia OpenCV na detekciu vedenia je uvedená ako

cv2.HoughLines (binarizovaný obraz, presnosť ρ, Ө presnosť, prahová hodnota), pričom prahová hodnota je minimálne hlasovanie, aby sa mohla považovať za riadok.

Teraz poďme detekovať čiary pre rámcový obraz pomocou funkcie Hough line z opencv.

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

Boli odstránené stupne šedej a ostré hrany

šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) hrany = cv2.Canny (šedá, 100 170, apertureSize = 3)

Spustite Houghove čiary s presnosťou rho na 1 pixel

#theta presnosť (np.pi / 180), čo je 1 stupeň, #line threshold is set to 240 (number of points on line) lines = cv2.HoughLines (edge, 1, np.pi / 180, 240) # we iterate cez každý riadok a previesť do formátu # vyžadovaného cv2.lines (tj vyžadujúce koncové body) pre i v rozsahu (0, len (riadky)): pre rho, theta v riadkoch: 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 (obrázok, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hrubé čiary'), obrázok) cv2.waitKey (0) cv2.destroyAllWindows ()

Teraz zopakujme detekciu vyššie uvedeného riadku s ďalším algoritmom pravdepodobnostnej Houghovej priamky.

Myšlienkou pravdepodobnej Houghovej čiary je zobrať náhodnú podmnožinu bodov dostatočných na detekciu čiary.

Funkcia OpenCV pre pravdepodobnostnú Houghovu čiaru je reprezentovaná ako cv2.HoughLinesP (binarizovaný obraz, presnosť ρ, Ө presnosť, prahová hodnota, minimálna dĺžka vedenia, maximálna medzera vedenia)

Teraz poďme zistiť čiary políčka pomocou pravdepodobnostných Houghových čiar.

import cv2 import numpy ako np

Odtiene sivej a hrany Extrahované

image = cv2.imread ('box.jpg') šedá = cv2.cvtColor (obrázok, cv2.COLOR_BGR2GRAY) edge = cv2.Canny (šedá, 50,150, apertureSize = 3) # znova použijeme rovnakú presnosť rho a theta #vždy však, zadáme minimálne hlasovanie (bodov pozdĺž čiary) 100 # a minimálna dĺžka riadku 5 pixelov a maximálna medzera medzi riadkami 10 pixelov riadky = cv2.HoughLinesP (hrany, 1, np.pi / 180,100,100,10) pre i v rozsahu (0, len (riadky)): pre x1, y1, x2, y2 v riadkoch: cv2.line (obrázok, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistické hrubé čiary', obrázok) cv2.waitKey (0) cv2.destroyAllWindows

8. Detekcia blobov

Bloby možno opísať ako skupinu spojených pixelov, ktoré všetky zdieľajú spoločnú vlastnosť. Metóda použitia detektora blob OpenCV je opísaná v tomto vývojovom diagrame.

Na vykreslenie kľúčových bodov použijeme cv2.drawKeypoints, ktorý obsahuje nasledujúce argumenty.

cv2.drawKeypoints (vstupný obrázok, kľúčové body, blank_output_array, farba, vlajky)

kde vo vlajkach by mohli byt

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

a prázdne tu nie je skoro nič iné ako matica núl jedna po druhej

Teraz vykonajme detekciu kvapiek na obrázku slnečnice, kde by kvapky boli centrálnou časťou kvetu, pretože sú bežné medzi všetkými kvetmi.

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

Nastavte detektor s predvolenými parametrami

detektor = cv2.SimpleBlobDetector_create ()

Zistiť kvapky

keypoints = detector.detect (obrázok)

Nakreslite zistené guľôčky ako červené kruhy

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS zabezpečte, aby veľkosť # kruhu zodpovedala veľkosti blobu blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,255), cv2.DRAW_MATCH__ATM

Zobraziť kľúčové body

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

Aj keď kód funguje dobre, niektoré guľôčky sa minuli kvôli nerovnomernej veľkosti kvetov, pretože kvety vpredu sú veľké v porovnaní s kvetmi na konci.

9. Filtrovanie blobov - počítanie kruhov a elips

Môžeme použiť parametre na filtrovanie guľôčok podľa ich tvaru, veľkosti a farby. Na použitie parametrov s blobovým detektorom používame funkciu OpenCV

cv2.SimpleBlobDetector_Params ()

Filtrovanie blobov uvidíme hlavne podľa týchto štyroch parametrov uvedených nižšie:

Oblasť

params.filterByArea = Pravda / Nepravda params.minArea = pixely params.maxArea = pixely

Obežnosť

params.filterByCircularity = True / False params.minCircularity = 1 je perfektný, 0 je oproti

Konvexita - oblasť blob / oblasť konvexného trupu

params.filterByConvexity = True / False params.minConvexity = oblasť

Zotrvačnosť

params.filterByInertia = Pravda / Nepravda params.minInertiaRatio = 0,01

Teraz sa pokúsme filtrovať objekty blob podľa vyššie uvedených parametrov

import cv2 import numpy ako np image = cv2.imread ('blobs.jpg') cv2.imshow ('pôvodný obrázok', obrázok) cv2.waitKey (0)

Inicializujte detektor pomocou predvolených parametrov

detektor = cv2.SimpleBlobDetector_create ()

Zistiť kvapky

keypoints = detector.detect (obrázok)

Nakreslite guľky na náš obrázok ako červené kruhy

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 = "celkový počet blobov" + str (len (kľúčové body)) cv2.putText (objekty BLOB, text, (20 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0255), 2)

Zobraziť obrázok s kľúčovými bodmi blob

cv2.imshow ('blob pomocou predvolených parametrov', blobs) cv2.waitKey (0)

Nastavte naše parametre filtrovania

#initialize nastavenie parametrov pomocou parametrov cv2.SimpleBlobDetector = cv2.SimpleBlobDetector_Params ()

Nastavte parametre filtrovania oblasti

params.filterByArea = Skutočné params.minArea = 100

Nastavte parametre filtrovania kruhovitosti

params.filterByCircularity = Skutočné parametres.minCircularity = 0,9

Nastavte parameter filtrovania konvexnosti

params.filterByConvexity = Falošné params.minConvexity = 0,2

Nastavte parameter filtrovania zotrvačnosti

params.filterByInertia = Skutočné parametres.minInertiaRatio = 0,01

Vytvorte detektor s parametrom

detektor = cv2.SimpleBlobDetector_create (parametre)

Zistiť kvapky

keypoints = detector.detect (obrázok)

Na obrázky nakreslite guľky ako červené kruhy

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (obrázok, kľúčové body, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (kľúčové body) text = "celkový počet kruhových blobov" + str (len (kľúčové body)) cv2.putText (objekty blob, text, (20 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Zobraziť kvapky

cv2.imshow ('filtrovanie kruhových blobov', blobov ) cv2.waitKey (0) cv2.destroyAllWindows ()

Takto je možné vykonať segmentáciu obrázkov v prostredí Python-OpenCV. Ak chcete dobre porozumieť počítačovému videniu a OpenCV, prečítajte si predchádzajúce články (Začíname s Python OpenCV a manipuláciou s obrázkami v Python OpenCV a pomocou počítačového videnia budete môcť vytvoriť niečo zaujímavé.