Segmentació d'imatges mitjançant opencv

En els tutorials anteriors, hem utilitzat OpenCV per al processament bàsic d’imatges i hem fet algunes operacions d’edició d’imatges avançades. Com sabem, OpenCV és Open Source Commuter Vision Library que té interfícies C ++, Python i Java i és compatible amb Windows, Linux, Mac OS, iOS i Android. Per tant, es pot instal·lar fàcilment a Raspberry Pi amb entorns Python i Linux. I Raspberry Pi amb OpenCV i càmera connectada es pot utilitzar per crear moltes aplicacions de processament d’imatges en temps real, com ara detecció de cares, bloqueig de cares, seguiment d’objectes, detecció de matrícules de vehicles, sistema de seguretat domèstica, etc. En aquest tutorial aprendrem com fer-ho segmentació d'imatges mitjançant OpenCV. A continuació es detallen les operacions que realitzarem:

• Segmentació i contorns
• Jerarquia i mode de recuperació
• Aproximant contorns i trobant el seu casc convex
• Conex Hull
• Contorn coincident
• Identificar formes (cercle, rectangle, triangle, quadrat, estrella)
• Detecció de línies
• Detecció de blob
• Filtrar els blobs: comptar cercles i el·lipses

1. Segmentació i contorns

La segmentació d’imatges és un procés mitjançant el qual compartim les imatges en diferents regions. Mentre que els contorns són les línies o corbes contínues que uneixen o cobreixen el límit complet d'un objecte en una imatge. I, aquí utilitzarem una tècnica de segmentació d'imatges anomenada contorns per extreure les parts d'una imatge.

També són molt importants els contorns

• Detecció d'objectes
• Anàlisi de formes

I tenen un camp d’aplicació molt ampli, des de l’anàlisi d’imatges del món real fins a l’anàlisi d’imatges mèdiques, com ara a les ressonàncies magnètiques

Sabem com implementar contorns en opencv, mitjançant l'extracció de contorns de quadrats.

importar cv2 importar numpy com a np

Carregem una imatge senzilla amb 3 quadrats negres

image = cv2.imread ('quadrats.jpg') cv2.imshow ('imatge d'entrada', imatge) cv2.waitKey (0)

Escala de grisos

gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY)

Cerqueu vores canyoses

edged = cv2.Canny (gris, 30.200) cv2.imshow ('cantons'), cv2.waitKey (0)

Cercar contorns

#utilitzeu una còpia de la vostra imatge, per exemple - edged.copy (), ja que la cerca de contorns altera la imatge # hem d'afegir _, abans que els contorns siguin un argument buit a causa de l'actualització de la versió OpenCV _, contorns, jerarquia = cv2.findContours (vorejat, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ("vores canyoses després del contorn", vorejat) cv2.waitKey (0)

Impressió del fitxer de contorn per saber de què es compon el contorn

print (contorns) print ('Nombre de contorns trobats =' + str (len (contorns)))

Dibuixa tots els contorns

#utilitza -1 com a tercer paràmetre per dibuixar tots els contorns cv2.drawContours (imatge, contorns, -1, (0,255,0), 3) cv2.imshow ('contorns', imatge) cv2.waitKey (0) cv2. destroyAllWindows ()

Sortida de la consola -],],], …,],],]], dtype = int32), array (],],

], …,

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

Nombre de contorns trobats = 3. Així doncs, hem trobat un total de tres contorns.

Ara, en el codi anterior també havíem imprès l'arxiu de contorn utilitzant , aquesta imatge indica com aquests contorns sembla, tal com figura en sortida de la consola anterior.

A la sortida de la consola anterior tenim una matriu que sembla coordenades de punts x, y. OpenCV emmagatzema contorns en llistes de llistes. Simplement podem mostrar la sortida de la consola anterior de la següent manera:

CONTOUR 1 CONTOUR 2 CONTOUR 3

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

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

Ara, quan fem servir la funció de longitud al fitxer de contorn, obtenim la longitud igual a 3, vol dir que hi havia tres llistes de llistes en aquest fitxer, és a dir, tres contorns.

Ara, imaginem CONTOUR 1 és el primer element d’aquesta matriu i aquesta llista conté la llista de totes les coordenades i aquestes coordenades són els punts al llarg dels contorns que acabem de veure, com les caixes rectangulars verdes.

Hi ha diferents mètodes per emmagatzemar aquestes coordenades i s’anomenen mètodes d’aproximació, bàsicament els mètodes d’aproximació són de dos tipus

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE emmagatzema tot el punt límit, però no necessàriament necessitem tots els punts límit, si el punt forma una línia recta, només necessitem el punt inicial i final d’aquesta línia.

