def display_grid(data, showcontour=False, contourcolor='w', filter_size=None,
figsize=3, auto=False, nrows=None, **kwargs):
'''
Display a dictionary of images in a nice grid
Parameters
----------
data : dict
a dictionary of images
showcontour: bool (default, False)
Whether to show contours or not
'''
if not isinstance(data, dict):
raise TypeError('Data is not a dictionary!')
fig, axs = make_grid(len(data), nrows=nrows, figsize=figsize)
for (k, v), ax in zip(sorted(data.items()), axs.ravel()):
if v.ndim == 1:
ax.plot(v, **kwargs)
else:
if auto:
# pop vmin and vmax from **kwargs
kwargs.pop('vmin', None)
kwargs.pop('vmax', None)
# calculate vmin, vmax
vmin, vmax = auto_adjust(v)
ax.matshow(v, vmin=vmin, vmax=vmax, **kwargs)
else:
ax.matshow(v, **kwargs)
if showcontour:
if filter_size is None:
vv = v
else:
vv = fft_gaussian_filter(v, filter_size)
ax.contour(vv, colors=contourcolor)
ax.set_title(k)
ax.axis('off')
clean_grid(fig, axs)
return fig, axs
def better_blob_dog(image,
min_sigma=1,
max_sigma=50,
sigma_ratio=1.6,
threshold=0.03):
"""Finds blobs in the given grayscale image.
Blobs are found using the Difference of Gaussian (DoG) method [1]_.
For each blob found, the method returns its coordinates and the standard
deviation of the Gaussian kernel that detected the blob.
Parameters
----------
image : ndarray
Input grayscale image, blobs are assumed to be light on dark
background (white on black).
min_sigma : float, optional
The minimum standard deviation for Gaussian Kernel. Keep this low to
detect smaller blobs.
max_sigma : float, optional
The maximum standard deviation for Gaussian Kernel. Keep this high to
detect larger blobs.
sigma_ratio : float, optional
The ratio between the standard deviation of Gaussian Kernels used for
computing the Difference of Gaussians
threshold : float, optional.
The absolute lower bound for scale space maxima. Local maxima smaller
than thresh are ignored. Reduce this to detect blobs with less
intensities.
Returns
-------
A : (n, 3) ndarray
A 2d array with each row representing 3 values, ``(y, x, sigma)``
where ``(y, x)`` are coordinates of the blob and ``sigma`` is the
standard deviation of the Gaussian kernel which detected the blob.
References
----------
.. [1] http://en.wikipedia.org/wiki/Blob_detection# The_difference_of_Gaussians_approach
Notes
-----
The radius of each blob is approximately :math:`\sqrt{2}sigma`.
"""
assert_nD(image, 2)
image = img_as_float(image)
sigma_ratio = float(sigma_ratio)
# k such that min_sigma*(sigma_ratio**k) > max_sigma
k = int(log(float(max_sigma) / min_sigma, sigma_ratio)) + 1
# a geometric progression of standard deviations for gaussian kernels
sigma_list = np.array([min_sigma * (sigma_ratio**i) for i in range(k + 1)])
# Use the faster fft_gaussian_filter to speed things up.
gaussian_images = [fft_gaussian_filter(image, s) for s in sigma_list]
# computing difference between two successive Gaussian blurred images
# multiplying with standard deviation provides scale invariance
dog_images = [(gaussian_images[i] - gaussian_images[i + 1]) * sigma_list[i]
for i in range(k)]
image_cube = np.dstack(dog_images)
# peak_local_max is looking in the image_cube, so threshold should
# be scaled by differences in sigma, i.e. sigma_ratio
local_maxima = peak_local_max(image_cube,
threshold_abs=threshold,
footprint=np.ones((3, 3, 3)),
threshold_rel=0.0,
exclude_border=False)
# Convert local_maxima to float64
lm = local_maxima.astype(np.float64)
# Convert the last index to its corresponding scale value
lm[:, 2] = sigma_list[local_maxima[:, 2]]
local_maxima = lm
return local_maxima
def better_blob_dog(image, min_sigma=1, max_sigma=50, sigma_ratio=1.6,
threshold=0.03):
"""Finds blobs in the given grayscale image.
Blobs are found using the Difference of Gaussian (DoG) method [1]_.
For each blob found, the method returns its coordinates and the standard
deviation of the Gaussian kernel that detected the blob.
Parameters
----------
image : ndarray
Input grayscale image, blobs are assumed to be light on dark
background (white on black).
min_sigma : float, optional
The minimum standard deviation for Gaussian Kernel. Keep this low to
detect smaller blobs.
max_sigma : float, optional
The maximum standard deviation for Gaussian Kernel. Keep this high to
detect larger blobs.
sigma_ratio : float, optional
The ratio between the standard deviation of Gaussian Kernels used for
computing the Difference of Gaussians
threshold : float, optional.
The absolute lower bound for scale space maxima. Local maxima smaller
than thresh are ignored. Reduce this to detect blobs with less
intensities.
Returns
-------
A : (n, 3) ndarray
A 2d array with each row representing 3 values, ``(y, x, sigma)``
where ``(y, x)`` are coordinates of the blob and ``sigma`` is the
standard deviation of the Gaussian kernel which detected the blob.
References
----------
.. [1] http://en.wikipedia.org/wiki/Blob_detection# The_difference_of_Gaussians_approach
Notes
-----
The radius of each blob is approximately :math:`\sqrt{2}sigma`.
"""
assert_nD(image, 2)
image = img_as_float(image)
sigma_ratio = float(sigma_ratio)
# k such that min_sigma*(sigma_ratio**k) > max_sigma
k = int(log(float(max_sigma) / min_sigma, sigma_ratio)) + 1
# a geometric progression of standard deviations for gaussian kernels
sigma_list = np.array([min_sigma * (sigma_ratio ** i)
for i in range(k + 1)])
# Use the faster fft_gaussian_filter to speed things up.
gaussian_images = [fft_gaussian_filter(image, s) for s in sigma_list]
# computing difference between two successive Gaussian blurred images
# multiplying with standard deviation provides scale invariance
dog_images = [(gaussian_images[i] - gaussian_images[i + 1]) * sigma_list[i]
for i in range(k)]
image_cube = np.dstack(dog_images)
# peak_local_max is looking in the image_cube, so threshold should
# be scaled by differences in sigma, i.e. sigma_ratio
local_maxima = peak_local_max(image_cube, threshold_abs=threshold,
footprint=np.ones((3, 3, 3)),
threshold_rel=0.0,
exclude_border=False)
# Convert local_maxima to float64
lm = local_maxima.astype(np.float64)
# Convert the last index to its corresponding scale value
lm[:, 2] = sigma_list[local_maxima[:, 2]]
local_maxima = lm
return local_maxima
