Segmentace obrazu pomocí opencv

V předchozích výukových programech jsme pro základní zpracování obrázků použili OpenCV a provedli jsme některé operace pro úpravy obrázků předem. Jak víme, OpenCV je Open Source Commuter Vision Library, která má rozhraní C ++, Python a Java a podporuje Windows, Linux, Mac OS, iOS a Android. Lze jej tedy snadno nainstalovat na Raspberry Pi s prostředím Python a Linux. A Raspberry Pi s OpenCV a připojenou kamerou lze použít k vytvoření mnoha aplikací pro zpracování obrazu v reálném čase, jako je detekce obličeje, zámek obličeje, sledování objektu, detekce poznávací značky automobilu, domácí bezpečnostní systém atd. V tomto tutoriálu se naučíme, jak to udělat segmentace obrazu pomocí OpenCV. Níže uvádíme operace, které provedeme:

• Segmentace a obrysy
• Hierarchie a režim načítání
• Přibližování kontur a hledání jejich konvexního trupu
• Conex Hull
• Odpovídající obrys
• Identifikace tvarů (kruh, obdélník, trojúhelník, čtverec, hvězda)
• Detekce linky
• Detekce blobů
• Filtrování blobů - počítání kruhů a elips

1. Segmentace a obrysy

Segmentace obrazu je proces, kterým rozdělujeme obrázky do různých oblastí. Zatímco kontury jsou spojité čáry nebo křivky, které ohraničují nebo pokrývají celou hranici objektu v obraze. A zde použijeme techniku ​​segmentace obrazu zvanou obrysy k extrahování částí obrazu.

Také obrysy jsou velmi důležité v

• Detekce objektů
• Analýza tvaru

A mají velmi široké pole použití od analýzy obrazu v reálném světě po analýzu lékařského obrazu, jako například v MRI

Pojďme vědět, jak implementovat obrysy v opencv, extrahováním obrysů čtverců.

import CV2 import numpy jako np

Načtěte jednoduchý obrázek se 3 černými čtverci

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

Stupně šedi

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

Najděte hrany

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

Hledání obrysů

# použijte kopii vašeho obrázku, např. - edged.copy (), protože hledání obrysů změní obrázek # musíme přidat _, před obrysy jako prázdný argument kvůli aktualizaci verze OpenCV _, obrysy, hierarchie = cv2.findContours (hrany, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('hrany po konturování', hrany) cv2.waitKey (0)

Tisk souboru obrysu, abyste věděli, z čeho se skládají obrysy

print (contours) print ('Počet nalezených obrysů =' + str (len (obrysy))))

Nakreslete všechny kontury

#use -1 jako třetí parametr k vykreslení všech kontur cv2. drawContours (obrázek, kontury, -1, (0,255,0), 3) cv2.imshow ('kontury', obrázek) cv2.waitKey (0) cv2. destruAllWindows ()

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

], …,

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

Počet nalezených obrysů = 3. Našli jsme tedy celkem tři kontury.

Nyní ve výše uvedeném kódu, který jsme také vytiskli pomocí souboru obrysu , tento soubor říká, jak tyto obrysy vypadají, jak je vytištěno ve výstupu konzoly výše.

Ve výše uvedeném výstupu konzoly máme matici, která vypadá jako souřadnice bodů x, y. OpenCV ukládá kontury do seznamů seznamů. Výše uvedený výstup konzoly můžeme jednoduše zobrazit takto:

OBRYS 1 OBRYS 2 OBRYS 3

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

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

Nyní, když používáme funkci délky v souboru obrysu, dostaneme délku rovnou 3, to znamená, že v tomto souboru byly tři seznamy seznamů, tj. Tři obrysy.

Představte si, že CONTOUR 1 je prvním prvkem v tomto poli a tento seznam obsahuje seznam všech souřadnic a tyto souřadnice jsou body podél obrysů, které jsme právě viděli, jako zelené obdélníkové rámečky.

Existují různé metody pro ukládání těchto souřadnic a tyto se nazývají aproximační metody, v zásadě jsou aproximační metody dvou typů

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE ukládá všechny hraniční body, ale nemusíme nutně potřebovat všechny hraniční body, pokud bod tvoří přímku, potřebujeme pouze počáteční bod a koncový bod na této přímce.

cv2.CHAIN_APPROX_SIMPLE místo toho poskytuje pouze počáteční a koncový bod ohraničujících obrysů, výsledkem je mnohem efektivnější ukládání informací o kontuře.

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

