Segmentarea imaginii folosind opencv

În tutorialele anterioare, am folosit OpenCV pentru prelucrarea de bază a imaginilor și am făcut câteva operații de editare a imaginilor în avans. După cum știm, OpenCV este Open Source Commuter Vision Library care are interfețe C ++, Python și Java și acceptă Windows, Linux, Mac OS, iOS și Android. Deci, poate fi instalat cu ușurință în Raspberry Pi cu mediul Python și Linux. Și Raspberry Pi cu OpenCV și camera atașată poate fi folosit pentru a crea multe aplicații de procesare a imaginilor în timp real, cum ar fi detectarea feței, blocarea feței, urmărirea obiectelor, detectarea plăcilor de înmatriculare a mașinii, sistemul de securitate la domiciliu etc. În acest tutorial vom afla cum să procedăm segmentarea imaginii folosind OpenCV. Operațiunile pe care le vom efectua sunt enumerate mai jos:

• Segmentare și contururi
• Ierarhia și modul de recuperare
• Aproximarea contururilor și găsirea corpului lor convex
• Conex Hull
• Contur de potrivire
• Identificarea formelor (cerc, dreptunghi, triunghi, pătrat, stea)
• Detectarea liniei
• Detectare blob
• Filtrarea bloburilor - numărarea cercurilor și elipselor

1. Segmentare și contururi

Segmentarea imaginilor este un proces prin care partiționăm imaginile în diferite regiuni. În timp ce contururile sunt liniile sau curbele continue care leagă sau acoperă delimitarea completă a unui obiect dintr-o imagine. Și aici vom folosi tehnica de segmentare a imaginii numită contururi pentru a extrage părțile unei imagini.

De asemenea, contururile sunt foarte importante în

• Detectarea obiectelor
• Analiza formei

Și au un domeniu de aplicare foarte larg, de la analiza imaginii din lumea reală la analiza imaginii medicale, cum ar fi în RMN

Să știm cum să implementăm contururi în opencv, prin extragerea contururilor de pătrate.

import cv2 import numpy ca np

Să încărcăm o imagine simplă cu 3 pătrate negre

image = cv2.imread ('pătrate.jpg') cv2.imshow ('imagine de intrare', imagine) cv2.waitKey (0)

Scara tonurilor de gri

gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY)

Găsiți margini canguroase

edged = cv2.Canny (gri, 30.200) cv2.imshow („margini canny”, margine) cv2.waitKey (0)

Găsirea contururilor

#utilizați o copie a imaginii dvs., de exemplu - edged.copy (), deoarece găsirea contururilor modifică imaginea # trebuie să adăugăm _, înainte de contururi ca argument gol din cauza actualizării versiunii OpenCV _, contururi, ierarhie = cv2.findContours (tivit, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow („margini cutate după conturare”, tivit) cv2.waitKey (0)

Tipărirea fișierului contur pentru a ști din ce cuprinde contururile

print (contururi) print ('Numărul de contururi găsite =' + str (len (contururi)))

Desenați toate contururile

#utilizați -1 ca al treilea parametru pentru a desena toate contururile cv2.drawContours (imagine, contururi, -1, (0,255,0), 3) cv2.imshow („contururi”, imagine) cv2.waitKey (0) cv2. destroyAllWindows ()

Ieșire consolă -],],], …,],],]], dtype = int32), matrice (],],

], …,

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

Numărul de contururi găsite = 3. Deci, am găsit un total de trei contururi.

Acum, în codul de mai sus am tipărit, de asemenea, fișierul contur folosind , acest fișier spune modul în care aceste contururi arata ca, așa cum tipărite în consola de mai sus.

În ieșirea consolei de mai sus avem o matrice care arată ca coordonatele punctelor x, y. OpenCV stochează contururile într-o listă de liste. Putem pur și simplu să afișăm ieșirea consolei de mai sus după cum urmează:

CONTOUR 1 CONTOUR 2 CONTOUR 3

], matrice (], matrice (],],],],],],],

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

Acum, pe măsură ce folosim funcția de lungime pe fișierul de contur, obținem lungimea egală cu 3, înseamnă că erau trei liste de liste în acel fișier, adică trei contururi.

Acum, imaginați-vă CONTOURUL 1 este primul element din acea matrice și acea listă conține lista tuturor coordonatelor și aceste coordonate sunt punctele de-a lungul contururilor pe care tocmai le-am văzut, ca casetele dreptunghiulare verzi.

Există diferite metode de stocare a acestor coordonate și acestea se numesc metode de aproximare, practic metodele de aproximare sunt de două tipuri

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE stochează tot punctul limită, dar nu avem neapărat nevoie de toate punctele limită, dacă punctul formează o linie dreaptă, avem nevoie doar de punctul de început și punctul de finalizare pe acea linie.

cv2.CHAIN_APPROX_SIMPLE oferă în schimb doar punctele de început și de sfârșit ale contururilor de delimitare, rezultatul este stocarea mult mai eficientă a informațiilor de contur.

_, contururi, ierarhie = cv2.findContours (tivit, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

În codul de mai sus cv2.RETR_EXTERNAL este modul de recuperare în timp ce cv2.CHAIN_APPROX_NONE este

metoda de aproximare.

Deci, am învățat despre contururi și metoda de aproximare, acum să explorăm ierarhia și modul de recuperare.

2. Ierarhia și modul de recuperare

Modul de recuperare definește ierarhia în contururi, cum ar fi contururile secundare, sau conturul extern sau toate contururile.

Acum există patru moduri de regăsire sortate pe tipurile de ierarhie.

cv2.RETR_LIST - recuperează toate contururile.

cv2.RETR_EXTERNAL - recuperează numai contururile externe sau exterioare.

cv2.RETR_CCOMP - recuperează toate într-o ierarhie pe 2 niveluri.

cv2.RETR_TREE - recuperează toate într-o ierarhie completă.

Ierarhia este stocată în următorul format

Acum să ilustrăm diferența dintre primele două moduri de recuperare, cv2.RETR_LIST și cv2.RETR_EXTERNAL.

import cv2 import numpy ca np

Permite încărcarea unei imagini simple cu 3 pătrate negre

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

Scara tonurilor de gri

gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY)

Găsește Canny Edges

edged = cv2.Canny (gri, 30.200) cv2.imshow („margini canny”, margine) cv2.waitKey (0)

Găsirea contururilor

#utilizați o copie a imaginii dvs., de exemplu - edged.copy (), deoarece găsirea contururilor modifică imaginea # trebuie să adăugăm _, înainte de contururi ca argument gol din cauza actualizării versiunii cv deschise _, contururi, ierarhie = cv2.findContours (tivit, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow („margini grozave după conturare”, tivit) cv2.waitKey (0)

Tipărirea fișierului de contur pentru a ști din ce cuprinde contururile.

print (contururi) print ('Numărul de contururi găsite =' + str (len (contururi)))

Desenați toate contururile

#utilizați -1 ca al treilea parametru pentru a desena toate contururile cv2.drawContours (imagine, contururi, -1, (0,255,0), 3) cv2.imshow („contururi”, imagine) cv2.waitKey (0) cv2. destroyAllWindows

import cv2 import numpy ca np

Permite încărcarea unei imagini simple cu 3 pătrate negre

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

Scara tonurilor de gri

gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY)

Găsiți margini canguroase

edged = cv2.Canny (gri, 30.200) cv2.imshow („margini canny”, margine) cv2.waitKey (0)

Găsirea contururilor

#utilizați o copie a imaginii dvs., de exemplu - edged.copy (), deoarece găsirea contururilor modifică imaginea # trebuie să adăugăm _, înainte de contururi ca argument gol din cauza actualizării versiunii cv deschise _, contururi, ierarhie = cv2.findContours (tivit, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow („margini cutanate după conturare”, tivit) cv2.waitKey (0)

