Segmentation d'image à l'aide d'opencv

Dans les didacticiels précédents, nous avons utilisé OpenCV pour le traitement d'image de base et effectué quelques opérations d'édition d'image avancées. Comme nous le savons, OpenCV est une bibliothèque Open Source Commuter Vision qui a des interfaces C ++, Python et Java et prend en charge Windows, Linux, Mac OS, iOS et Android. Il peut donc être facilement installé dans Raspberry Pi avec l'environnement Python et Linux. Et Raspberry Pi avec OpenCV et caméra connectée peut être utilisé pour créer de nombreuses applications de traitement d'image en temps réel telles que la détection de visage, le verrouillage du visage, le suivi d'objet, la détection de plaque d'immatriculation de voiture, le système de sécurité domestique, etc. segmentation d'image à l'aide d'OpenCV. Les opérations que nous allons effectuer sont répertoriées ci-dessous:

• Segmentation et contours
• Hiérarchie et mode de récupération
• Approcher les contours et trouver leur coque convexe
• Coque Conex
• Contour assorti
• Identifier les formes (cercle, rectangle, triangle, carré, étoile)
• Détection de ligne
• Détection de blob
• Filtrer les blobs - compter les cercles et les ellipses

1. Segmentation et contours

La segmentation d'image est un processus par lequel nous partitionnons les images en différentes régions. Alors que les contours sont les lignes ou courbes continues qui délimitent ou couvrent toute la limite d'un objet dans une image. Et, ici, nous utiliserons une technique de segmentation d'image appelée contours pour extraire les parties d'une image.

Les contours sont également très importants dans

• Détection d'objets
• Analyse de forme

Et ils ont un champ d'application très large, de l'analyse d'images du monde réel à l'analyse d'images médicales telles que l'IRM.

Sachons implémenter des contours dans opencv, en extrayant des contours de carrés.

importer cv2 importer numpy en tant que np

Chargeons une image simple avec 3 carrés noirs

image = cv2.imread ('squares.jpg') cv2.imshow ('image d'entrée', image) cv2.waitKey (0)

Niveaux de gris

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

Trouvez des bords astucieux

edged = cv2.Canny (gris, 30200 ) cv2.imshow ('cany bords', bordé) cv2.waitKey (0)

Trouver des contours

# utiliser une copie de votre image, par exemple - edged.copy (), car trouver des contours modifie l'image # nous devons ajouter _, avant les contours comme argument vide en raison de la mise à niveau de la version OpenCV _, contours, hierarchy = cv2.findContours (bordé, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bords malfaisants après le contouring', bordé) cv2.waitKey (0)

Impression du fichier de contour pour savoir ce que les contours comprennent

print (contours) print ('Nombre de contours trouvés =' + str (len (contours)))

Dessinez tous les contours

# utilisez -1 comme 3ème paramètre pour dessiner tous les contours cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Sortie console -],],], …,],],]], dtype = int32), tableau (],],

], …,

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

Nombre de contours trouvés = 3. Nous avons donc trouvé un total de trois contours.

Maintenant, dans le code ci-dessus, nous avions également imprimé le fichier de contour en utilisant , ce fichier indique à quoi ressemblent ces contours, comme indiqué dans la sortie de la console ci-dessus.

Dans la sortie de la console ci-dessus, nous avons une matrice qui ressemble aux coordonnées de points x, y. OpenCV stocke les contours dans une liste de listes. Nous pouvons simplement afficher la sortie de la console ci-dessus comme suit:

CONTOUR 1 CONTOUR 2 CONTOUR 3

], tableau (], tableau (],],],],],],],

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

Maintenant, comme nous utilisons la fonction de longueur sur un fichier de contour, nous obtenons la longueur égale à 3, cela signifie qu'il y avait trois listes de listes dans ce fichier, soit trois contours.

Maintenant, imaginez que CONTOUR 1 est le premier élément de ce tableau et que cette liste contient la liste de toutes les coordonnées et que ces coordonnées sont les points le long des contours que nous venons de voir, comme les cases rectangulaires vertes.

Il existe différentes méthodes pour stocker ces coordonnées et celles-ci sont appelées méthodes d'approximation, essentiellement les méthodes d'approximation sont de deux types

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE stocke tous les points limites, mais nous n'avons pas nécessairement besoin de tous les points limites, si le point forme une ligne droite, nous n'avons besoin que du point de départ et du point d'arrivée sur cette ligne.