Ve výše uvedeném kódu je cv2.RETR_EXTERNAL režim načítání, zatímco cv2.CHAIN_APPROX_NONE je

metoda aproximace.

Takže jsme se dozvěděli o konturách a metodě aproximace, pojďme prozkoumat hierarchii a režim načítání.

2. Hierarchie a režim načítání

Režim načítání definuje hierarchii v konturách, jako jsou kontury, vnější kontury nebo všechny kontury.

Nyní existují čtyři režimy načítání seřazené podle typů hierarchie.

cv2.RETR_LIST - načte všechny obrysy.

cv2.RETR_EXTERNAL - načte pouze vnější nebo vnější obrysy.

cv2.RETR_CCOMP - načte vše ve dvouúrovňové hierarchii.

cv2.RETR_TREE - načte vše v úplné hierarchii.

Hierarchie je uložena v následujícím formátu

Nyní pojďme ilustrovat rozdíl mezi prvními dvěma režimy načítání, cv2.RETR_LIST a cv2.RETR_EXTERNAL.

import CV2 import numpy jako np

Načtěte jednoduchý obrázek se 3 černými čtverci

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

Stupně šedi

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

Najděte Canny Edges

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

Hledání kontur

# použijte kopii vašeho obrázku, např. - edged.copy (), protože hledání obrysů změní obrázek # musíme přidat _, před obrysy jako prázdný argument kvůli upgradu otevřené verze cv _, obrysy, hierarchie = cv2.findContours (hrany, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('hrany po konturování', hrany) cv2.waitKey (0)

Tisk souboru obrysu, abyste věděli, z čeho se skládají obrysy.

print (contours) print ('Počet nalezených obrysů =' + str (len (obrysy))))

Nakreslete všechny kontury

#use -1 jako 3. parametr pro vykreslení všech kontur cv2. drawContours (obrázek, kontury, -1, (0,255,0), 3) cv2.imshow ('kontury', obrázek) cv2.waitKey (0) cv2. zničit všechna okna

import CV2 import numpy jako np

Načtěte jednoduchý obrázek se 3 černými čtverci

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

Stupně šedi

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

Najděte hrany

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

Hledání obrysů

# použijte kopii vašeho obrázku, např. - edged.copy (), protože hledání obrysů změní obrázek # musíme přidat _, před obrysy jako prázdný argument kvůli upgradu otevřené verze cv _, obrysy, hierarchie = cv2.findContours (edged, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow (' canny edge after contouring', edged) cv2.waitKey (0)

Tisk souboru obrysu, abyste věděli, z čeho se skládají obrysy.

print (contours) print ('Počet nalezených obrysů =' + str (len (obrysy))))

Nakreslete všechny kontury

#use -1 jako třetí parametr k vykreslení všech kontur cv2. drawContours (obrázek, kontury, -1, (0,255,0), 3) cv2.imshow ('kontury', obrázek) cv2.waitKey (0) cv2. destruAllWindows ()

Takže prostřednictvím ukázky výše uvedených kódů jsme mohli jasně vidět rozdíl mezi cv2.RETR_LIST a cv2.RETR_EXTERNNAL , v cv2.RETR_EXTERNNAL jsou brány v úvahu pouze vnější kontury, zatímco vnitřní kontury jsou ignorovány.

Zatímco v cv2.RETR_LIST jsou zohledňovány také vnitřní obrysy.

3. Přibližování kontur a hledání jejich konvexního trupu

Při přibližování obrysů je tvar obrysu aproximován přes jiný tvar obrysu, který se nemusí příliš podobat prvnímu obrysu.

Pro přiblížení používáme approxPolyDP funkci OpenCV, jež jsou popsány níže

cv2. okoloxPolyDP (obrys, přesnost přiblížení, uzavřený)

Parametry:

• Obrys - je individuální obrys, který chceme přiblížit.
• Přesnost aproximace - důležitý parametr při určování přesnosti aproximace, malá hodnota poskytuje přesnou aproximaci, velká hodnota poskytuje obecnější informace. Dobré pravidlo palce je menší než 5% obvodu obrysu.
• Uzavřeno - logická hodnota, která určuje, zda může být přibližný obrys otevřený nebo uzavřený.

Pokusme se přiblížit jednoduchou postavu domu

import numpy jako np import cv2

Vložte obrázek a uchovejte kopii

