introduction

Je prends souvent des photos de cellules à cause de mon travail, j'ai donc analysé les images de cellules avec la version Python d'OpenCV.

Avec une signification commémorative.

Cette fois, nous trouverons le ratio de cellules cultivées recouvrant la surface adhésive du récipient de culture (taux d'occupation cellulaire ou confluence), ce que l'on appelle la "confluence cellulaire".

En bref, le taux d'occupation des cellules dans l'image microscopique est quantifié par analyse d'image.

Veuillez commenter si vous avez des opinions ou si vous souhaitez faire plus comme ça.

URL de référence

Image à utiliser

Une micrographie de cellules appelées cellules souches mésenchymateuses (CSM).

À première vue, la confluence (taux d'occupation des cellules de l'image) est d'environ 30 à 40%.

Forfaits requis

Chargez la bibliothèque ** OpenCV ** pour l'analyse d'image à l'aide de Python.

Chargez également ** NumPy **.

#Bibliothèque
import cv2
import numpy as np

Chargement d'image et mise à l'échelle des gris

La fonction ** imread () ** lit les données d'image en couleur, et la fonction ** cvtColor () ** les met à l'échelle des gris.

** cvtColor () ** Le premier argument de la fonction est l'image d'entrée (image couleur). Puisque les données acquises par la fonction ** imread () ** sont au format BGR, spécifiez `` cv2.COLOR_BGR2GRAY '' comme second argument.

#Chargement des images couleur
img = cv2.imread('cell.jpg', 1)

#Échelle de gris
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Binariser l'image

Binarisez l'image.

C'est-à-dire que si la valeur de pixel est plus grande que la valeur de seuil, une certaine valeur (blanc) est attribuée, et sinon, une autre valeur (noir) est attribuée.

Il semble y avoir différentes méthodes de binarisation, mais j'ai essayé d'utiliser celle appelée "binarisation d'Otsu".

Traitement du seuil d'image

Utilisez la fonction ** threshold () ** pour binariser.

** seuil () ** Le premier argument de la fonction doit être une image d'entrée et une image en niveaux de gris. Le deuxième argument est le seuil, qui est utilisé pour identifier la valeur du pixel. Le troisième argument est la valeur maximale attribuée aux pixels avec une valeur supérieure ou égale au seuil. Comme mentionné ci-dessus, OpenCV a plusieurs méthodes de traitement de seuil, qui sont spécifiées par le 4ème argument. Cette fois, nous utiliserons la méthode de "binarisation d'Otsu", donc nous utiliserons cv2.THRESH_BINARY + cv2.THRESH_OTSU.

#Binarisation d'Otsu
ret,th = cv2.threshold(img_gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

La fonction ** threshold () ** renvoie deux valeurs de retour. La deuxième valeur de retour `` th '' est une ** image binarisée **.

Conversion de morphologie (expansion)

Une conversion de morphologie (expansion) est effectuée pour supprimer le bruit dans l'image.

Selon la taille du noyau (taille 5x5 cette fois), tous les pixels près de la limite de l'objet passent du noir (0) au blanc (1) et disparaissent. Si même un pixel avec une valeur de pixel de «1» est inclus dans le noyau, la valeur de pixel du pixel d’attention de l’image de sortie sera de «1».

Conversion morphologique

#Paramètres du noyau
kernel = np.ones((5,5),np.uint8)

#Conversion de morphologie (expansion)
th_dilation = cv2.dilate(th,kernel,iterations = 1)

Avant la conversion morphologique (** th **)

Après conversion morphologique (** th_dilation **)

La zone noire à l'intérieur de la cellule peut être convertie en zone blanche.

Extraction de contour

Le contour est extrait sur la base de l'image dont le bruit a été supprimé par conversion de morphologie.

Utilisez la fonction ** findContours () ** pour extraire les contours.

** findContours () ** Le premier argument de la fonction est l'image utilisée pour l'extraction des contours. Le deuxième argument spécifie le mode d'extraction et le troisième argument spécifie la méthode d'approximation des contours.

** findContours () ** La valeur de retour de la fonction, `` contours '', contient les coordonnées de chaque contour au format de tableau Numpy.

Utilisez `` contours '' pour dessiner des contours sur l'image d'origine avec la fonction ** drawContours () **.

Lorsque vous dessinez le contour entier, spécifiez le troisième argument de la fonction ** drawContours () ** sur `` -1 ''.

[Aperçu: première étape](http://labs.eecs.tottori-u.ac.jp/sd/Member/oyamada/OpenCV/html/py_tutorials/py_imgproc/py_contours/py_contours_begin/py_contours_begin.html#contours-getting- commencé)

#Extraction de contour
contours, hierarchy = cv2.findContours(th_dilation,
                                       cv2.RETR_LIST,
                                       cv2.CHAIN_APPROX_NONE)

#Dessiner le contour sur l'image d'origine
img_contour = cv2.drawContours(img, contours, -1, (0, 255, 0), 3)

Calcul de la zone noir et blanc

Obtenez le nombre total de pixels avec `` .size ''.

Obtenez le nombre de pixels dans la zone blanche, c'est-à-dire la zone de cellule avec la fonction ** countNonZero () **.

Nombre total de pixels - Calculez la zone blanche et obtenez le nombre de pixels dans la zone noire (zones autres que les cellules).

Enfin, chaque rapport est affiché.

#Nombre total de pixels
whole_area = th_dilation.size

#Nombre de pixels dans la partie blanche
white_area = cv2.countNonZero(th_dilation)

#Nombre de pixels dans la partie noire
black_area = whole_area - white_area

#Afficher chaque pourcentage
print('White_Area =' + str(white_area / whole_area * 100) + ' %')
print('Black_Area =' + str(black_area / whole_area * 100) + ' %')

résultat

White_Area =26.266264121542658 %
Black_Area =73.73373587845734 %

Le résultat était que la confluence cellulaire était d'environ 30%.

Affichage de l'image

Enfin, l'image d'origine avec le contour ajouté et l'image utilisée pour l'extraction du contour sont affichées.

#Affichage de l'image
cv2.imshow('img', img)
cv2.imshow('th_dilation', th_dilation)
cv2.waitKey(0)
cv2.destroyAllWindows()