dask_image.ndfilters package

dask_image.ndfilters.convolve(input, weights, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.convolve”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multidimensional convolution.

The array is convolved with the given kernel.

Parameters:
  • input (array_like) – The input array.
  • weights (array_like) – Array of weights, same number of dimensions as input
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

result – The result of convolution of input with weights.

Return type:

ndarray

See also

correlate()
Correlate an image with a kernel.

Notes

Each value in result is \(C_i = \sum_j{I_{i+k-j} W_j}\), where W is the weights kernel, j is the n-D spatial index over \(W\), I is the input and k is the coordinate of the center of W, specified by origin in the input parameters.

Examples

Perhaps the simplest case to understand is mode='constant', cval=0.0, because in this case borders (i.e. where the weights kernel, centered on any one value, extends beyond an edge of input.

>>> a = np.array([[1, 2, 0, 0],
...               [5, 3, 0, 4],
...               [0, 0, 0, 7],
...               [9, 3, 0, 0]])
>>> k = np.array([[1,1,1],[1,1,0],[1,0,0]])
>>> from scipy import ndimage
>>> ndimage.convolve(a, k, mode='constant', cval=0.0)
array([[11, 10,  7,  4],
       [10,  3, 11, 11],
       [15, 12, 14,  7],
       [12,  3,  7,  0]])

Setting cval=1.0 is equivalent to padding the outer edge of input with 1.0’s (and then extracting only the original region of the result).

>>> ndimage.convolve(a, k, mode='constant', cval=1.0)
array([[13, 11,  8,  7],
       [11,  3, 11, 14],
       [16, 12, 14, 10],
       [15,  6, 10,  5]])

With mode='reflect' (the default), outer values are reflected at the edge of input to fill in missing values.

>>> b = np.array([[2, 0, 0],
...               [1, 0, 0],
...               [0, 0, 0]])
>>> k = np.array([[0,1,0], [0,1,0], [0,1,0]])
>>> ndimage.convolve(b, k, mode='reflect')
array([[5, 0, 0],
       [3, 0, 0],
       [1, 0, 0]])

This includes diagonally at the corners.

>>> k = np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> ndimage.convolve(b, k)
array([[4, 2, 0],
       [3, 2, 0],
       [1, 1, 0]])

With mode='nearest', the single nearest value in to an edge in input is repeated as many times as needed to match the overlapping weights.

>>> c = np.array([[2, 0, 1],
...               [1, 0, 0],
...               [0, 0, 0]])
>>> k = np.array([[0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0]])
>>> ndimage.convolve(c, k, mode='nearest')
array([[7, 0, 3],
       [5, 0, 2],
       [3, 0, 1]])
dask_image.ndfilters.correlate(input, weights, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.correlate”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multi-dimensional correlation.

The array is correlated with the given kernel.

Parameters:
  • input (array_like) – The input array.
  • weights (ndarray) – array of weights, same number of dimensions as input
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.

See also

convolve()
Convolve an image with a kernel.
dask_image.ndfilters.gaussian_filter(input, sigma, order=0, mode='reflect', cval=0.0, truncate=4.0)

Wrapped copy of “scipy.ndimage.filters.gaussian_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multidimensional Gaussian filter.

Parameters:
  • input (array_like) – The input array.
  • 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.
  • order (int or sequence of ints, optional) – The order of the filter along each axis is given as a sequence of integers, or as a single number. An order of 0 corresponds to convolution with a Gaussian kernel. A positive order corresponds to convolution with that derivative of a Gaussian.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • truncate (float) – Truncate the filter at this many standard deviations. Default is 4.0.
Returns:

gaussian_filter – Returned array of same shape as input.

Return type:

ndarray

Notes

The multidimensional 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.

Examples

>>> from scipy.ndimage import gaussian_filter
>>> a = np.arange(50, step=2).reshape((5,5))
>>> a
array([[ 0,  2,  4,  6,  8],
       [10, 12, 14, 16, 18],
       [20, 22, 24, 26, 28],
       [30, 32, 34, 36, 38],
       [40, 42, 44, 46, 48]])
>>> gaussian_filter(a, sigma=1)
array([[ 4,  6,  8,  9, 11],
       [10, 12, 14, 15, 17],
       [20, 22, 24, 25, 27],
       [29, 31, 33, 34, 36],
       [35, 37, 39, 40, 42]])
>>> from scipy import misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = gaussian_filter(ascent, sigma=5)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.gaussian_gradient_magnitude(input, sigma, mode='reflect', cval=0.0, truncate=4.0, **kwargs)

Wrapped copy of “scipy.ndimage.filters.gaussian_gradient_magnitude”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multidimensional gradient magnitude using Gaussian derivatives.

Parameters:
  • input (array_like) – The input array.
  • sigma (scalar or sequence of scalars) – 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 or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • keyword arguments will be passed to gaussian_filter() (Extra) –
Returns:

gaussian_gradient_magnitude – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.gaussian_gradient_magnitude(ascent, sigma=5)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.gaussian_laplace(input, sigma, mode='reflect', cval=0.0, truncate=4.0, **kwargs)

Wrapped copy of “scipy.ndimage.filters.gaussian_laplace”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multidimensional Laplace filter using gaussian second derivatives.

Parameters:
  • input (array_like) – The input array.
  • sigma (scalar or sequence of scalars) – 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 or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • keyword arguments will be passed to gaussian_filter() (Extra) –

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> ascent = misc.ascent()
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> result = ndimage.gaussian_laplace(ascent, sigma=1)
>>> ax1.imshow(result)
>>> result = ndimage.gaussian_laplace(ascent, sigma=3)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.generic_filter(input, function, size=None, footprint=None, mode='reflect', cval=0.0, origin=0, extra_arguments=(), extra_keywords={})

Wrapped copy of “scipy.ndimage.filters.generic_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multi-dimensional filter using the given function.

At each element the provided function is called. The input values within the filter footprint at that element are passed to the function as a 1D array of double values.

Parameters:
  • input (array_like) – The input array.
  • function ({callable, scipy.LowLevelCallable}) – Function to apply at each element.
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
  • extra_arguments (sequence, optional) – Sequence of extra positional arguments to pass to passed function.
  • extra_keywords (dict, optional) – dict of extra keyword arguments to pass to passed function.

Notes

This function also accepts low-level callback functions with one of the following signatures and wrapped in scipy.LowLevelCallable:

int callback(double *buffer, npy_intp filter_size,
             double *return_value, void *user_data)
int callback(double *buffer, intptr_t filter_size,
             double *return_value, void *user_data)

The calling function iterates over the elements of the input and output arrays, calling the callback function at each element. The elements within the footprint of the filter at the current element are passed through the buffer parameter, and the number of elements within the footprint through filter_size. The calculated value is returned in return_value. user_data is the data pointer provided to scipy.LowLevelCallable as-is.

The callback function must return an integer error status that is zero if something went wrong and one otherwise. If an error occurs, you should normally set the python error status with an informative message before returning, otherwise a default error message is set by the calling function.

In addition, some other low-level function pointer specifications are accepted, but these are for backward compatibility only and should not be used in new code.

dask_image.ndfilters.laplace(input, mode='reflect', cval=0.0)

Wrapped copy of “scipy.ndimage.filters.laplace”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

N-dimensional Laplace filter based on approximate second derivatives.

Parameters:
  • input (array_like) – The input array.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.laplace(ascent)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.maximum_filter(input, size=None, footprint=None, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.maximum_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multi-dimensional maximum filter.

Parameters:
  • input (array_like) – The input array.
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

maximum_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.maximum_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.median_filter(input, size=None, footprint=None, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.median_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multidimensional median filter.

Parameters:
  • input (array_like) – The input array.
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

median_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.median_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.minimum_filter(input, size=None, footprint=None, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.minimum_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multi-dimensional minimum filter.

Parameters:
  • input (array_like) – The input array.
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

minimum_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.minimum_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.percentile_filter(input, percentile, size=None, footprint=None, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.percentile_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multi-dimensional percentile filter.

Parameters:
  • input (array_like) – The input array.
  • percentile (scalar) – The percentile parameter may be less then zero, i.e., percentile = -20 equals percentile = 80
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

percentile_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.percentile_filter(ascent, percentile=20, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.prewitt(input, axis=-1, mode='reflect', cval=0.0)

Wrapped copy of “scipy.ndimage.filters.prewitt”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a Prewitt filter.

Parameters:
  • input (array_like) – The input array.
  • axis (int, optional) – The axis of input along which to calculate. Default is -1.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.prewitt(ascent)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.rank_filter(input, rank, size=None, footprint=None, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.rank_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a multi-dimensional rank filter.

Parameters:
  • input (array_like) – The input array.
  • rank (int) – The rank parameter may be less then zero, i.e., rank = -1 indicates the largest element.
  • size (scalar or tuple, optional) – See footprint, below. Ignored if footprint is given.
  • footprint (array, optional) – Either size or footprint must be defined. size gives the shape that is taken from the input array, at every element position, to define the input to the filter function. footprint is a boolean array that specifies (implicitly) a shape, but also which of the elements within this shape will get passed to the filter function. Thus size=(n,m) is equivalent to footprint=np.ones((n,m)). We adjust size to the number of dimensions of the input array, so that, if the input array is shape (10,10,10), and size is 2, then the actual size used is (2,2,2). When footprint is given, size is ignored.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

rank_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.rank_filter(ascent, rank=42, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.sobel(input, axis=-1, mode='reflect', cval=0.0)

Wrapped copy of “scipy.ndimage.filters.sobel”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Calculate a Sobel filter.

Parameters:
  • input (array_like) – The input array.
  • axis (int, optional) – The axis of input along which to calculate. Default is -1.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.sobel(ascent)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
dask_image.ndfilters.uniform_filter(input, size=3, mode='reflect', cval=0.0, origin=0)

Wrapped copy of “scipy.ndimage.filters.uniform_filter”

Excludes the output parameter as it would not work with Dask arrays.

Original docstring:

Multi-dimensional uniform filter.

Parameters:
  • input (array_like) – The input array.
  • size (int or sequence of ints, optional) – The sizes of the uniform filter are given for each axis as a sequence, or as a single number, in which case the size is equal for all axes.
  • mode (str or sequence, optional) –

    The mode parameter determines how the input array is extended when the filter overlaps a border. By passing a sequence of modes with length equal to the number of dimensions of the input array, different modes can be specified along each axis. Default value is ‘reflect’. The valid values and their behavior is as follows:

    ’reflect’ (d c b a | a b c d | d c b a)
    The input is extended by reflecting about the edge of the last pixel.
    ’constant’ (k k k k | a b c d | k k k k)
    The input is extended by filling all values beyond the edge with the same constant value, defined by the cval parameter.
    ’nearest’ (a a a a | a b c d | d d d d)
    The input is extended by replicating the last pixel.
    ’mirror’ (d c b | a b c d | c b a)
    The input is extended by reflecting about the center of the last pixel.
    ’wrap’ (a b c d | a b c d | a b c d)
    The input is extended by wrapping around to the opposite edge.
  • cval (scalar, optional) – Value to fill past edges of input if mode is ‘constant’. Default is 0.0.
  • origin (int or sequence, optional) – Controls the placement of the filter on the input array’s pixels. A value of 0 (the default) centers the filter over the pixel, with positive values shifting the filter to the left, and negative ones to the right. By passing a sequence of origins with length equal to the number of dimensions of the input array, different shifts can be specified along each axis.
Returns:

uniform_filter – Filtered array. Has the same shape as input.

Return type:

ndarray

Notes

The multi-dimensional filter is implemented as a sequence of one-dimensional uniform 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.

Examples

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.uniform_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()