Detección de blobs

Un procedimiento común para la detección de máximos locales en imágenes procesadas se llama detección de blobs. Típicamente se aplica a imágenes de Diferencia de Gaussianas (DoG), Laplaciano de Gaussiana (LoG) y Determinante de Hessiana (DoH). Usaremos funciones de scikit-image para ello. La ventaja de estos métodos es que no se necesita preprocesamiento, está integrado.

Ver también

• Detección de blobs (tutorial de scikit-image)

• Detección y seguimiento de puntos (video)

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

Comenzamos cargando una imagen y recortando una región con fines de demostración. Usamos el conjunto de imágenes BBBC007v1 versión 1 (Jones et al., Proc. ICCV Workshop on Computer Vision for Biomedical Image Applications, 2005), disponible en 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)

Por razones técnicas, es importante convertir primero el tipo de píxel de esta imagen (ver esta discusión) y este problema de GitHub.

image = image.astype(float)

Diferencia de Gaussianas (DoG)

La técnica DoG consiste en dos operaciones de desenfoque gaussiano aplicadas a una imagen. Las imágenes resultantes se restan entre sí, dando como resultado una imagen donde se eliminan los objetos más pequeños y más grandes que un rango de tamaño o sigma definido. En esta imagen, se detectan máximos locales. Lea más en la documentación 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)

Este array contiene coordenadas en x e y y el sigma correspondiente al máximo. Podemos extraer la lista de coordenadas y visualizarla.

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

[<matplotlib.lines.Line2D at 0x1a509079a00>]

Laplaciano de Gaussiana (LoG)

La técnica LoG es un núcleo laplaciano aplicado a una imagen con desenfoque gaussiano. En la imagen resultante, los objetos de un tamaño dado se pueden detectar más fácilmente porque se ha eliminado el ruido y se han mejorado los bordes.

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>]

Determinante de Hessiana (DoH)

Este enfoque funciona determinando máximos en la imagen del determinante de Hessiana de una imagen con desenfoque gaussiano del original (leer más).

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>]