image = cv2.imread ('house.jpg') orig_image = image.copy () cv2.imshow ('původní obrázek', orig_image) cv2.waitKey (0)

Stupně šedi a binarizace obrazu

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

Najděte obrysy

_, kontury, hierarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Procházejte každý obrys a spočítejte jejich hraniční obdélník

pro c v obrysech: 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)

Procházejte každý obrys a vypočítejte přibližně obrys

pro c v obrysech:

# přesnost výpočtu jako procento přesnosti perimetru obrysu = 0,03 * cv2.arcLength (c, True) cca = cv2.aptxPolyDP (c, přesnost, True) cv2.drawContours (obrázek`` 0, (0,255,0), 2) cv2.imshow ('Přibližně polyDP', obrázek) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Konvexní trup

Konvexní trup je v podstatě vnější hrana, představovaná nakreslením čar nad daným obrázkem.

Může to být nejmenší polygon, který se vejde kolem samotného objektu.

import cv2 import numpy jako np obrázek = cv2.imread ('star.jpg') šedá = cv2.cvtColor (obrázek, cv2.COLOR_BGR2GRAY) cv2.imshow ('původní obrázek', obrázek) cv2.waitKey (0)

Prah obrazu

ret, thresh = cv2.threshold (šedá, 176 255,0)

Najděte obrysy

_, kontury, hierarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Třídit obrysy podle oblasti a poté odstranit největší obrys rámečku

n = len (kontury) -1 kontury = seřazené (kontury, klíč = cv2.contourArea, reverzní = False)

Iterujte obrysy a nakreslete konvexní trup

pro c v obrysech:

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

5. Přizpůsobení obrysu podle tvarů

cv2.matchShapes (konturová šablona, ​​konturová metoda, parametr metody)

Výstup - hodnota shody (nižší hodnota znamená bližší shodu)

obrysová šablona - Toto je náš referenční obrys, který se snažíme najít na novém obrázku.

kontura - individuální kontura, proti které se kontrolujeme.

Metoda - Typ přizpůsobení kontury (1,2,3).

parametr metody - ponechte samotnou jako 0,0 (nepoužívá se v pythonu opencv)

import CV2 import numpy jako np

Načtěte šablonu tvaru nebo referenční obrázek

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

Načtěte cílový obrázek s tvary, které se snažíme spojit

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

Před použitím cv2.findContours nejprve oba obrázky upravte

ret, thresh1 = cv2.threshold (šablona, ​​127 255,0) ret, thresh2 = cv2.threshold (šedá, 127 255,0)

Najděte obrysy v šabloně

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # musíme obrysy seřadit podle oblasti, abychom mohli odstranit největší obrys, který je

Obrys obrázku

tříděné_obrysy = seřazené (obrysy, klíč = cv2.contourArea, reverzní = True) # extrahujeme druhý největší obrys, který bude naší šablonou obrys tempelate_contour = obrysy # extrahujte obrysy z druhého cílového obrázku _, obrysy, hierarchie = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) pro c in contours: #iterate through each contour in the target image and use cv2.matchShape to compare the contour shape match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("shoda") #if hodnota shody je menší než 0,15, pokud shoda <0,16: nejbližší_konto = c else: nejbližší_konto = cv2.drawContours (cíl,, - 1, (0,255,0), 3) cv2.imshow ('výstup',cílová) cv2.waitKey (0) cv2.destroyAllWindows ()

Výstup konzoly -

0,16818605122199104

0,19946910256158912

0,18949760627309664

0,11101058276281539

Existují tři různé metody s různými matematickými funkcemi, s každou metodou můžeme experimentovat pouhým nahrazením hodnot metody cv2.matchShapes (tempelate_contour, c, 1, 0,0), které se liší od 1,2 a 3, za každou hodnotu získáte jinou shodu hodnoty ve výstupu konzoly.

6. Identifikace tvarů (kruh, obdélník, trojúhelník, čtverec, hvězda)

OpenCV lze také použít k automatické detekci různých typů tvarů z obrázku. Pomocí níže uvedeného kódu budeme schopni detekovat kruh, obdélník, trojúhelník, čtverec a hvězdy z obrázku.

import CV2 import numpy jako np

Načtěte a poté obrázky v šedé stupnici

image = cv2.imread ('tvary.jpg') šedá = cv2.cvtColor (obrázek, cv2.COLOR_BGR2GRAY) cv2.imshow ('identifikace tvarů', obrázek) cv2.waitKey (0) ret, thresh = cv2.threshold (šedá, 127 255,1)