Tipărirea fișierului de contur pentru a ști din ce cuprinde contururile.

print (contururi) print ('Numărul de contururi găsite =' + str (len (contururi)))

Desenați toate contururile

#utilizați -1 ca al treilea parametru pentru a desena toate contururile cv2.drawContours (imagine, contururi, -1, (0,255,0), 3) cv2.imshow („contururi”, imagine) cv2.waitKey (0) cv2. destroyAllWindows ()

Deci, prin demonstrația codurilor de mai sus, am putut vedea clar diferența dintre cv2.RETR_LIST și cv2.RETR_EXTERNNAL , în cv2.RETR_EXTERNNAL doar contururile exterioare sunt luate în considerare, în timp ce contururile interioare sunt ignorate.

În timp ce se află în cv2.RETR_LIST se iau în calcul și contururile interioare.

3. Aproximarea contururilor și găsirea corpului lor convex

În aproximarea contururilor, o formă de contur este aproximată peste o altă formă de contur, care poate să nu fie atât de asemănătoare cu prima formă de contur.

Pentru aproximare folosim approxPolyDP funcție de OpenCV care este explicată mai jos

cv2.approxPolyDP (contur, precizie de aproximare, închis)

Parametri:

• Contur - este conturul individual pe care dorim să îl aproximăm.
• Precizie de aproximare - parametru important în determinarea acurateței aproximării, valoare mică oferă aproximare precisă, valori mari oferă informații mai generice. O regulă bună pentru degetul mare este mai mică de 5% din perimetrul conturului.
• Închis - o valoare booleană care afirmă dacă conturul aproximativ poate fi deschis sau închis.

Să încercăm să aproximăm o figură simplă a unei case

import numpy ca np import cv2

Încărcați imaginea și păstrați o copie

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

Scară de gri și binarizează imaginea

gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) ret, treji = cv2.threshold (gri, 127.255, cv2.THRESH_BINARY_INV)

Găsiți contururi

_, contururi, ierarhie = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Iterează prin fiecare contur și calculează dreptunghiul lor de delimitare

pentru c în contururi: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (original_image, (x, y), (x + w, y + h), (0,0,255), 2) cv2.imshow („Bounding rect”, orig_image) cv2.waitKey (0)

Iterați prin fiecare contur și calculați aprox conturul

pentru c în contururi:

#calculați acuratețea ca procent din precizia perimetrului conturului = 0,03 * cv2.arc Lungime (c, Adevărat) aprox = cv2.approxPolyDP (c, precizie, Adevărat) cv2.drawContours (imagine,, 0, (0,255,0), 2) cv2.imshow („Aproximativ polyDP”, imagine) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Carena convexă

Coca convexă este practic marginile exterioare, reprezentate prin trasarea unor linii peste o anumită figură.

Ar putea fi cel mai mic poligon care se potrivește în jurul obiectului în sine.

import cv2 import numpy as np image = cv2.imread ('star.jpg') gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) cv2.imshow ('imaginea originală', imagine) cv2.waitKey (0)

Pragul imaginii

ret, treier = cv2.threshold (gri, 176.255,0)

Găsiți contururi

_, contururi, ierarhie = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Sortați contururile după zonă și apoi eliminați cel mai mare contur al cadrului

n = len (contururi) -1 contururi = sortate (contururi, cheie = cv2.contourArea, invers = False)

Iterează prin contururi și desenează corpul convex

pentru c în contururi:

hull = cv2.convexHull (c) cv2.drawContours (imagine,, 0, (0,255,0), 2) cv2.imshow ('convex hull', image) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Potrivirea conturului după forme

cv2.matchShapes (șablon de contur, metodă de contur, parametru de metodă)

Ieșire - valoarea potrivirii (valoarea mai mică înseamnă o potrivire mai apropiată)