cv2.CHAIN_APPROX_SIMPLE només proporciona els punts inicial i final dels contorns delimitadors, el resultat és un emmagatzematge molt més eficient de la informació del contorn.

_, contorns, jerarquia = cv2.findContours (amb vores, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

Al codi anterior cv2.RETR_EXTERNAL és el mode de recuperació mentre que cv2.CHAIN_APPROX_NONE és

el mètode d’aproximació.

Per tant, hem après sobre els contorns i el mètode d’aproximació; ara explorem la jerarquia i el mode de recuperació.

2. Jerarquia i mode de recuperació

El mode de recuperació defineix la jerarquia en contorns, com ara contorns secundaris, o contorns externs o tots els contorns.

Ara hi ha quatre modes de recuperació ordenats en els tipus de jerarquia.

cv2.RETR_LIST: recupera tots els contorns.

cv2.RETR_EXTERNAL: només recupera contorns externs o externs.

cv2.RETR_CCOMP: recupera tot en una jerarquia de 2 nivells.

cv2.RETR_TREE: recupera tot en una jerarquia completa.

La jerarquia s’emmagatzema en el format següent

Ara il·lustrem la diferència entre els dos primers modes de recuperació, cv2.RETR_LIST i cv2.RETR_EXTERNAL.

importar cv2 importar numpy com a np

Permet carregar una imatge senzilla amb 3 quadrats negres

image = cv2.imread ('donut quadrat.jpg') cv2.imshow ('imatge d'entrada', imatge) cv2.waitKey (0)

Escala de grisos

gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY)

Troba Canny Edges

edged = cv2.Canny (gris, 30.200) cv2.imshow ('cantons'), cv2.waitKey (0)

Cercar contorns

#utilitzeu una còpia de la vostra imatge, per exemple - edged.copy (), ja que la cerca de contorns altera la imatge # hem d'afegir _, abans que els contorns siguin un argument buit a causa de l'actualització de la versió de cv oberta _, contorns, jerarquia = cv2.findContours (vorejat, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ("vores canyoses després del contorn", vorejat) cv2.waitKey (0)

Impressió del fitxer de contorn per saber de què es compon el contorn.

print (contorns) print ('Nombre de contorns trobats =' + str (len (contorns)))

Dibuixa tots els contorns

#utilitza -1 com a tercer paràmetre per dibuixar tots els contorns cv2.drawContours (imatge, contorns, -1, (0,255,0), 3) cv2.imshow ('contorns', imatge) cv2.waitKey (0) cv2. destroyAllWindows

importar cv2 importar numpy com a np

Permet carregar una imatge senzilla amb 3 quadrats negres

image = cv2.imread ('donut quadrat.jpg') cv2.imshow ('imatge d'entrada', imatge) cv2.waitKey (0)

Escala de grisos

gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY)

Cerqueu vores canyoses

edged = cv2.Canny (gris, 30.200) cv2.imshow ('cantons'), cv2.waitKey (0)

Cercar contorns

#utilitzeu una còpia de la vostra imatge, per exemple - edged.copy (), ja que la cerca de contorns altera la imatge # hem d'afegir _, abans que els contorns siguin un argument buit a causa de l'actualització de la versió de cv oberta _, contorns, jerarquia = cv2.findContours (vorejat, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ("vores canyoses després del contorn", vores) cv2.waitKey (0)

Impressió del fitxer de contorn per saber de què es compon el contorn.

print (contorns) print ('Nombre de contorns trobats =' + str (len (contorns)))

Dibuixa tots els contorns

#utilitza -1 com a tercer paràmetre per dibuixar tots els contorns cv2.drawContours (imatge, contorns, -1, (0,255,0), 3) cv2.imshow ('contorns', imatge) cv2.waitKey (0) cv2. destroyAllWindows ()

Així doncs, mitjançant la demostració dels codis anteriors vam poder veure clarament la diferència entre cv2.RETR_LIST i cv2.RETR_EXTERNNAL , a cv2.RETR_EXTERNNAL només es tenen en compte els contorns externs mentre s’ignoren els contorns interns.

Mentre que a cv2.RETR_LIST també es tenen en compte els contorns interiors.

3. Aproximació de contorns i trobada del seu casc convex

En aproximar els contorns, una forma de contorn s’aproxima a una altra forma de contorn, que potser no és tan similar a la primera forma de contorn.

Per fer aproximacions utilitzem la funció approxPolyDP d’openCV que s’explica a continuació

cv2.approxPolyDP (contorn, precisió d'aproximació, tancat)

Paràmetres:

• Contorn: és el contorn individual que volem aproximar.
• Precisió d'aproximació: paràmetre important per determinar la precisió de l'aproximació; el valor petit proporciona una aproximació precisa, els valors grans donen informació més genèrica. Una bona regla del polze és inferior al 5% del perímetre del contorn.
• Tancat: valor booleà que indica si el contorn aproximat podria ser obert o tancat.

Intentem aproximar una figura senzilla d’una casa

importar numpy com np importar cv2

Carregueu la imatge i en guardeu una còpia

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

Escala de grisos i binaritza la imatge

gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) ret, batre = llindar cv2. (gris, 127.255, cv2.THRESH_BINARY_INV)

Cerca contorns

_, contorns, jerarquia = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Repeteix cada contorn i calcula el seu rectangle delimitant

per a c en contorns: 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)

