Détection de taches#

Une procédure courante pour la détection des maxima locaux sur des images traitées s’appelle la détection de taches. Elle est généralement appliquée aux images de Différence de Gaussiennes (DoG), Laplacien de Gaussiennes (LoG) et Déterminant de Hessienne (DoH). Nous utiliserons les fonctions de scikit-image pour cela. L’avantage de ces méthodes est qu’aucun prétraitement n’est nécessaire, il est intégré.

Voir aussi

from skimage.feature import blob_dog, blob_log, blob_doh

import pyclesperanto_prototype as cle
from skimage.io import imread, imshow
from skimage.filters import gaussian 
import matplotlib.pyplot as plt

Nous commençons par charger une image et découper une région à des fins de démonstration. Nous avons utilisé l’ensemble d’images BBBC007v1 version 1 (Jones et al., Proc. ICCV Workshop on Computer Vision for Biomedical Image Applications, 2005), disponible dans la Broad Bioimage Benchmark Collection [Ljosa et al., Nature Methods, 2012].

image = imread("../../data/BBBC007_batch/A9 p7d.tif")[-100:, 0:100]

cle.imshow(image)
../_images/8641a082f73416921fa012245d92e7dcb078bcb651b843865b416a1a714e51e0.png

Pour des raisons techniques, il est important de convertir d’abord le type de pixel de cette image (voir cette discussion) et ce problème GitHub.

image = image.astype(float)

Différence de Gaussiennes (DoG)#

La technique DoG consiste en deux opérations de flou gaussien appliquées à une image. Les images résultantes sont soustraites l’une de l’autre, produisant une image où les objets plus petits et plus grands qu’une taille ou une plage sigma définie sont supprimés. Dans cette image, les maxima locaux sont détectés. En savoir plus dans la documentation de blob_dog.

coordinates_dog = blob_dog(image, min_sigma=1, max_sigma=10, threshold=1)
coordinates_dog

array([[10.    , 30.    ,  4.096 ],
       [24.    , 85.    ,  4.096 ],
       [42.    , 39.    ,  4.096 ],
       [11.    ,  0.    ,  4.096 ],
       [87.    , 35.    ,  4.096 ],
       [71.    , 85.    ,  4.096 ],
       [32.    , 71.    ,  4.096 ],
       [46.    ,  0.    ,  1.    ],
       [ 9.    , 58.    ,  4.096 ],
       [78.    , 18.    ,  6.5536],
       [81.    , 85.    ,  1.6   ],
       [99.    , 90.    ,  2.56  ],
       [ 0.    , 99.    ,  6.5536],
       [51.    , 41.    ,  1.6   ],
       [52.    ,  0.    ,  1.    ],
       [16.    , 99.    ,  1.6   ],
       [99.    , 81.    ,  1.6   ],
       [41.    , 27.    ,  1.    ],
       [34.    , 37.    ,  1.    ],
       [16.    ,  8.    ,  1.    ],
       [46.    , 25.    ,  1.    ],
       [99.    , 49.    ,  1.    ],
       [99.    , 45.    ,  1.    ]])

coordinates_dog.shape

(23, 3)

Ce tableau contient les coordonnées en x et y et le sigma correspondant au maximum. Nous pouvons extraire la liste des coordonnées et la visualiser.

cle.imshow(image, continue_drawing=True)
plt.plot(coordinates_dog[:, 1], coordinates_dog[:, 0], 'r.')

[<matplotlib.lines.Line2D at 0x1a509079a00>]
../_images/04dbb052939cd5cad2686af6662a69b07d8e48238b0791180c5e83c66d6f3d51.png

Laplacien de Gaussiennes (LoG)#

La technique LoG est un noyau laplacien appliqué à une image floutée gaussienne. Dans l’image résultante, les objets d’une taille donnée peuvent être détectés plus facilement car le bruit a été supprimé et les bords renforcés.

coordinates_log = blob_log(image, min_sigma=1, max_sigma=10, num_sigma=10, threshold=1)
coordinates_log

array([[10., 30.,  5.],
       [23., 85.,  4.],
       [43., 38.,  6.],
       [11.,  0.,  6.],
       [71., 85.,  6.],
       [87., 35.,  5.],
       [ 9., 58.,  5.],
       [46.,  0.,  1.],
       [77., 17.,  7.],
       [81., 85.,  2.],
       [99., 90.,  3.],
       [ 0., 99.,  8.],
       [51., 41.,  2.],
       [52.,  0.,  1.],
       [16., 99.,  3.],
       [87., 19.,  2.],
       [99., 81.,  2.],
       [41., 27.,  1.],
       [34., 36.,  1.],
       [56., 38.,  1.],
       [17.,  8.,  1.],
       [46., 25.,  1.],
       [35., 44.,  1.],
       [56., 33.,  1.],
       [62., 83.,  1.],
       [99., 49.,  2.],
       [99., 45.,  1.],
       [82., 95.,  1.],
       [99., 42.,  1.]])

cle.imshow(image, continue_drawing=True)
plt.plot(coordinates_log[:, 1], coordinates_log[:, 0], 'r.')

[<matplotlib.lines.Line2D at 0x1a5090b3a90>]
../_images/4bdf11e1fc397d63d1bedad4ab36eda87210f12eb274eb513979c9905b0efe28.png

Déterminant de Hessienne (DoH)#

Cette approche fonctionne en déterminant les maxima dans l’image du déterminant hessien d’une image floutée gaussienne de l’original (en savoir plus).

coordinates_doh = blob_doh(image, min_sigma=1, max_sigma=10, num_sigma=10, threshold=1)
coordinates_doh

array([[25., 85., 10.],
       [43., 37., 10.],
       [86., 34.,  8.],
       [71., 85., 10.],
       [ 0., 30., 10.],
       [31., 70.,  9.],
       [ 0., 77., 10.],
       [76., 16., 10.],
       [ 0., 57.,  9.],
       [ 1., 93.,  5.],
       [97., 89.,  3.],
       [ 0., 44.,  6.],
       [71., 29.,  9.],
       [ 0.,  0.,  9.],
       [19., 16., 10.],
       [95., 22.,  9.],
       [62.,  0., 10.],
       [92.,  0., 10.],
       [28., 50., 10.],
       [41., 81.,  9.],
       [30., 25., 10.],
       [59., 72., 10.],
       [43., 58., 10.],
       [85., 95.,  9.],
       [88., 74., 10.],
       [17., 34.,  5.],
       [74., 45., 10.],
       [98., 84.,  1.],
       [53., 11., 10.],
       [99., 43.,  9.],
       [35., 98.,  9.],
       [58., 49.,  9.],
       [57., 99.,  9.],
       [10., 99.,  7.],
       [57., 34.,  3.],
       [32.,  0., 10.]])

cle.imshow(image, continue_drawing=True)
plt.plot(coordinates_doh[:, 1], coordinates_doh[:, 0], 'r.')

[<matplotlib.lines.Line2D at 0x1a5090d0310>]
../_images/2406ef61364ebb6c3f17adc617d29a3cb276c0f340ec7008c4d5710eccacf5aa.png