Extrahujte obrysy

_, kontury, hierarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Pro cnt v obrysech:

Získejte přibližné polygony cca = cv2.aboutPolyDP (cnt, 0,01 * cv2.arcLength (cnt, True), True) pokud len (přibližně) == 3: shape_name = "Triangle" cv2.drawContours (obrázek,, 0, (0,255, 0), - 1)

vyhledejte obrysový střed a umístěte text do středu

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázek, název_tvaru, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (přibližně) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Zkontrolujte, zda je čtyřstranný mnohoúhelník čtvercový nebo obdélníkový

# cv2.boundingRect vrací levou šířku a výšku v pixelech, počínaje od horního # levého rohu, pro čtverec by to bylo zhruba stejné, kdyby abs (wh) <= 3: shape_name = "square" #find obrysový střed, kam umístit text na centrum cv2.drawContours (obrázek,, 0, (0,125,255), - 1) cv2.putText (obrázek, název_formátu, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" #find obrysový střed pro umístění textu do středu cv2.drawContours (obrázek,, 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 (přibližně) == 10: shape_name = 'hvězda' cv2.drawContours (obrázek,, 0, (255 255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázek, název_tvaru, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (přibližně)> = 15: shape_name = 'circle' cv2.drawContours (obrázek`` 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (obrázek, název_formátu, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identifikace tvarů', obrázek) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Detekce linky

Detekce linek je v OpenCV velmi důležitým konceptem a má slibné použití v reálném světě. Autonomní auta používají k detekci jízdních pruhů a silnic algoritmy detekce linek.

Při detekci linek se budeme zabývat dvěma algoritmy,

• Algoritmus Hough Line
• Probalistický algoritmus Hough Line.

Možná jste si pamatovali reprezentaci přímky ze středoškolské matematiky pomocí rovnice, y = mx + c.

V OpenCV je však linka reprezentována jiným způsobem

Rovnice nad ρ = xcosӨ + ysincosӨ je OpenCV reprezentace přímky, kde ρ je kolmá vzdálenost přímky od počátku a Ө je úhel tvořený normálou této přímky k počátku (měřeno v radiánech, kde 1pi radiány / 180 = 1 stupeň).

Funkce OpenCV pro detekci linky je uvedena jako

cv2.HoughLines (binarizovaný obrázek, ρ přesnost, Ө přesnost, prahová hodnota), přičemž prahová hodnota je minimální hlasování, aby mohla být považována za řádek.

Nyní pojďme detekovat čáry pro obraz pole pomocí funkce Hough line v opencv.

import CV2 import numpy jako np obraz = cv2.imread ('box.jpg')

Vytaženy okraje ve stupních šedi a okraje

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

Spouštějte Houghovy čáry s přesností rho 1 pixel

#theta přesnost (np.pi / 180), což je 1 stupeň # prahová hodnota řádku je nastavena na 240 (počet bodů na řádku) lines = cv2.HoughLines (edge, 1, np.pi / 180, 240) #we iterate přes každý řádek a převést do formátu # požadováno cv2.lines (tj. vyžadující koncové body) pro i v rozsahu (0, len (řádky)): pro rho, theta v řádcích: 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ázek, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough lines', obrázek) cv2.waitKey (0) cv2.destroyAllWindows ()

Nyní zopakujme detekci výše uvedeného řádku s dalším algoritmem pravděpodobnostní Houghovy linie.

Myšlenkou pravděpodobnostní Houghovy linie je vzít náhodnou podmnožinu bodů dostatečných pro detekci čáry.

Funkce OpenCV pro pravděpodobnostní linii Hough je reprezentována jako cv2.HoughLinesP (binarizovaný obraz, přesnost ρ, přesnost threshold, prahová hodnota, minimální délka linky, maximální mezera linky)

Nyní pojďme detekovat řádky pole pomocí pravděpodobnostních Houghových čar.

import CV2 import numpy jako np

Stupně šedi a ostré hrany Extrahováno

image = cv2.imread ('box.jpg') grey = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) edge = cv2.Canny (grey, 50,150, apertureSize = 3) # opět používáme stejnou přesnost rho a theta # jakkoli, zadáme minimální hlasování (body podél čáry) 100 # a minimální délka řádku 5 pixelů a maximální mezera mezi řádky 10 pixelů řádky = cv2.HoughLinesP (hrany, 1, np.pi / 180,100,100,10) pro i v rozsahu (0, len (řádky)): pro x1, y1, x2, y2 v řádcích: cv2.line (obrázek, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('probalistické hrubé čáry', obrázek) cv2.waitKey (0) cv2.destroyAllWindows

