Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
out : ndarray, optional
output array. If used, this must be a C-array of the same ``dtype`` as
``A``. Otherwise, a new array is allocated.
Returns
-------
erosion : ndarray
eroded version of ``A``
See Also
--------
dilate
'''
_verify_is_integer_type(A,'erode')
Bc = get_structuring_elem(A,Bc)
output = _get_output(A, out, 'erode', output=output)
return _morph.erode(A, Bc, output)
----------
labeled : ndarray of integer type
input labeled array
Bc : structure element, optional
out : ndarray of same shape as `labeled`, dtype=bool, optional
where to store the output. If ``None``, a new array is allocated
mode : {'reflect', 'nearest', 'wrap', 'mirror', 'constant' [default], 'ignore'}
How to handle borders
Returns
-------
border_img : boolean ndarray
Pixels are True exactly where there is a border in `labeled`
'''
Bc = get_structuring_elem(labeled, Bc)
output = _get_output(labeled, out, 'labeled.borders', bool, output=output)
output.fill(False)
return _labeled.borders(labeled, Bc, output, _checked_mode2int(mode, 0.0, 'borders'))
Returns
-------
filtered : ndarray
Filtered version of `array`
Notes
-----
The multi-dimensional filter is implemented as a sequence of
one-dimensional convolution filters. The intermediate arrays are
stored in the same data type as the output. Therefore, for output
types with a limited precision, the results may be imprecise
because intermediate results may be stored with insufficient
precision.
"""
array = _as_floating_point_array(array)
output = _get_output(array, out, 'gaussian_filter', output=output)
orders = _normalize_sequence(array, order, 'gaussian_filter')
sigmas = _normalize_sequence(array, sigma, 'gaussian_filter')
output[...] = array[...]
noutput = None
for axis in range(array.ndim):
sigma = sigmas[axis]
order = orders[axis]
noutput = gaussian_filter1d(output, sigma, axis, order, mode, cval, noutput)
output,noutput = noutput,output
return output
Parameters
----------
a : ndarray
b : ndarray
out : ndarray, optional
Pass ``a`` as output to subtract in-place.
Returns
-------
c : ndarray
Result of subtraction
'''
if a.dtype != b.dtype:
raise ValueError('mahotas.subm: This is only well-defined if both arguments are of the same type')
out = _get_output(a, out, 'subm')
if out is not a:
out[:] = a
return _morph.subm(out, b)
0 0 0 0 0
0 0 2 0 0
0 0 2 0 0
0 0 3 0 0
0 0 3 0 0
0 0 0 0 0
The top 2 is a local maximum because it has the maximal value in its
neighbourhood, but it is not a regional maximum.
locmin : function
Local minima
'''
Bc = get_structuring_elem(f, Bc)
output = _get_output(f, out, 'locmax', np.bool_, output=output)
Bc = _remove_centre(Bc.copy())
return _morph.locmin_max(f, Bc, output, False)
``A``. Otherwise, a new array is allocated.
output : deprecated
Do not use
Returns
-------
dilated : ndarray
dilated version of ``A``
See Also
--------
erode
'''
_verify_is_integer_type(A, 'dilate')
Bc = get_structuring_elem(A,Bc)
output = _get_output(A, out, 'dilate', output=output)
return _morph.dilate(A, Bc, output)
with a limited precision, the results may be imprecise because
intermediate results may be stored with insufficient precision.
"""
array = _check_interpolate(array, order, 'spline_filter')
if isinstance(out, type): # pragma: no cover
import warnings
warnings.warn('mahotas.interpolate.spline_filter: Use `dtype` for type instead of `out`', DeprecationWarning)
dtype = out
out = None
if isinstance(output, type): # pragma: no cover
import warnings
warnings.warn('mahotas.interpolate.spline_filter: Use `dtype` for type instead of `output`', DeprecationWarning)
dtype = output
output = None
output = internal._get_output(array, out, 'interpolate.spline_filter', dtype=dtype, output=output)
output[...] = array
for axis in range(array.ndim):
_interpolate.spline_filter1d(output, order, axis)
return output
img : ndarray
input img (currently only 2-D images accepted)
N : int, optional
size of filter (must be odd integer), defaults to 3.
out : ndarray, optional
Used for output. Must be Boolean ndarray of same size as `img`
output : deprecated
Do not use
Returns
-------
filtered : ndarray
boolean image of same size as img.
'''
img = np.asanyarray(img, dtype=np.bool_)
output = _get_output(img, out, 'majority_filter', np.bool_, output=output)
if N <= 1:
raise ValueError('mahotas.majority_filter: filter size must be positive')
if not N&1:
import warnings
warnings.warn('mahotas.majority_filter: size argument must be odd. Adding 1.')
N += 1
return _morph.majority_filter(img, N, output)