șablon de contur - Acesta este conturul nostru de referință pe care încercăm să îl găsim într-o nouă imagine.

contur - Conturul individual pe care îl verificăm.

Metodă - Tipul de potrivire a conturului (1,2,3).

parametrul metodei - lăsați-l singur ca 0.0 (nu este utilizat în Python opencv)

import cv2 import numpy ca np

Încărcați șablonul de formă sau imaginea de referință

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

Încărcați imaginea țintă cu formele pe care încercăm să le potrivim

target = cv2.imread ('shapestomatch.jpg') gri = cv2.cvtColor (target, cv2.COLOR_BGR2GRAY)

Priviți ambele imagini mai întâi înainte de a utiliza cv2.findContours

ret, treier1 = cv2.threshold (șablon, 127.255,0) ret, treier2 = cv2.threshold (gri, 127.255,0)

Găsiți contururi în șablon

_, contours, hierarhy = cv2.findContours (thrash1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # trebuie să sortăm contururile după zonă, astfel încât să putem elimina cel mai mare contur care este

Schița imaginii

sorted_contours = sorted (contours, key = cv2.contourArea, reverse = True) # extragem al doilea cel mai mare contur care va fi șablonul nostru de contur tempelate_contour = contururi # extrageți contururile din a doua imagine țintă _, contururi, ierarhie = cv2.findContours (throwh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) pentru c în contururi: #iterează prin fiecare contur din imaginea țintă și folosește cv2.matchShape pentru a compara forma conturului match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print („potrivire”) # dacă valoarea potrivirii este mai mică de 0,15 dacă se potrivește <0,16: cel mai apropiat_contur = c altul: cel mai apropiat_contur = cv2.drawContours (țintă,, - 1, (0,255,0), 3) cv2.imshow („ieșire”),ţintă) cv2.waitKey (0) cv2.destroyAllWindows ()

Ieșire consolă -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

Există trei metode diferite cu funcție matematică diferită, putem experimenta cu fiecare metodă doar înlocuind valorile metodei cv2.matchShapes (tempelate_contour, c, 1, 0,0) care variază între 1,2 și 3, pentru fiecare valoare veți obține o potrivire diferită valorile în ieșirea consolei.

6. Identificarea formelor (cerc, dreptunghi, triunghi, pătrat, stea)

OpenCV poate fi, de asemenea, utilizat pentru detectarea automată a diferitelor tipuri de forme din imagine. Folosind codul de mai jos vom putea detecta cercul, dreptunghiul, triunghiul, pătratul și stelele din imagine.

import cv2 import numpy ca np

Încărcați și apoi imagini la nivel de gri

image = cv2.imread ('formes.jpg') gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) cv2.imshow ('forme de identificare', imagine) cv2.waitKey (0) ret, treji = cv2.threshold (gri, 127.255,1)

Extrageți contururile

_, contururi, ierarhie = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Pentru cnt în contururi:

Obțineți poligoane aproximative aproximativ = cv2.approxPolyDP (cnt, 0,01 * cv2.arcLength (cnt, True), True) dacă len (aproximativ) == 3: shape_name = "Triunghi" cv2.drawContours (imagine,, 0, (0,255, 0), - 1)

găsiți centrul conturului pentru a plasa textul în centru

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagine, nume_formă, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0, 0), 1) elif len (aprox) == 4: x, y, w, h = cv2.boundingRect (cnt) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M)

Verificați dacă acel poligon cu patru fețe este pătrat sau dreptunghi

# cv2.boundingRect returnează lățimea și înălțimea stânga în pixeli, începând din colțul din stânga sus, pentru pătrat ar fi aproximativ același dacă abs (wh) <= 3: shape_name = "pătrat" #find centru de contur pentru a plasa textul la centru cv2.drawContours (imagine,, 0, (0,125,255), - 1) cv2.putText (imagine, nume_formă, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) altceva: shape_name = "Reactangle" #find contour center to place text at center cv2.drawContours (imagine,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagine, nume_formă, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox) == 10: nume_formă = 'stea' cv2.drawContours (imagine,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagine, nume_formă, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox)> = 15: shape_name = 'circle' cv2.drawContours (imagine,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imagine, nume_formă, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow („identificarea formelor”, imagine) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Detectarea liniei