8. Detekce blobů

Bloby lze popsat jako skupinu připojených pixelů, které všechny sdílejí společnou vlastnost. Metoda použití detektoru blob OpenCV je popsána v tomto vývojovém diagramu.

Pro kreslení klíčových bodů používáme cv2.drawKeypoints, který přebírá následující argumenty.

cv2.drawKeypoints (vstupní obrázek, klíčové body, blank_output_array, barva, příznaky)

kde by mohly být vlajky

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ázdné zde není skoro nic jiného než matice nul po jedné

Nyní provedeme detekci blob na snímku slunečnic, kde by bloby byly centrální částí květu, protože jsou běžné u všech květů.

import CV2 import numpy jako np obraz = cv2.imread ('Sunflowers.jpg' cv2.IMREAD_GRAYSCALE)

Nastavte detektor s výchozími parametry

detektor = cv2.SimpleBlobDetector_create ()

Zjistěte objekty BLOB

keypoints = detector.detect (obrázek)

Nakreslete zjištěné objekty BLOB jako červené kruhy

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS zajistěte, aby velikost # kruhu odpovídala velikosti blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,255), cv2.DRAW_MATCH__ATM

Zobrazit klíčové body

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

I když kód funguje dobře, ale některé kuličky chybí kvůli nerovnoměrné velikosti květů, protože květiny v přední části jsou velké ve srovnání s květinami na konci.

9. Filtrování blobů - počítání kruhů a elips

Můžeme použít parametry pro filtrování objektů BLOB podle jejich tvaru, velikosti a barvy. Pro použití parametrů s detektorem blob používáme funkci OpenCV

cv2.SimpleBlobDetector_Params ()

Uvidíme filtrování objektů blob hlavně podle těchto čtyř parametrů uvedených níže:

Plocha

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

Kruhovitost

params.filterByCircularity = True / False params.minCircularity = 1 je perfektní, 0 je naproti

Konvexita - oblast blob / oblast konvexního trupu

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

Setrvačnost

params.filterByInertia = True / False params.minInertiaRatio = 0,01

Nyní zkusme filtrovat objekty BLOB podle výše uvedených parametrů

import cv2 import numpy jako np image = cv2.imread ('blobs.jpg') cv2.imshow ('původní obrázek', obrázek) cv2.waitKey (0)

Inicializujte detektor pomocí výchozích parametrů

detektor = cv2.SimpleBlobDetector_create ()

Zjistěte objekty BLOB

keypoints = detector.detect (obrázek)

Nakreslete kuličky na náš obrázek jako č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 blobů" + str (len (klíčové body)) cv2.putText (objekty BLOB, text, (20 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0255), 2)

Zobrazit obrázek s klíčovými body blob

cv2.imshow ('blob using default parameters', blobs) cv2.waitKey (0)

Nastavte naše parametry filtrování

#initialize nastavení parametrů pomocí parametrů cv2.SimpleBlobDetector = cv2.SimpleBlobDetector_Params ()

Nastavte parametry filtrování oblasti

params.filterByArea = Pravda params.minArea = 100

Nastavte parametry filtrování kruhovitosti

params.filterByCircularity = Pravé parametry. minCircularity = 0,9

Nastavte parametr filtrování konvexity

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

Nastavte parametr filtrování setrvačnosti

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

Vytvořte detektor s parametrem

detector = cv2.SimpleBlobDetector_create (parametry)

Zjistěte objekty BLOB

keypoints = detector.detect (obrázek)

Nakreslete na obrázky kuličky jako červené kruhy

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (obrázek, klíčové body, prázdné, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (klíčové body) text = "celkový počet kruhových blobů" + str (len (klíčové body)) cv2.putText (objekty BLOB, text, (20 550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Zobrazit objekty BLOB

cv2.imshow ('filtrování kruhových objektů BLOB', objektů BLOB ) cv2.waitKey (0) cv2.destroyAllWindows ()

Takto lze segmentaci obrazu provést v Pythonu-OpenCV. Chcete-li dobře porozumět počítačovému vidění a OpenCV, projděte si předchozí články (Začínáme s Pythonem OpenCV a manipulací s obrázky v Pythonu OpenCV a pomocí počítačového vidění si budete moci vytvořit něco skvělého.