rm CondaPkg environment
This commit is contained in:
@@ -1,249 +0,0 @@
|
||||
"""
|
||||
canny.py - Canny Edge detector
|
||||
|
||||
Reference: Canny, J., A Computational Approach To Edge Detection, IEEE Trans.
|
||||
Pattern Analysis and Machine Intelligence, 8:679-714, 1986
|
||||
"""
|
||||
|
||||
import numpy as np
|
||||
import scipy.ndimage as ndi
|
||||
|
||||
from ..util.dtype import dtype_limits
|
||||
from .._shared.filters import gaussian
|
||||
from .._shared.utils import _supported_float_type, check_nD
|
||||
from ._canny_cy import _nonmaximum_suppression_bilinear
|
||||
|
||||
|
||||
def _preprocess(image, mask, sigma, mode, cval):
|
||||
"""Generate a smoothed image and an eroded mask.
|
||||
|
||||
The image is smoothed using a gaussian filter ignoring masked
|
||||
pixels and the mask is eroded.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
image : array
|
||||
Image to be smoothed.
|
||||
mask : array
|
||||
Mask with 1's for significant pixels, 0's for masked pixels.
|
||||
sigma : scalar or sequence of scalars
|
||||
Standard deviation for Gaussian kernel. The standard
|
||||
deviations of the Gaussian filter are given for each axis as a
|
||||
sequence, or as a single number, in which case it is equal for
|
||||
all axes.
|
||||
mode : str, {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}
|
||||
The ``mode`` parameter determines how the array borders are
|
||||
handled, where ``cval`` is the value when mode is equal to
|
||||
'constant'.
|
||||
cval : float, optional
|
||||
Value to fill past edges of input if `mode` is 'constant'.
|
||||
|
||||
Returns
|
||||
-------
|
||||
smoothed_image : ndarray
|
||||
The smoothed array
|
||||
eroded_mask : ndarray
|
||||
The eroded mask.
|
||||
|
||||
Notes
|
||||
-----
|
||||
This function calculates the fractional contribution of masked pixels
|
||||
by applying the function to the mask (which gets you the fraction of
|
||||
the pixel data that's due to significant points). We then mask the image
|
||||
and apply the function. The resulting values will be lower by the
|
||||
bleed-over fraction, so you can recalibrate by dividing by the function
|
||||
on the mask to recover the effect of smoothing from just the significant
|
||||
pixels.
|
||||
"""
|
||||
gaussian_kwargs = dict(sigma=sigma, mode=mode, cval=cval,
|
||||
preserve_range=False)
|
||||
compute_bleedover = (mode == 'constant' or mask is not None)
|
||||
float_type = _supported_float_type(image.dtype)
|
||||
if mask is None:
|
||||
if compute_bleedover:
|
||||
mask = np.ones(image.shape, dtype=float_type)
|
||||
masked_image = image
|
||||
|
||||
eroded_mask = np.ones(image.shape, dtype=bool)
|
||||
eroded_mask[:1, :] = 0
|
||||
eroded_mask[-1:, :] = 0
|
||||
eroded_mask[:, :1] = 0
|
||||
eroded_mask[:, -1:] = 0
|
||||
|
||||
else:
|
||||
mask = mask.astype(bool, copy=False)
|
||||
masked_image = np.zeros_like(image)
|
||||
masked_image[mask] = image[mask]
|
||||
|
||||
# Make the eroded mask. Setting the border value to zero will wipe
|
||||
# out the image edges for us.
|
||||
s = ndi.generate_binary_structure(2, 2)
|
||||
eroded_mask = ndi.binary_erosion(mask, s, border_value=0)
|
||||
|
||||
if compute_bleedover:
|
||||
# Compute the fractional contribution of masked pixels by applying
|
||||
# the function to the mask (which gets you the fraction of the
|
||||
# pixel data that's due to significant points)
|
||||
bleed_over = gaussian(mask.astype(float_type, copy=False),
|
||||
**gaussian_kwargs) + np.finfo(float_type).eps
|
||||
|
||||
# Smooth the masked image
|
||||
smoothed_image = gaussian(masked_image, **gaussian_kwargs)
|
||||
|
||||
# Lower the result by the bleed-over fraction, so you can
|
||||
# recalibrate by dividing by the function on the mask to recover
|
||||
# the effect of smoothing from just the significant pixels.
|
||||
if compute_bleedover:
|
||||
smoothed_image /= bleed_over
|
||||
|
||||
return smoothed_image, eroded_mask
|
||||
|
||||
|
||||
def canny(image, sigma=1., low_threshold=None, high_threshold=None,
|
||||
mask=None, use_quantiles=False, *, mode='constant', cval=0.0):
|
||||
"""Edge filter an image using the Canny algorithm.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
image : 2D array
|
||||
Grayscale input image to detect edges on; can be of any dtype.
|
||||
sigma : float, optional
|
||||
Standard deviation of the Gaussian filter.
|
||||
low_threshold : float, optional
|
||||
Lower bound for hysteresis thresholding (linking edges).
|
||||
If None, low_threshold is set to 10% of dtype's max.
|
||||
high_threshold : float, optional
|
||||
Upper bound for hysteresis thresholding (linking edges).
|
||||
If None, high_threshold is set to 20% of dtype's max.
|
||||
mask : array, dtype=bool, optional
|
||||
Mask to limit the application of Canny to a certain area.
|
||||
use_quantiles : bool, optional
|
||||
If ``True`` then treat low_threshold and high_threshold as
|
||||
quantiles of the edge magnitude image, rather than absolute
|
||||
edge magnitude values. If ``True`` then the thresholds must be
|
||||
in the range [0, 1].
|
||||
mode : str, {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}
|
||||
The ``mode`` parameter determines how the array borders are
|
||||
handled during Gaussian filtering, where ``cval`` is the value when
|
||||
mode is equal to 'constant'.
|
||||
cval : float, optional
|
||||
Value to fill past edges of input if `mode` is 'constant'.
|
||||
|
||||
Returns
|
||||
-------
|
||||
output : 2D array (image)
|
||||
The binary edge map.
|
||||
|
||||
See also
|
||||
--------
|
||||
skimage.filters.sobel
|
||||
|
||||
Notes
|
||||
-----
|
||||
The steps of the algorithm are as follows:
|
||||
|
||||
* Smooth the image using a Gaussian with ``sigma`` width.
|
||||
|
||||
* Apply the horizontal and vertical Sobel operators to get the gradients
|
||||
within the image. The edge strength is the norm of the gradient.
|
||||
|
||||
* Thin potential edges to 1-pixel wide curves. First, find the normal
|
||||
to the edge at each point. This is done by looking at the
|
||||
signs and the relative magnitude of the X-Sobel and Y-Sobel
|
||||
to sort the points into 4 categories: horizontal, vertical,
|
||||
diagonal and antidiagonal. Then look in the normal and reverse
|
||||
directions to see if the values in either of those directions are
|
||||
greater than the point in question. Use interpolation to get a mix of
|
||||
points instead of picking the one that's the closest to the normal.
|
||||
|
||||
* Perform a hysteresis thresholding: first label all points above the
|
||||
high threshold as edges. Then recursively label any point above the
|
||||
low threshold that is 8-connected to a labeled point as an edge.
|
||||
|
||||
References
|
||||
----------
|
||||
.. [1] Canny, J., A Computational Approach To Edge Detection, IEEE Trans.
|
||||
Pattern Analysis and Machine Intelligence, 8:679-714, 1986
|
||||
:DOI:`10.1109/TPAMI.1986.4767851`
|
||||
.. [2] William Green's Canny tutorial
|
||||
https://en.wikipedia.org/wiki/Canny_edge_detector
|
||||
|
||||
Examples
|
||||
--------
|
||||
>>> from skimage import feature
|
||||
>>> rng = np.random.default_rng()
|
||||
>>> # Generate noisy image of a square
|
||||
>>> im = np.zeros((256, 256))
|
||||
>>> im[64:-64, 64:-64] = 1
|
||||
>>> im += 0.2 * rng.random(im.shape)
|
||||
>>> # First trial with the Canny filter, with the default smoothing
|
||||
>>> edges1 = feature.canny(im)
|
||||
>>> # Increase the smoothing for better results
|
||||
>>> edges2 = feature.canny(im, sigma=3)
|
||||
|
||||
"""
|
||||
|
||||
# Regarding masks, any point touching a masked point will have a gradient
|
||||
# that is "infected" by the masked point, so it's enough to erode the
|
||||
# mask by one and then mask the output. We also mask out the border points
|
||||
# because who knows what lies beyond the edge of the image?
|
||||
|
||||
check_nD(image, 2)
|
||||
dtype_max = dtype_limits(image, clip_negative=False)[1]
|
||||
|
||||
if low_threshold is None:
|
||||
low_threshold = 0.1
|
||||
elif use_quantiles:
|
||||
if not(0.0 <= low_threshold <= 1.0):
|
||||
raise ValueError("Quantile thresholds must be between 0 and 1.")
|
||||
else:
|
||||
low_threshold /= dtype_max
|
||||
|
||||
if high_threshold is None:
|
||||
high_threshold = 0.2
|
||||
elif use_quantiles:
|
||||
if not(0.0 <= high_threshold <= 1.0):
|
||||
raise ValueError("Quantile thresholds must be between 0 and 1.")
|
||||
else:
|
||||
high_threshold /= dtype_max
|
||||
|
||||
if high_threshold < low_threshold:
|
||||
raise ValueError("low_threshold should be lower then high_threshold")
|
||||
|
||||
# Image filtering
|
||||
smoothed, eroded_mask = _preprocess(image, mask, sigma, mode, cval)
|
||||
|
||||
# Gradient magnitude estimation
|
||||
jsobel = ndi.sobel(smoothed, axis=1)
|
||||
isobel = ndi.sobel(smoothed, axis=0)
|
||||
magnitude = isobel * isobel
|
||||
magnitude += jsobel * jsobel
|
||||
np.sqrt(magnitude, out=magnitude)
|
||||
|
||||
if use_quantiles:
|
||||
low_threshold, high_threshold = np.percentile(magnitude,
|
||||
[100.0 * low_threshold,
|
||||
100.0 * high_threshold])
|
||||
|
||||
# Non-maximum suppression
|
||||
low_masked = _nonmaximum_suppression_bilinear(
|
||||
isobel, jsobel, magnitude, eroded_mask, low_threshold
|
||||
)
|
||||
|
||||
# Double thresholding and edge tracking
|
||||
#
|
||||
# Segment the low-mask, then only keep low-segments that have
|
||||
# some high_mask component in them
|
||||
#
|
||||
low_mask = low_masked > 0
|
||||
strel = np.ones((3, 3), bool)
|
||||
labels, count = ndi.label(low_mask, strel)
|
||||
if count == 0:
|
||||
return low_mask
|
||||
|
||||
high_mask = low_mask & (low_masked >= high_threshold)
|
||||
nonzero_sums = np.unique(labels[high_mask])
|
||||
good_label = np.zeros((count + 1,), bool)
|
||||
good_label[nonzero_sums] = True
|
||||
output_mask = good_label[labels]
|
||||
return output_mask
|
||||
Reference in New Issue
Block a user