Detectarea liniei este un concept foarte important în OpenCV și are o utilizare promițătoare în lumea reală. Mașinile autonome utilizează algoritmi de detectare a liniilor pentru detectarea benzilor și a drumurilor.

În detectarea liniei ne vom ocupa de doi algoritmi,

• Algoritmul liniei Hough
• Algoritmul liniei Hough Probalistic.

Poate că ți-ai amintit reprezentarea liniei din matematica liceului cu ecuația, y = mx + c.

Cu toate acestea, în OpenCV linia este reprezentată de un alt mod

Ecuația de deasupra ρ = xcosӨ + ysincosӨ este reprezentarea OpenCV a liniei, în care ρ este distanța perpendiculară a liniei de la origine și Ө este unghiul format de normalul acestei linii la origine (măsurat în radiani, în care 1pi radiani / 180 = 1 grad).

Funcția OpenCV pentru detectarea liniei este dată ca

cv2.HoughLines (imagine binarizată, precizie ρ, precizie Ө, prag), în care pragul este votul minim pentru ca acesta să fie considerat o linie.

Acum, să detectăm liniile pentru o imagine de cutie cu ajutorul funcției liniei Hough a opencv.

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

Scară de gri și margini caninoase extrase

gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) margini = cv2.Canny (gri, 100.170, dimensiune diafragmă = 3)

Rulați liniile Hough folosind o precizie rho de 1 pixel

precizie #theta de (np.pi / 180), care este de 1 grad prag #line este setat la 240 (numărul de puncte pe linie) liniile = cv2.HoughLines (muchii, 1, np.pi / 180, 240) #Vrem itera prin fiecare linie și convertiți în formatul #cercat de cv2.lines (adică necesită puncte finale) pentru i în intervalul (0, len (linii)): pentru rho, theta în linii: 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 (imagine, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow („linii de hough”, imagine) cv2.waitKey (0) cv2.destroyAllWindows ()

Acum să repetăm ​​detectarea liniei de mai sus cu alt algoritm al liniei Hough probabiliste.

Ideea din spatele liniei Hough probabilistă este de a lua un subset aleatoriu de puncte suficient de suficient pentru detectarea liniei.

Funcția OpenCV pentru linia Hough probabilistică este reprezentată ca cv2.HoughLinesP (imagine binarizată, precizie ρ, precizie Ө, prag, lungime minimă a liniei, decalaj maxim de linie)

Acum să detectăm liniile de cutie cu ajutorul liniilor Hough probabiliste.

import cv2 import numpy ca np

Scară de gri și margini caninoase Extrase

image = cv2.imread ('box.jpg') gri = cv2.cvtColor (imagine, cv2.COLOR_BGR2GRAY) margini = cv2.Canny (gri, 50.150, apertureSize = 3) # din nou folosim aceleași precizii rho și theta # oricum, specificăm un vot minim (puncte de-a lungul liniei) de 100 # și o lungime a liniei minime de 5 pixeli și spațiu maxim între liniile de 10 pixeli linii = cv2.HoughLinesP (margini, 1, np.pi / 180,100,100,10) pentru i în interval (0, len (linii)): pentru x1, y1, x2, y2 în linii: cv2.line (imagine, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow („linii probabile de hough”, imagine) cv2.waitKey (0) cv2.destroyAllWindows

8. Detectare blob

Blob-urile pot fi descrise ca un grup de pixeli conectați care partajează toți o proprietate comună. Metoda de utilizare a detectorului blob OpenCV este descrisă prin această diagramă.

Pentru desenarea punctelor cheie folosim cv2.drawKeypoints care ia următoarele argumente.