Repeteix cada contorn i calcula el contorn aproximat

per a c en contorns:

#calcula la precisió com a percentatge de precisió del perímetre del contorn = 0,03 * cv2.arcLongitud (c, cert) aprox = cv2.approxPolyDP (c, precisió, cert) cv2.drawContours (imatge,, 0, (0,255,0), 2) cv2.imshow ("Aprox polyDP", imatge) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Casc convex

El casc convex és bàsicament la vora exterior, representada dibuixant línies sobre una figura determinada.

Podria ser el polígon més petit que pot cabre al voltant del propi objecte.

importar cv2 importar numpy com np image = cv2.imread ('star.jpg') gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) cv2.imshow ('imatge original', imatge) cv2.waitKey (0)

Llindar la imatge

ret, batre = llindar cv2. (gris, 176.255,0)

Cerqueu contorns

_, contorns, jerarquia = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Ordeneu els contorns per àrea i traieu el contorn del marc més gran

n = len (contorns) -1 contorns = ordenats (contorns, clau = cv2.contourArea, revers = False)

Repeteix els contorns i dibuixa el casc convex

per a c en contorns:

casco = cv2.convexHull (c) cv2.drawContours (imatge,, 0, (0,255,0), 2) cv2.imshow ('casc convex', imatge) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Coincidència del contorn per formes

cv2.matchShapes (plantilla de contorn, mètode de contorn, paràmetre de mètode)

Sortida: valor de coincidència (el valor inferior significa una coincidència més propera)

plantilla de contorn: aquest és el nostre contorn de referència que intentem trobar en una imatge nova.

contorn: el contorn individual que estem comprovant.

Mètode: tipus de concordança de contorn (1,2,3).

