Blob-Erkennung#

Ein gängiges Verfahren zur Erkennung lokaler Maxima in verarbeiteten Bildern wird als Blob-Erkennung bezeichnet. Es wird typischerweise auf Difference-of-Gaussian (DoG), Laplacian-of-Gaussian (LoG) und Determinant-of-Hessian (DoH) Bilder angewendet. Wir werden dafür Funktionen von scikit-image verwenden. Der Vorteil dieser Methoden ist, dass keine Vorverarbeitung notwendig ist, sie ist bereits integriert.

Siehe auch

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

Wir beginnen mit dem Laden eines Bildes und dem Zuschneiden eines Bereichs für Demonstrationszwecke. Wir haben den Bilddatensatz BBBC007v1 Version 1 verwendet (Jones et al., Proc. ICCV Workshop on Computer Vision for Biomedical Image Applications, 2005), verfügbar in der 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

Aus technischen Gründen ist es wichtig, den Pixeltyp dieses Bildes zuerst zu konvertieren (siehe diese Diskussion) und dieses GitHub-Problem.

image = image.astype(float)

Difference-of-Gaussian (DoG)#

Die DoG-Technik besteht aus zwei Gaußschen Unschärfeoperationen, die auf ein Bild angewendet werden. Die resultierenden Bilder werden voneinander subtrahiert, was zu einem Bild führt, in dem Objekte kleiner und größer als ein definierter Größen- oder sigma-Bereich entfernt werden. In diesem Bild werden lokale Maxima erkannt. Lesen Sie mehr in der Dokumentation von 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)

Dieses Array enthält Koordinaten in x und y sowie das Sigma, das dem Maximum entspricht. Wir können die Liste der Koordinaten extrahieren und visualisieren.

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

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

Laplacian-of-Gaussian (LoG)#

Die LoG-Technik ist ein Laplace-Kernel, der auf ein Gauß-geglättetes Bild angewendet wird. Im resultierenden Bild können Objekte einer bestimmten Größe leichter erkannt werden, da Rauschen entfernt und Kanten verstärkt wurden.

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

Determinant-of-Hessian (DoH)#

Dieser Ansatz funktioniert, indem Maxima im Hesse-Determinanten-Bild eines Gauß-geglätteten Bildes des Originals bestimmt werden (mehr lesen).

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