cv2.drawKeypoints (imagine de intrare, puncte cheie, blank_output_array, culoare, steaguri)

unde în steaguri putea fi

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

și gol aici nu este aproape nimic altceva decât una câte una matrice de zerouri

Acum, să efectuăm detectarea blob-ului pe o imagine de floarea-soarelui, unde blob-urile ar fi părțile centrale ale florii, deoarece acestea sunt comune între toate florile.

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

Configurați detectorul cu parametrii impliciți

detector = cv2.SimpleBlobDetector_create ()

Detectați bloburile

puncte cheie = detector.detect (imagine)

Desenați bloburile detectate ca cercuri roșii

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS asigurați-vă că #mărimea cercului corespunde dimensiunii blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagine, keypoints, blank, (0,255,255), cv2.DRAW_SAT_MATCH

Afișați punctele cheie

cv2.imshow („blobs”, blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Chiar dacă codul funcționează bine, dar unele dintre blob-uri sunt ratate din cauza dimensiunilor inegale ale florilor, deoarece florile din față sunt mari în comparație cu florile de la sfârșit.

9. Filtrarea bloburilor - numărarea cercurilor și a elipselor

Putem folosi parametri pentru filtrarea bloburilor în funcție de forma, dimensiunea și culoarea lor. Pentru utilizarea parametrilor cu detector blob folosim funcția OpenCV

cv2.SimpleBlobDetector_Params ()

Vom vedea filtrarea blob-urilor după acești patru parametri enumerați mai jos:

Zonă

params.filterByArea = Adevărat / fals Params.minArea = pixeli params.maxArea = pixeli

Circularitate

params.filterByCircularity = Adevărat / fals Params.minCircularity = 1 fiind perfect, 0 fiind opus

Convexitate - Zona blobului / zona corpului convex

params.filterByConvexity = Adevărat / fals Params.minConvexity = Zona

Inerţie

params.filterByInertia = Adevărat / fals Params.minInertiaRatio = 0,01

Acum să încercăm să filtrăm bloburile după parametrii menționați mai sus

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

Inițializați detectorul utilizând parametrii impliciți

detector = cv2.SimpleBlobDetector_create ()

Detectați bloburile

puncte cheie = detector.detect (imagine)

Desenați bloburi pe imaginea noastră ca cercuri roșii

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagine, keypoints, blank, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "numărul total de blobs" + str (len (puncte cheie)) cv2.putText (blobs, text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100.0.255), 2)

Afișați imaginea cu puncte cheie blob

cv2.imshow („blob folosind parametrii impliciți”, blobs) cv2.waitKey (0)

Setați parametrii noștri de filtrare

#initialize setarea parametrilor utilizând cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Setați parametrii de filtrare a zonei

params.filterByArea = Params.minArea adevărat = 100

Setați parametrii de filtrare a circularității

params.filterByCircularity = Adevărat params.minCircularity = 0.9

Setați parametrul de filtrare a convexității

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

Setați parametrul de filtrare a inerției

params.filterByInertia = Adevărat params.minInertiaRatio = 0,01

Creați detector cu parametru

detector = cv2.SimpleBlobDetector_create (params)

Detectați bloburile

puncte cheie = detector.detect (imagine)

Desenați bloburi pe imagini sub formă de cercuri roșii

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (imagine, keypoints, blank, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) number_of_blobs = len (keypoints) text = "numărul total de blobs circulare" + str (len (puncte cheie)) cv2.putText (blobs, text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Afișați bloburi

cv2.imshow („filtrare blobs circulare”, blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Deci, așa se poate face segmentarea imaginii în Python-OpenCV. Pentru a cunoaște bine viziunea computerizată și OpenCV, parcurgeți articolele anterioare (Noțiuni introductive despre Python OpenCV și Manipulări de imagine în Python OpenCV și veți putea face ceva interesant cu Computer Vision.