paràmetre del mètode: deixeu-lo sol com a 0,0 (no s'utilitza a Python opencv)

importar cv2 importar numpy com a np

Carregueu la plantilla de forma o la imatge de referència

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

Carregueu la imatge objectiu amb les formes que intentem fer coincidir

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

Llindar primer les dues imatges abans d’utilitzar cv2.findContours

ret, thrill1 = llindar cv2. (plantilla, 127.255,0) ret, thrill2 = llindar cv2. (gris, 127.255,0)

Cerqueu contorns a la plantilla

_, contours, hierarhy = cv2.findContours (thrash1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # hem d'ordenar els contorns per àrea perquè puguem eliminar el contorn més gran que és

Esquema de la imatge

sorted_contours = ordenat (contorns, clau = cv2.contourArea, revers = True) #extreu el segon contorn més gran que serà la nostra plantilla contorn tempelate_contour = contorns #extreu els contorns de la segona imatge objectiu _, contorns, jerarquia = cv2.findContours (thirh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) per a contorns: #iterar a través de cada contorn de la imatge de destinació i utilitzar cv2.matchShape per comparar la forma del contorn match = cv2.matchShapes (tempelate_contour, c, 1,0,0) imprimir ("coincideix") # si el valor de coincidència és inferior a 0,15 si coincideix amb <0,16: contorn_proximat = c else: contorn_pròxim = cv2.drawContours (objectiu,, - 1, (0,255,0), 3) cv2.imshow ('sortida'),objectiu) cv2.waitKey (0) cv2.destroyAllWindows ()

Sortida de la consola:

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

Hi ha tres mètodes diferents amb diferents funcions matemàtiques, podem experimentar amb cada mètode simplement substituint valors del mètode cv2.matchShapes (tempelate_contour, c, 1, 0,0) que varia entre 1,2 i 3, per a cada valor obtindreu una coincidència diferent valors en la sortida de la consola.

6. Identificar formes (cercle, rectangle, triangle, quadrat, estrella)

OpenCV també es pot utilitzar per detectar diferents tipus de formes automàticament de la imatge. En utilitzar el codi següent, podrem detectar cercles, rectangles, triangles, quadrats i estrelles de la imatge.

importar cv2 importar numpy com a np

Carregueu imatges a escala de grisos

image = cv2.imread ('formes.jpg') gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) cv2.imshow ('identificació de formes', imatge) cv2.waitKey (0) ret, thrash = cv2.threshold (gris, 127.255,1)

Extreure contorns

_, contorns, jerarquia = cv2.findContours (throwh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Per a cnt en contorns:

Obteniu polígons aproximats aproximadament = cv2.approxPolyDP (cnt, 0,01 * cv2.arcLength (cnt, True), True) si len (aprox) == 3: shape_name = "Triangle" cv2.drawContours (imatge,, 0, (0,255, 0), - 1)

cerqueu el centre de contorn per col·locar text al centre

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imatge, forma_nom, (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)

Comproveu si aquest polígon de quatre cares és quadrat o rectangle

# cv2.boundingRect retorna l'amplada i l'alçada esquerra en píxels, començant per la # cantonada esquerra superior , per al quadrat seria aproximadament el mateix si abs (wh) <= 3: shape_name = "quadrat" #find centre del contorn per col·locar text centre cv2.drawContours (image,, 0, (0,125,255), - 1) cv2.putText (image, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) else: shape_name = "Reactangle" #find contour centre to place text at center cv2.drawContours (image,, 0, (0,0,255), - 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 (aprox) == 10: shape_name = 'estrella' cv2.drawContours (imatge,, 0, (255.255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imatge, forma_nom, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (aprox)> = 15: shape_name = 'circle' cv2.drawContours (imatge,, 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (imatge, forma_nom, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ("identificació de formes", imatge) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Detecció de línies

La detecció de línies és un concepte molt important a OpenCV i té un ús prometedor al món real. Els cotxes autònoms utilitzen algoritmes de detecció de línies per a la detecció de carrils i carreteres.

En la detecció de línia tractarem dos algoritmes,

• Algorisme de línia Hough
• Algorisme de línia Hough probalístic.

És possible que hagueu recordat la representació de la línia de les matemàtiques de l’institut amb l’equació, y = mx + c.

No obstant això, en OpenCV la línia es representa per una altra forma

L'equació superior a ρ = xcosӨ + ysincosӨ és la representació OpenCV de la línia, en la qual ρ és la distància perpendicular de la línia des de l'origen i Ө és l'angle format per la normal d'aquesta línia a l'origen (mesurat en radians, en què radiants 1pi / 180 = 1 grau).

La funció OpenCV per a la detecció de línia es dóna com a

cv2.HoughLines (imatge binaritzada, precisió ρ, precisió,, llindar), en què el llindar és el vot mínim perquè es consideri una línia.

Ara anem a detectar línies per a una imatge de quadre amb l'ajut de la funció de línia Hough de opencv.

importa cv2 importa numpy com np image = cv2.imread ('box.jpg')

Escales de grisos i vores canyoses extretes

gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) vores = cv2.Canny (gris, 100.170, obertura Size = 3)

Executeu les línies Hough amb una precisió rho d'1 píxel

La precisió #theta de (np.pi / 180) que és d'1 grau # el llindar de la línia s'estableix en 240 (nombre de punts a la línia) línies = cv2.HoughLines (arestes, 1, np.pi / 180, 240) #we iterate a través de cada línia i convertir-lo en el format #required per cv2.lines (és a dir, que requereixen punts finals) per a l’interval (0, len (línies)): per a rho, theta en línies: 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 (imatge, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('línies de hough'), imatge) cv2.waitKey (0) cv2.destroyAllWindows ()

Ara repetim la detecció de la línia anterior amb un altre algorisme de línia probabilística de Hough.

La idea darrere de la línia probabilística de Hough és agafar un subconjunt aleatori de punts suficient per a la detecció de la línia.

La funció OpenCV per a la línia probabilística de Hough es representa com a cv2.HoughLinesP (imatge binaritzada, precisió ρ, precisió,, llindar, longitud mínima de línia, espai màxim de línia)

Ara anem a detectar línies de caixa amb l'ajut de línies probabilístiques de Hough.

importar cv2 importar numpy com a np

Escales de grisos i vores canyoses Extretes

image = cv2.imread ('box.jpg') gris = cv2.cvtColor (imatge, cv2.COLOR_BGR2GRAY) arestes = cv2.Canny (gris, 50.150, obertura Size = 3) # de nou fem servir les mateixes precisions rho i theta #tot i tot, especifiquem un vot mínim (pts al llarg de la línia) de 100 # i una longitud de línia mínima de 5 píxels i un espai màxim entre les línies de línies de 10 píxels = cv2.HoughLinesP (arestes, 1, np.pi / 180,100,100,10) per a a l'interval (0, len (línies)): per a x1, y1, x2, y2 en línies: cv2.line (imatge, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('línies probades de hough', imatge) cv2.waitKey (0) cv2.destroyAllWindows

8. Detecció de blobs

Els blobs es poden descriure com un grup de píxels connectats que comparteixen una propietat comuna. El mètode per utilitzar el detector de blob OpenCV es descriu a través d’aquest diagrama de flux.

Per dibuixar els punts clau utilitzem cv2.drawKeypoints que pren els arguments següents.

cv2.drawKeypoints (imatge d'entrada, punts clau, matriu_deixida en blanc, color, indicadors)

on a les banderes podria estar

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 en blanc aquí no hi ha gairebé res més que una per una matriu de zeros

Ara realitzem la detecció de blobs en una imatge de gira-sols, on les blobs serien les parts centrals de la flor, ja que són habituals entre totes les flors.

importa cv2 importa numpy com np image = cv2.imread ("Sunflowers.jpg", cv2.IMREAD_GRAYSCALE)

Configureu el detector amb paràmetres predeterminats

detector = cv2.SimpleBlobDetector_create ()

Detecta blobs

punts clau = detector.detect (imatge)

Dibuixa les taques detectades com a cercles vermells

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS assegureu-vos que la # mida del cercle correspon a la mida de blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,255), cv2.DRAW_STA_MATCH

Mostra els punts clau

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

Tot i que el codi funciona bé, però algunes de les taques es perden a causa de les mides desiguals de les flors, ja que les flors de la part frontal són grans en comparació amb les flors del final.

9. Filtrar els blobs: comptar cercles i punts suspensius

Podem utilitzar paràmetres per filtrar els blobs segons la seva forma, mida i color. Per utilitzar paràmetres amb detector de blob utilitzem la funció d’OpenCV

cv2.SimpleBlobDetector_Params ()

Veurem filtrar els blobs principalment per aquests quatre paràmetres que s’enumeren a continuació:

Zona

params.filterByArea = Verdader / Fals params.minArea = píxels params.maxArea = píxels

Circularitat

params.filterByCircularity = Verdader / Fals params.minCircularity = 1 és perfecte, 0 és oposat

Convexitat: àrea del blob / àrea del casc convex

params.filterByConvexity = Verdader / Fals params.minConvexity = Àrea

Inèrcia

params.filterByInertia = Verdader / Fals params.minInertiaRatio = 0,01

Ara intentem filtrar els blobs segons els paràmetres esmentats anteriorment

importa cv2 importa numpy com np image = cv2.imread ('blobs.jpg') cv2.imshow ('imatge original', imatge) cv2.waitKey (0)

Inicialitzeu el detector mitjançant paràmetres predeterminats

detector = cv2.SimpleBlobDetector_create ()

Detecta blobs

punts clau = detector.detect (imatge)

Dibuixa taques a la nostra imatge com a cercles vermells

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 no de blobs" + str (len (punts clau)) cv2.putText (blobs, text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100.0.255), 2)

Mostra la imatge amb punts clau de blob

cv2.imshow ('blob amb paràmetres predeterminats', blobs) cv2.waitKey (0)

Establiu els nostres paràmetres de filtratge

#initialize paràmetre mitjançant cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Estableix paràmetres de filtratge d'àrea

params.filterByArea = Veritable params.minArea = 100

Estableix paràmetres de filtratge de circularitat

params.filterByCircularity = Params.minCircularity veritable = 0,9

Estableix el paràmetre de filtratge de convexitat

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

Estableix el paràmetre de filtratge d'inèrcia

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

Crea detector amb paràmetre

detector = cv2.SimpleBlobDetector_create (params)

Detecta blobs

punts clau = detector.detect (imatge)

Dibuixa taques a les imatges com a cercles vermells

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 = "no total de blobs circulars" + str (len (punts clau)) cv2.putText (blobs, text, (20.550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Mostra blobs

cv2.imshow ('filtratge de taques circulars', taques) cv2.waitKey (0) cv2.destroyAllWindows ()

Així doncs, es pot fer la segmentació d’imatges a Python-OpenCV. Per obtenir una bona comprensió de la visió per ordinador i OpenCV, consulteu articles anteriors (Introducció a Python OpenCV i manipulacions d’imatges a Python OpenCV i podreu fer alguna cosa divertit amb Computer Vision.