mirror of
https://github.com/wassname/scikit-image.git
synced 2026-06-27 18:25:32 +08:00
Jeremy Metz
176 lines
6.6 KiB
Python
176 lines
6.6 KiB
Python
import numpy as np
|
|
import scipy.ndimage as ndi
|
|
from ..filters import rank_order
|
|
|
|
|
|
def peak_local_max(image, min_distance=1, threshold_abs=None,
|
|
threshold_rel=None, exclude_border=True, indices=True,
|
|
num_peaks=np.inf, footprint=None, labels=None):
|
|
"""Find peaks in an image as coordinate list or boolean mask.
|
|
|
|
Peaks are the local maxima in a region of `2 * min_distance + 1`
|
|
(i.e. peaks are separated by at least `min_distance`).
|
|
|
|
If peaks are flat (i.e. multiple adjacent pixels have identical
|
|
intensities), the coordinates of all such pixels are returned.
|
|
|
|
If both `threshold_abs` and `threshold_rel` are provided, the maximum
|
|
of the two is chosen as the minimum intensity threshold of peaks.
|
|
|
|
Parameters
|
|
----------
|
|
image : ndarray
|
|
Input image.
|
|
min_distance : int, optional
|
|
Minimum number of pixels separating peaks in a region of `2 *
|
|
min_distance + 1` (i.e. peaks are separated by at least
|
|
`min_distance`).
|
|
To find the maximum number of peaks, use `min_distance=1`.
|
|
threshold_abs : float, optional
|
|
Minimum intensity of peaks. By default, the absolute threshold is
|
|
the minimum intensity of the image.
|
|
threshold_rel : float, optional
|
|
Minimum intensity of peaks, calculated as `max(image) * threshold_rel`.
|
|
exclude_border : int, optional
|
|
If nonzero, `exclude_border` excludes peaks from
|
|
within `exclude_border`-pixels of the border of the image.
|
|
indices : bool, optional
|
|
If True, the output will be an array representing peak
|
|
coordinates. If False, the output will be a boolean array shaped as
|
|
`image.shape` with peaks present at True elements.
|
|
num_peaks : int, optional
|
|
Maximum number of peaks. When the number of peaks exceeds `num_peaks`,
|
|
return `num_peaks` peaks based on highest peak intensity.
|
|
footprint : ndarray of bools, optional
|
|
If provided, `footprint == 1` represents the local region within which
|
|
to search for peaks at every point in `image`. Overrides
|
|
`min_distance` (also for `exclude_border`).
|
|
labels : ndarray of ints, optional
|
|
If provided, each unique region `labels == value` represents a unique
|
|
region to search for peaks. Zero is reserved for background.
|
|
|
|
Returns
|
|
-------
|
|
output : ndarray or ndarray of bools
|
|
|
|
* If `indices = True` : (row, column, ...) coordinates of peaks.
|
|
* If `indices = False` : Boolean array shaped like `image`, with peaks
|
|
represented by True values.
|
|
|
|
Notes
|
|
-----
|
|
The peak local maximum function returns the coordinates of local peaks
|
|
(maxima) in an image. A maximum filter is used for finding local maxima.
|
|
This operation dilates the original image. After comparison of the dilated
|
|
and original image, this function returns the coordinates or a mask of the
|
|
peaks where the dilated image equals the original image.
|
|
|
|
Examples
|
|
--------
|
|
>>> img1 = np.zeros((7, 7))
|
|
>>> img1[3, 4] = 1
|
|
>>> img1[3, 2] = 1.5
|
|
>>> img1
|
|
array([[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
|
|
[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
|
|
[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
|
|
[ 0. , 0. , 1.5, 0. , 1. , 0. , 0. ],
|
|
[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
|
|
[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ],
|
|
[ 0. , 0. , 0. , 0. , 0. , 0. , 0. ]])
|
|
|
|
>>> peak_local_max(img1, min_distance=1)
|
|
array([[3, 2],
|
|
[3, 4]])
|
|
|
|
>>> peak_local_max(img1, min_distance=2)
|
|
array([[3, 2]])
|
|
|
|
>>> img2 = np.zeros((20, 20, 20))
|
|
>>> img2[10, 10, 10] = 1
|
|
>>> peak_local_max(img2, exclude_border=0)
|
|
array([[10, 10, 10]])
|
|
|
|
"""
|
|
|
|
if type(exclude_border) == bool:
|
|
exclude_border = min_distance if exclude_border else 0
|
|
|
|
out = np.zeros_like(image, dtype=np.bool)
|
|
|
|
# In the case of labels, recursively build and return an output
|
|
# operating on each label separately
|
|
if labels is not None:
|
|
label_values = np.unique(labels)
|
|
# Reorder label values to have consecutive integers (no gaps)
|
|
if np.any(np.diff(label_values) != 1):
|
|
mask = labels >= 1
|
|
labels[mask] = 1 + rank_order(labels[mask])[0].astype(labels.dtype)
|
|
labels = labels.astype(np.int32)
|
|
|
|
# New values for new ordering
|
|
label_values = np.unique(labels)
|
|
for label in label_values[label_values != 0]:
|
|
maskim = (labels == label)
|
|
out += peak_local_max(image * maskim, min_distance=min_distance,
|
|
threshold_abs=threshold_abs,
|
|
threshold_rel=threshold_rel,
|
|
exclude_border=exclude_border,
|
|
indices=False, num_peaks=np.inf,
|
|
footprint=footprint, labels=None)
|
|
|
|
if indices is True:
|
|
return np.transpose(out.nonzero())
|
|
else:
|
|
return out.astype(np.bool)
|
|
|
|
if np.all(image == image.flat[0]):
|
|
if indices is True:
|
|
return np.empty((0, 2), np.int)
|
|
else:
|
|
return out
|
|
|
|
# Non maximum filter
|
|
if footprint is not None:
|
|
image_max = ndi.maximum_filter(image, footprint=footprint,
|
|
mode='constant')
|
|
else:
|
|
size = 2 * min_distance + 1
|
|
image_max = ndi.maximum_filter(image, size=size, mode='constant')
|
|
mask = image == image_max
|
|
|
|
if exclude_border:
|
|
# zero out the image borders
|
|
for i in range(mask.ndim):
|
|
mask = mask.swapaxes(0, i)
|
|
remove = (footprint.shape[i] if footprint is not None
|
|
else 2 * exclude_border)
|
|
mask[:remove // 2] = mask[-remove // 2:] = False
|
|
mask = mask.swapaxes(0, i)
|
|
|
|
# find top peak candidates above a threshold
|
|
thresholds = []
|
|
if threshold_abs is None:
|
|
threshold_abs = image.min()
|
|
thresholds.append(threshold_abs)
|
|
if threshold_rel is not None:
|
|
thresholds.append(threshold_rel * image.max())
|
|
if thresholds:
|
|
mask &= image > max(thresholds)
|
|
|
|
# get coordinates of peaks
|
|
coordinates = np.transpose(mask.nonzero())
|
|
|
|
if coordinates.shape[0] > num_peaks:
|
|
intensities = image.flat[np.ravel_multi_index(coordinates.transpose(),
|
|
image.shape)]
|
|
idx_maxsort = np.argsort(intensities)[::-1]
|
|
coordinates = coordinates[idx_maxsort][:num_peaks]
|
|
|
|
if indices is True:
|
|
return coordinates
|
|
else:
|
|
nd_indices = tuple(coordinates.T)
|
|
out[nd_indices] = True
|
|
return out
|