cv2.CHAIN_APPROX_SIMPLE fournit à la place uniquement les points de début et de fin des contours de délimitation, le résultat est un stockage beaucoup plus efficace des informations de contour.

_, contours, hiérarchie = cv2.findContours (bordé, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

Dans le code ci-dessus cv2.RETR_EXTERNAL est le mode de récupération tandis que le cv2.CHAIN_APPROX_NONE est

la méthode d'approximation.

Nous avons donc appris les contours et la méthode d'approximation, explorons maintenant la hiérarchie et le mode de récupération.

2. Hiérarchie et mode de récupération

Le mode de récupération définit la hiérarchie en contours comme les sous-contours, ou le contour externe ou tous les contours.

Il existe maintenant quatre modes d'extraction triés sur les types de hiérarchie.

cv2.RETR_LIST - récupère tous les contours.

cv2.RETR_EXTERNAL - récupère uniquement les contours externes ou externes.

cv2.RETR_CCOMP - récupère tout dans une hiérarchie à 2 niveaux.

cv2.RETR_TREE - récupère tout dans une hiérarchie complète.

La hiérarchie est stockée dans le format suivant

Illustrons maintenant la différence entre les deux premiers modes de récupération, cv2.RETR_LIST et cv2.RETR_EXTERNAL.

importer cv2 importer numpy en tant que np

Permet de charger une image simple avec 3 carrés noirs

image = cv2.imread ('square donut.jpg') cv2.imshow ('image d'entrée', image) cv2.waitKey (0)

Niveaux de gris

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

Trouver Canny Edges

edged = cv2.Canny (gris, 30200 ) cv2.imshow ('cany bords', bordé) cv2.waitKey (0)

Recherche de contours

# utiliser une copie de votre image, par exemple - edged.copy (), car trouver des contours modifie l'image # nous devons ajouter _, avant les contours comme argument vide en raison de la mise à jour de la version ouverte du cv _, contours, hierarchy = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('cany bords after contouring', edged) cv2.waitKey (0)

Impression du fichier de contour pour savoir en quoi consistent les contours.

print (contours) print ('Nombre de contours trouvés =' + str (len (contours)))

Dessinez tous les contours

# utilisez -1 comme 3ème paramètre pour dessiner tous les contours cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows

importer cv2 importer numpy en tant que np

Permet de charger une image simple avec 3 carrés noirs

image = cv2.imread ('square donut.jpg') cv2.imshow ('image d'entrée', image) cv2.waitKey (0)

Niveaux de gris

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

Trouvez des bords astucieux

edged = cv2.Canny (gris, 30200 ) cv2.imshow ('cany bords', bordé) cv2.waitKey (0)

Trouver des contours

# utiliser une copie de votre image, par exemple - edged.copy (), car trouver des contours modifie l'image # nous devons ajouter _, avant les contours comme argument vide en raison de la mise à jour de la version ouverte du cv _, contours, hierarchy = cv2.findContours (bordé, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('bords canons après le contouring', bordé) cv2.waitKey (0)

Impression du fichier de contour pour savoir en quoi consistent les contours.

print (contours) print ('Nombre de contours trouvés =' + str (len (contours)))

Dessinez tous les contours

# utilisez -1 comme 3ème paramètre pour dessiner tous les contours cv2.drawContours (image, contours, -1, (0,255,0), 3) cv2.imshow ('contours', image) cv2.waitKey (0) cv2. destroyAllWindows ()

Ainsi, grâce à la démonstration des codes ci-dessus, nous avons pu clairement voir la différence entre la cv2.RETR_LIST et la cv2.RETR_EXTERNNAL , dans cv2.RETR_EXTERNNAL seuls les contours extérieurs sont pris en compte tandis que les contours intérieurs sont ignorés.

Alors que dans cv2.RETR_LIST, les contours intérieurs sont également pris en compte.

3. Approximation des contours et recherche de leur coque convexe

Lors de l'approximation des contours, une forme de contour est approchée sur une autre forme de contour, qui peut ne pas être très similaire à la première forme de contour.

Pour approximation, nous utilisons approxPolyDP fonction de OpenCV qui est expliquée ci - dessous

cv2.approxPolyDP (contour, précision d'approximation, fermé)

Paramètres:

• Contour - est le contour individuel que nous souhaitons approximer.
• Précision d'approximation - paramètre important pour déterminer la précision de l'approximation, une petite valeur donne une approximation précise, de grandes valeurs donnent des informations plus génériques. Une bonne règle empirique est inférieure à 5% du périmètre du contour.
• Closed - une valeur booléenne indiquant si le contour approximatif peut être ouvert ou fermé.

Essayons d'approcher une figure simple d'une maison

import numpy comme np import cv2

Chargez l'image et conservez une copie

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

Niveaux de gris et binariser l'image

gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold (gris, 127255, cv2.THRESH_BINARY_INV)

Trouver des contours

_, contours, hiérarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Parcourez chaque contour et calculez leur rectangle englobant

pour c dans les contours: 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)

Parcourez chaque contour et calculez le contour approximatif

pour c dans les contours:

#calculer la précision en pourcentage de la précision du périmètre du contour = 0,03 * cv2.arcLength (c, True) approx = cv2.approxPolyDP (c, precision, True) cv2.drawContours (image,, 0, (0,255,0), 2) cv2.imshow ('Approx polyDP', image) cv2.waitKey (0) cv2.destroyAllWindows ()

4. Coque convexe

La coque convexe est essentiellement les bords extérieurs, représentés par des lignes de dessin sur une figure donnée.

Il peut s'agir du plus petit polygone pouvant s'ajuster autour de l'objet lui-même.

import cv2 import numpy as np image = cv2.imread ('star.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('image originale', image) cv2.waitKey (0)

Seuil de l'image

ret, thresh = cv2.threshold (gris, 176,255,0)

Trouver des contours

_, contours, hiérarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Trier les contours par zone, puis supprimer le plus grand contour du cadre

n = len (contours) -1 contours = trié (contours, clé = cv2.contourArea, reverse = False)

Itérer à travers les contours et dessiner une coque convexe

pour c dans les contours:

coque = cv2.convexHull (c) cv2.drawContours (image,, 0, (0,255,0), 2) cv2.imshow ('coque convexe', image) cv2.waitKey (0) cv2.destroyAllWindows ()

5. Contour correspondant par formes

cv2.matchShapes (modèle de contour, méthode de contour, paramètre de méthode)

Sortie - valeur de correspondance (une valeur inférieure signifie une correspondance plus proche)

modèle de contour - Ceci est notre contour de référence que nous essayons de trouver dans une nouvelle image.

contour - Le contour individuel que nous vérifions.

Méthode - Type de correspondance de contour (1, 2, 3).

paramètre de méthode - laisser seul comme 0.0 (non utilisé dans python opencv)

importer cv2 importer numpy en tant que np

Charger le modèle de forme ou l'image de référence

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

Chargez l'image cible avec les formes que nous essayons de faire correspondre

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

Seuil des deux images avant d'utiliser cv2.findContours

ret, thresh1 = cv2.threshold (modèle, 127,255,0) ret, thresh2 = cv2.threshold (gris, 127,255,0)

Rechercher des contours dans le modèle

_, contours, hierarhy = cv2.findContours (thresh1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # nous devons trier les contours par zone afin que nous puissions supprimer le plus grand contour qui est

Contour de l'image

sorted_contours = sorted (contours, key = cv2.contourArea, reverse = True) # nous extrayons le deuxième plus grand contour qui sera notre modèle de contour tempelate_contour = contours # extrayez les contours de la deuxième image cible _, contours, hierarchy = cv2.findContours (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) pour c dans les contours: #iterate à travers chaque contour dans l'image cible et utilisez cv2.matchShape pour comparer la forme de contour match = cv2.matchShapes (tempelate_contour, c, 1,0.0) print ("match") # si la valeur de correspondance est inférieure à 0,15 si la correspondance est <0,16: plus proche_contour = c sinon: plus proche_contour = cv2.drawContours (cible,, - 1, (0,255,0), 3) cv2.imshow ('sortie',cible) cv2.waitKey (0) cv2.destroyAllWindows ()

Sortie de la console -

0,16818605122199104

0,19946910256158912

0,18949760627309664

0,11101058276281539

Il existe trois méthodes différentes avec des fonctions mathématiques différentes, nous pouvons expérimenter chaque méthode en remplaçant simplement les valeurs de la méthode cv2.matchShapes (tempelate_contour, c, 1, 0.0) qui varient de 1,2 et 3, pour chaque valeur, vous obtiendrez une correspondance différente valeurs dans la sortie de la console.

6. Identifier les formes (cercle, rectangle, triangle, carré, étoile)

OpenCV peut également être utilisé pour détecter automatiquement différents types de formes à partir de l'image. En utilisant le code ci-dessous, nous pourrons détecter un cercle, un rectangle, un triangle, un carré et des étoiles à partir de l'image.

importer cv2 importer numpy en tant que np

Chargez, puis des images en échelle de gris

image = cv2.imread ('forms.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) cv2.imshow ('identification des formes', image) cv2.waitKey (0) ret, thresh = cv2.threshold (gray, 127,255,1)

Extraire les contours

_, contours, hiérarchie = cv2.findContours (thresh.copy (), cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

Pour cnt dans les contours:

Obtenez des polygones approximatifs approx = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) si len (approx) == 3: shape_name = "Triangle" cv2.drawContours (image,, 0, (0,255, 0), - 1)

trouver le centre du contour pour placer le texte au centre

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

Vérifiez si ce polygone à quatre côtés est carré ou rectangle

# cv2.boundingRect renvoie la largeur et la hauteur de gauche en pixels, à partir du coin supérieur #gauche, pour square, ce serait à peu près la même chose si abs (wh) <= 3: shape_name = "square" #find contour center pour placer le texte à center 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) autre: shape_name = "Reactangle" #find contour center pour placer le texte au centre cv2.drawContours (image,, 0, (0,0,255), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, nom_forme, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (approx) == 10: nom_forme = 'étoile' cv2.drawContours (image,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, nom_forme, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (approx)> = 15: shape_name = 'cercle' cv2.drawContours (image`` 0, (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (image, nom_forme, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) cv2.imshow ('identification des formes', image) cv2.waitKey (0) cv2.destroyAllWindows ()

7. Détection de ligne

La détection de ligne est un concept très important dans OpenCV, et a une utilisation prometteuse dans le monde réel. Les voitures autonomes utilisent des algorithmes de détection de ligne pour la détection des voies et des routes.

En détection en ligne, nous traiterons de deux algorithmes,

• Algorithme de Hough Line
• Algorithme Probalistic de Hough Line.

Vous vous êtes peut-être souvenu de la représentation de la ligne des mathématiques du secondaire avec l'équation y = mx + c.

Cependant, dans la ligne OpenCV est représentée d'une autre manière

L'équation ci-dessus ρ = xcosӨ + ysincosӨ est la représentation OpenCV de la ligne, où ρ est la distance perpendiculaire de la ligne à l'origine et Ө est l'angle formé par la normale de cette ligne à l'origine (mesuré en radians, où 1pi radians / 180 = 1 degré).

La fonction OpenCV pour la détection de ligne est donnée comme

cv2.HoughLines (image binarisée, ρ précision, Ө précision, seuil), où le seuil est le vote minimum pour qu'il soit considéré comme une ligne.

Détectons maintenant les lignes d'une image de boîte à l'aide de la fonction de ligne Hough d'opencv.

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

Niveaux de gris et bords astucieux extraits

gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) bords = cv2.Canny (gris, 100170, apertureSize = 3)

Exécutez des lignes Hough en utilisant une précision rho de 1 pixel

# précision thêta de (np.pi / 180) qui est de 1 degré # seuil de ligne est fixé à 240 (nombre de points sur la ligne) lignes = cv2.HoughLines (arêtes, 1, np.pi / 180, 240) #we iterate à travers chaque ligne et convertir au format #requis par cv2.lines (c'est-à-dire nécessitant des points d'extrémité) pour i dans la plage (0, len (lignes)): pour rho, thêta en lignes: a = np.cos (theta) b = np.sin (thêta) 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 (image, (x1, y1), (x2, y2), (0,255,0), 2) cv2.imshow ('hough lines', image) cv2.waitKey (0) cv2.destroyAllWindows ()

Répétons maintenant la détection au-dessus de la ligne avec un autre algorithme de la ligne de Hough probabiliste.

L'idée derrière la ligne de Hough probabiliste est de prendre un sous-ensemble aléatoire de points suffisant pour la détection de ligne.

La fonction OpenCV pour la ligne de Hough probabiliste est représentée par cv2.HoughLinesP (image binarisée, ρ précision, Ө précision, seuil, longueur de ligne minimum, écart de ligne maximum)

Détectons maintenant les lignes de boîte à l'aide de lignes de Hough probabilistes.

importer cv2 importer numpy en tant que np

Niveaux de gris et bords astucieux extraits

image = cv2.imread ('box.jpg') gray = cv2.cvtColor (image, cv2.COLOR_BGR2GRAY) bords = cv2.Canny (gray, 50,150, apertureSize = 3) #encore nous utilisons les mêmes précisions rho et thêta #Cependant, nous spécifions un vote minimum (pts le long de la ligne) de 100 # et une longueur de ligne minimale de 5 pixels et un écart maximum entre les lignes de 10 pixels lines = cv2.HoughLinesP (bords, 1, np.pi / 180,100,100,10) pour i in range (0, len (lines)): pour x1, y1, x2, y2 in lines: cv2.line (image, (x1, y1), (x2, y2), (0,255,0), 3) cv2. imshow ('lignes hough probalistes', image) cv2.waitKey (0) cv2.destroyAllWindows

8. Détection de blob

Les objets blob peuvent être décrits comme un groupe de pixels connectés qui partagent tous une propriété commune. La méthode d'utilisation du détecteur d'objets blob OpenCV est décrite dans cet organigramme.

Pour dessiner les points clés, nous utilisons cv2.drawKeypoints qui prend les arguments suivants.

cv2.drawKeypoints (image d'entrée, points clés, tableau de sortie_blanc, couleur, indicateurs)

où dans les drapeaux pourraient être

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

et vide ici n'est à peu près rien d'autre qu'une matrice de zéros un par un

Maintenant, effectuons la détection des taches sur une image de tournesols, où les taches seraient les parties centrales de la fleur car elles sont communes à toutes les fleurs.

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

Configurer le détecteur avec les paramètres par défaut

detecteur = cv2.SimpleBlobDetector_create ()

Détecter les blobs

points clés = detecteur.detect (image)

Dessinez les gouttes détectées sous forme de cercles rouges

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS s'assure que la #size of circle correspond à la taille de blob blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (image, keypoints, blank, (0,255,255), cv2.DRAW_MATCHESFFL)

Afficher les points clés

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

Même si le code fonctionne bien, mais certaines des taches sont manquées en raison de tailles inégales des fleurs, car les fleurs à l'avant sont grandes par rapport aux fleurs à la fin.

9. Filtrage des objets blob - Comptage des cercles et des ellipses

Nous pouvons utiliser des paramètres pour filtrer les blobs en fonction de leur forme, taille et couleur. Pour utiliser des paramètres avec le détecteur de blob, nous utilisons la fonction OpenCV

cv2.SimpleBlobDetector_Params ()

Nous verrons filtrer les blobs principalement par ces quatre paramètres listés ci-dessous:

Surface

params.filterByArea = Vrai / Faux params.minArea = pixels params.maxArea = pixels

Circularité

params.filterByCircularity = Vrai / Faux params.minCircularity = 1 étant parfait, 0 étant opposé

Convexité - Zone de tache / zone de coque convexe

params.filterByConvexity = Vrai / Faux params.minConvexity = Aire

Inertie

params.filterByInertia = Vrai / Faux params.minInertiaRatio = 0,01

Essayons maintenant de filtrer les blobs par les paramètres mentionnés ci-dessus

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

Initialisez le détecteur en utilisant les paramètres par défaut

detecteur = cv2.SimpleBlobDetector_create ()

Détecter les blobs

points clés = detecteur.detect (image)

Dessinez des gouttes sur notre image sous forme de cercles rouges

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 = "nombre total de blobs" + str (len (points clés)) cv2.putText (blobs, texte, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

Afficher l'image avec des points-clés de blob

cv2.imshow ('blob utilisant les paramètres par défaut', blobs) cv2.waitKey (0)

Définissez nos paramètres de filtrage

#initialiser la configuration du paramètre à l'aide de cv2.SimpleBlobDetector params = cv2.SimpleBlobDetector_Params ()

Définir les paramètres de filtrage de zone

params.filterByArea = Vrai params.minArea = 100

Définir les paramètres de filtrage de circularité

params.filterByCircularity = Vrai params.minCircularity = 0.9

Définir le paramètre de filtrage de convexité

params.filterByConvexity = Faux params.minConvexity = 0.2

Définir le paramètre de filtrage par inertie

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

Créer un détecteur avec paramètre

detecteur = cv2.SimpleBlobDetector_create (paramètres)

Détecter les blobs

points clés = detecteur.detect (image)

Dessinez des gouttes sur les images sous forme de cercles rouges

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 = "nombre total de blobs circulaires" + str (len (points clés)) cv2.putText (blobs, texte, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,100,255), 2)

Afficher les blobs

cv2.imshow ('filtrage des blobs circulaires', des blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

Voici donc comment la segmentation d'image peut être effectuée dans Python-OpenCV. Pour bien comprendre la vision par ordinateur et OpenCV, parcourez les articles précédents (Premiers pas avec Python OpenCV et les manipulations d'images dans Python OpenCV et vous pourrez faire quelque chose de cool avec Computer Vision.