Coverage for /usr/lib/python3/dist-packages/scipy/ndimage/filters.py : 24%

# Copyright (C) 2003-2005 Peter J. Verveer 

# 

# Redistribution and use in source and binary forms, with or without 

# modification, are permitted provided that the following conditions 

# are met: 

# 

# 1. Redistributions of source code must retain the above copyright 

# notice, this list of conditions and the following disclaimer. 

# 

# 2. Redistributions in binary form must reproduce the above 

# copyright notice, this list of conditions and the following 

# disclaimer in the documentation and/or other materials provided 

# with the distribution. 

# 

# 3. The name of the author may not be used to endorse or promote 

# products derived from this software without specific prior 

# written permission. 

# 

# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS 

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 

# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 

# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 

# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 

# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 

# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 

# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 

# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

from __future__ import division, print_function, absolute_import 

import warnings 

import math 

import numpy 

from . import _ni_support 

from . import _nd_image 

from . import _ni_docstrings 

from scipy.misc import doccer 

from scipy._lib._version import NumpyVersion 

__all__ = ['correlate1d', 'convolve1d', 'gaussian_filter1d', 'gaussian_filter', 

'prewitt', 'sobel', 'generic_laplace', 'laplace', 

'gaussian_laplace', 'generic_gradient_magnitude', 

'gaussian_gradient_magnitude', 'correlate', 'convolve', 

'uniform_filter1d', 'uniform_filter', 'minimum_filter1d', 

'maximum_filter1d', 'minimum_filter', 'maximum_filter', 

'rank_filter', 'median_filter', 'percentile_filter', 

'generic_filter1d', 'generic_filter'] 

@_ni_docstrings.docfiller 

def correlate1d(input, weights, axis=-1, output=None, mode="reflect", 

cval=0.0, origin=0): 

"""Calculate a one-dimensional correlation along the given axis. 

The lines of the array along the given axis are correlated with the 

given weights. 

Parameters 

---------- 

%(input)s 

weights : array 

One-dimensional sequence of numbers. 

%(axis)s 

%(output)s 

%(mode)s 

%(cval)s 

%(origin)s 

Examples 

-------- 

>>> from scipy.ndimage import correlate1d 

>>> correlate1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 3]) 

array([ 8, 26, 8, 12, 7, 28, 36, 9]) 

""" 

input = numpy.asarray(input) 

if numpy.iscomplexobj(input): 

raise TypeError('Complex type not supported') 

output = _ni_support._get_output(output, input) 

weights = numpy.asarray(weights, dtype=numpy.float64) 

if weights.ndim != 1 or weights.shape[0] < 1: 

raise RuntimeError('no filter weights given') 

if not weights.flags.contiguous: 

weights = weights.copy() 

axis = _ni_support._check_axis(axis, input.ndim) 

if (len(weights) // 2 + origin < 0) or (len(weights) // 2 + 

origin > len(weights)): 

raise ValueError('invalid origin') 

mode = _ni_support._extend_mode_to_code(mode) 

_nd_image.correlate1d(input, weights, axis, output, mode, cval, 

origin) 

return output 

@_ni_docstrings.docfiller 

def convolve1d(input, weights, axis=-1, output=None, mode="reflect", 

cval=0.0, origin=0): 

"""Calculate a one-dimensional convolution along the given axis. 

The lines of the array along the given axis are convolved with the 

given weights. 

Parameters 

---------- 

%(input)s 

weights : ndarray 

One-dimensional sequence of numbers. 

%(axis)s 

%(output)s 

%(mode)s 

%(cval)s 

%(origin)s 

Returns 

------- 

convolve1d : ndarray 

Convolved array with same shape as input 

Examples 

-------- 

>>> from scipy.ndimage import convolve1d 

>>> convolve1d([2, 8, 0, 4, 1, 9, 9, 0], weights=[1, 3]) 

array([14, 24, 4, 13, 12, 36, 27, 0]) 

""" 

weights = weights[::-1] 

origin = -origin 

if not len(weights) & 1: 

origin -= 1 

return correlate1d(input, weights, axis, output, mode, cval, origin) 

def _gaussian_kernel1d(sigma, order, radius): 

""" 

Computes a 1D Gaussian convolution kernel. 

""" 

if order < 0: 

raise ValueError('order must be non-negative') 

p = numpy.polynomial.Polynomial([0, 0, -0.5 / (sigma * sigma)]) 

x = numpy.arange(-radius, radius + 1) 

phi_x = numpy.exp(p(x), dtype=numpy.double) 

phi_x /= phi_x.sum() 

if order > 0: 

q = numpy.polynomial.Polynomial([1]) 

p_deriv = p.deriv() 

for _ in range(order): 

# f(x) = q(x) * phi(x) = q(x) * exp(p(x)) 

# f'(x) = (q'(x) + q(x) * p'(x)) * phi(x) 

q = q.deriv() + q * p_deriv 

phi_x *= q(x) 

return phi_x 

@_ni_docstrings.docfiller 

def gaussian_filter1d(input, sigma, axis=-1, order=0, output=None, 

mode="reflect", cval=0.0, truncate=4.0): 

"""One-dimensional Gaussian filter. 

Parameters 

---------- 

%(input)s 

sigma : scalar 

standard deviation for Gaussian kernel 

%(axis)s 

order : int, optional 

An order of 0 corresponds to convolution with a Gaussian 

kernel. A positive order corresponds to convolution with 

that derivative of a Gaussian. 

%(output)s 

%(mode)s 

%(cval)s 

truncate : float, optional 

Truncate the filter at this many standard deviations. 

Default is 4.0. 

Returns 

------- 

gaussian_filter1d : ndarray 

Examples 

-------- 

>>> from scipy.ndimage import gaussian_filter1d 

>>> gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 1) 

array([ 1.42704095, 2.06782203, 3. , 3.93217797, 4.57295905]) 

>>> gaussian_filter1d([1.0, 2.0, 3.0, 4.0, 5.0], 4) 

array([ 2.91948343, 2.95023502, 3. , 3.04976498, 3.08051657]) 

>>> import matplotlib.pyplot as plt 

>>> np.random.seed(280490) 

>>> x = np.random.randn(101).cumsum() 

>>> y3 = gaussian_filter1d(x, 3) 

>>> y6 = gaussian_filter1d(x, 6) 

>>> plt.plot(x, 'k', label='original data') 

>>> plt.plot(y3, '--', label='filtered, sigma=3') 

>>> plt.plot(y6, ':', label='filtered, sigma=6') 

>>> plt.legend() 

>>> plt.grid() 

>>> plt.show() 

""" 

sd = float(sigma) 

# make the radius of the filter equal to truncate standard deviations 

lw = int(truncate * sd + 0.5) 

# Since we are calling correlate, not convolve, revert the kernel 

weights = _gaussian_kernel1d(sigma, order, lw)[::-1] 

return correlate1d(input, weights, axis, output, mode, cval, 0) 

@_ni_docstrings.docfiller 

def gaussian_filter(input, sigma, order=0, output=None, 

mode="reflect", cval=0.0, truncate=4.0): 

"""Multidimensional Gaussian filter. 

Parameters 

---------- 

%(input)s 

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. 

%(output)s 

%(mode_multiple)s 

%(cval)s 

truncate : float 

Truncate the filter at this many standard deviations. 

Default is 4.0. 

Returns 

------- 

gaussian_filter : ndarray 

Returned array of same shape as `input`. 

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() 

""" 

input = numpy.asarray(input) 

output = _ni_support._get_output(output, input) 

orders = _ni_support._normalize_sequence(order, input.ndim) 

sigmas = _ni_support._normalize_sequence(sigma, input.ndim) 

modes = _ni_support._normalize_sequence(mode, input.ndim) 

axes = list(range(input.ndim)) 

axes = [(axes[ii], sigmas[ii], orders[ii], modes[ii]) 

for ii in range(len(axes)) if sigmas[ii] > 1e-15] 

if len(axes) > 0: 

for axis, sigma, order, mode in axes: 

gaussian_filter1d(input, sigma, axis, order, output, 

mode, cval, truncate) 

input = output 

else: 

output[...] = input[...] 

return output 

@_ni_docstrings.docfiller 

def prewitt(input, axis=-1, output=None, mode="reflect", cval=0.0): 

"""Calculate a Prewitt filter. 

Parameters 

---------- 

%(input)s 

%(axis)s 

%(output)s 

%(mode_multiple)s 

%(cval)s 

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() 

""" 

input = numpy.asarray(input) 

axis = _ni_support._check_axis(axis, input.ndim) 

output = _ni_support._get_output(output, input) 

modes = _ni_support._normalize_sequence(mode, input.ndim) 

correlate1d(input, [-1, 0, 1], axis, output, modes[axis], cval, 0) 

axes = [ii for ii in range(input.ndim) if ii != axis] 

for ii in axes: 

correlate1d(output, [1, 1, 1], ii, output, modes[ii], cval, 0,) 

return output 

@_ni_docstrings.docfiller 

def sobel(input, axis=-1, output=None, mode="reflect", cval=0.0): 

"""Calculate a Sobel filter. 

Parameters 

---------- 

%(input)s 

%(axis)s 

%(output)s 

%(mode_multiple)s 

%(cval)s 

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() 

""" 

input = numpy.asarray(input) 

axis = _ni_support._check_axis(axis, input.ndim) 

output = _ni_support._get_output(output, input) 

modes = _ni_support._normalize_sequence(mode, input.ndim) 

correlate1d(input, [-1, 0, 1], axis, output, modes[axis], cval, 0) 

axes = [ii for ii in range(input.ndim) if ii != axis] 

for ii in axes: 

correlate1d(output, [1, 2, 1], ii, output, modes[ii], cval, 0) 

return output 

@_ni_docstrings.docfiller 

def generic_laplace(input, derivative2, output=None, mode="reflect", 

cval=0.0, 

extra_arguments=(), 

extra_keywords=None): 

""" 

N-dimensional Laplace filter using a provided second derivative function. 

Parameters 

---------- 

%(input)s 

derivative2 : callable 

Callable with the following signature:: 

derivative2(input, axis, output, mode, cval, 

*extra_arguments, **extra_keywords) 

See `extra_arguments`, `extra_keywords` below. 

%(output)s 

%(mode_multiple)s 

%(cval)s 

%(extra_keywords)s 

%(extra_arguments)s 

""" 

if extra_keywords is None: 

extra_keywords = {} 

input = numpy.asarray(input) 

output = _ni_support._get_output(output, input) 

axes = list(range(input.ndim)) 

if len(axes) > 0: 

modes = _ni_support._normalize_sequence(mode, len(axes)) 

derivative2(input, axes[0], output, modes[0], cval, 

*extra_arguments, **extra_keywords) 

for ii in range(1, len(axes)): 

tmp = derivative2(input, axes[ii], output.dtype, modes[ii], cval, 

*extra_arguments, **extra_keywords) 

output += tmp 

else: 

output[...] = input[...] 

return output 

@_ni_docstrings.docfiller 

def laplace(input, output=None, mode="reflect", cval=0.0): 

"""N-dimensional Laplace filter based on approximate second derivatives. 

Parameters 

---------- 

%(input)s 

%(output)s 

%(mode_multiple)s 

%(cval)s 

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() 

""" 

def derivative2(input, axis, output, mode, cval): 

return correlate1d(input, [1, -2, 1], axis, output, mode, cval, 0) 

return generic_laplace(input, derivative2, output, mode, cval) 

@_ni_docstrings.docfiller 

def gaussian_laplace(input, sigma, output=None, mode="reflect", 

cval=0.0, **kwargs): 

"""Multidimensional Laplace filter using gaussian second derivatives. 

Parameters 

---------- 

%(input)s 

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. 

%(output)s 

%(mode_multiple)s 

%(cval)s 

Extra keyword arguments will be passed to gaussian_filter(). 

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() 

""" 

input = numpy.asarray(input) 

def derivative2(input, axis, output, mode, cval, sigma, **kwargs): 

order = [0] * input.ndim 

order[axis] = 2 

return gaussian_filter(input, sigma, order, output, mode, cval, 

**kwargs) 

return generic_laplace(input, derivative2, output, mode, cval, 

extra_arguments=(sigma,), 

extra_keywords=kwargs) 

@_ni_docstrings.docfiller 

def generic_gradient_magnitude(input, derivative, output=None, 

mode="reflect", cval=0.0, 

extra_arguments=(), extra_keywords=None): 

"""Gradient magnitude using a provided gradient function. 

Parameters 

---------- 

%(input)s 

derivative : callable 

Callable with the following signature:: 

derivative(input, axis, output, mode, cval, 

*extra_arguments, **extra_keywords) 

See `extra_arguments`, `extra_keywords` below. 

`derivative` can assume that `input` and `output` are ndarrays. 

Note that the output from `derivative` is modified inplace; 

be careful to copy important inputs before returning them. 

%(output)s 

%(mode_multiple)s 

%(cval)s 

%(extra_keywords)s 

%(extra_arguments)s 

""" 

if extra_keywords is None: 

extra_keywords = {} 

input = numpy.asarray(input) 

output = _ni_support._get_output(output, input) 

axes = list(range(input.ndim)) 

if len(axes) > 0: 

modes = _ni_support._normalize_sequence(mode, len(axes)) 

derivative(input, axes[0], output, modes[0], cval, 

*extra_arguments, **extra_keywords) 

numpy.multiply(output, output, output) 

for ii in range(1, len(axes)): 

tmp = derivative(input, axes[ii], output.dtype, modes[ii], cval, 

*extra_arguments, **extra_keywords) 

numpy.multiply(tmp, tmp, tmp) 

output += tmp 

# This allows the sqrt to work with a different default casting 

numpy.sqrt(output, output, casting='unsafe') 

else: 

output[...] = input[...] 

return output 

@_ni_docstrings.docfiller 

def gaussian_gradient_magnitude(input, sigma, output=None, 

mode="reflect", cval=0.0, **kwargs): 

"""Multidimensional gradient magnitude using Gaussian derivatives. 

Parameters 

---------- 

%(input)s 

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

%(output)s 

%(mode_multiple)s 

%(cval)s 

Extra keyword arguments will be passed to gaussian_filter(). 

Returns 

------- 

gaussian_gradient_magnitude : ndarray 

Filtered array. Has the same shape as `input`. 

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() 

""" 

input = numpy.asarray(input) 

def derivative(input, axis, output, mode, cval, sigma, **kwargs): 

order = [0] * input.ndim 

order[axis] = 1 

return gaussian_filter(input, sigma, order, output, mode, 

cval, **kwargs) 

return generic_gradient_magnitude(input, derivative, output, mode, 

cval, extra_arguments=(sigma,), 

extra_keywords=kwargs) 

def _correlate_or_convolve(input, weights, output, mode, cval, origin, 

convolution): 

input = numpy.asarray(input) 

if numpy.iscomplexobj(input): 

raise TypeError('Complex type not supported') 

origins = _ni_support._normalize_sequence(origin, input.ndim) 

weights = numpy.asarray(weights, dtype=numpy.float64) 

wshape = [ii for ii in weights.shape if ii > 0] 

if len(wshape) != input.ndim: 

raise RuntimeError('filter weights array has incorrect shape.') 

if convolution: 

weights = weights[tuple([slice(None, None, -1)] * weights.ndim)] 

for ii in range(len(origins)): 

origins[ii] = -origins[ii] 

if not weights.shape[ii] & 1: 

origins[ii] -= 1 

for origin, lenw in zip(origins, wshape): 

if (lenw // 2 + origin < 0) or (lenw // 2 + origin > lenw): 

raise ValueError('invalid origin') 

if not weights.flags.contiguous: 

weights = weights.copy() 

output = _ni_support._get_output(output, input) 

mode = _ni_support._extend_mode_to_code(mode) 

_nd_image.correlate(input, weights, output, mode, cval, origins) 

return output 

@_ni_docstrings.docfiller 

def correlate(input, weights, output=None, mode='reflect', cval=0.0, 

origin=0): 

""" 

Multi-dimensional correlation. 

The array is correlated with the given kernel. 

Parameters 

---------- 

%(input)s 

weights : ndarray 

array of weights, same number of dimensions as input 

%(output)s 

%(mode_multiple)s 

%(cval)s 

%(origin_multiple)s 

See Also 

-------- 

convolve : Convolve an image with a kernel. 

""" 

return _correlate_or_convolve(input, weights, output, mode, cval, 

origin, False) 

@_ni_docstrings.docfiller 

def convolve(input, weights, output=None, mode='reflect', cval=0.0, 

origin=0): 

""" 

Multidimensional convolution. 

The array is convolved with the given kernel. 

Parameters 

---------- 

%(input)s 

weights : array_like 

Array of weights, same number of dimensions as input 

%(output)s 

%(mode_multiple)s 

cval : scalar, optional 

Value to fill past edges of input if `mode` is 'constant'. Default 

is 0.0 

%(origin_multiple)s 

Returns 

------- 

result : ndarray 

The result of convolution of `input` with `weights`. 

See Also 

-------- 

correlate : Correlate an image with a kernel. 

Notes 

----- 

Each value in result is :math:`C_i = \\sum_j{I_{i+k-j} W_j}`, where 

W is the `weights` kernel, 

j is the n-D spatial index over :math:`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]]) 

""" 

return _correlate_or_convolve(input, weights, output, mode, cval, 

origin, True) 

@_ni_docstrings.docfiller 

def uniform_filter1d(input, size, axis=-1, output=None, 

mode="reflect", cval=0.0, origin=0): 

"""Calculate a one-dimensional uniform filter along the given axis. 

The lines of the array along the given axis are filtered with a 

uniform filter of given size. 

Parameters 

---------- 

%(input)s 

size : int 

length of uniform filter 

%(axis)s 

%(output)s 

%(mode)s 

%(cval)s 

%(origin)s 

Examples 

-------- 

>>> from scipy.ndimage import uniform_filter1d 

>>> uniform_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) 

array([4, 3, 4, 1, 4, 6, 6, 3]) 

""" 

input = numpy.asarray(input) 

if numpy.iscomplexobj(input): 

raise TypeError('Complex type not supported') 

axis = _ni_support._check_axis(axis, input.ndim) 

if size < 1: 

raise RuntimeError('incorrect filter size') 

output = _ni_support._get_output(output, input) 

if (size // 2 + origin < 0) or (size // 2 + origin >= size): 

raise ValueError('invalid origin') 

mode = _ni_support._extend_mode_to_code(mode) 

_nd_image.uniform_filter1d(input, size, axis, output, mode, cval, 

origin) 

return output 

@_ni_docstrings.docfiller 

def uniform_filter(input, size=3, output=None, mode="reflect", 

cval=0.0, origin=0): 

"""Multi-dimensional uniform filter. 

Parameters 

---------- 

%(input)s 

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. 

%(output)s 

%(mode_multiple)s 

%(cval)s 

%(origin_multiple)s 

Returns 

------- 

uniform_filter : ndarray 

Filtered array. Has the same shape as `input`. 

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() 

""" 

input = numpy.asarray(input) 

output = _ni_support._get_output(output, input) 

sizes = _ni_support._normalize_sequence(size, input.ndim) 

origins = _ni_support._normalize_sequence(origin, input.ndim) 

modes = _ni_support._normalize_sequence(mode, input.ndim) 

axes = list(range(input.ndim)) 

axes = [(axes[ii], sizes[ii], origins[ii], modes[ii]) 

for ii in range(len(axes)) if sizes[ii] > 1] 

if len(axes) > 0: 

for axis, size, origin, mode in axes: 

uniform_filter1d(input, int(size), axis, output, mode, 

cval, origin) 

input = output 

else: 

output[...] = input[...] 

return output 

@_ni_docstrings.docfiller 

def minimum_filter1d(input, size, axis=-1, output=None, 

mode="reflect", cval=0.0, origin=0): 

"""Calculate a one-dimensional minimum filter along the given axis. 

The lines of the array along the given axis are filtered with a 

minimum filter of given size. 

Parameters 

---------- 

%(input)s 

size : int 

length along which to calculate 1D minimum 

%(axis)s 

%(output)s 

%(mode)s 

%(cval)s 

%(origin)s 

Notes 

----- 

This function implements the MINLIST algorithm [1]_, as described by 

Richard Harter [2]_, and has a guaranteed O(n) performance, `n` being 

the `input` length, regardless of filter size. 

References 

---------- 

.. [1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777 

.. [2] http://www.richardhartersworld.com/cri/2001/slidingmin.html 

Examples 

-------- 

>>> from scipy.ndimage import minimum_filter1d 

>>> minimum_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) 

array([2, 0, 0, 0, 1, 1, 0, 0]) 

""" 

input = numpy.asarray(input) 

if numpy.iscomplexobj(input): 

raise TypeError('Complex type not supported') 

axis = _ni_support._check_axis(axis, input.ndim) 

if size < 1: 

raise RuntimeError('incorrect filter size') 

output = _ni_support._get_output(output, input) 

if (size // 2 + origin < 0) or (size // 2 + origin >= size): 

raise ValueError('invalid origin') 

mode = _ni_support._extend_mode_to_code(mode) 

_nd_image.min_or_max_filter1d(input, size, axis, output, mode, cval, 

origin, 1) 

return output 

@_ni_docstrings.docfiller 

def maximum_filter1d(input, size, axis=-1, output=None, 

mode="reflect", cval=0.0, origin=0): 

"""Calculate a one-dimensional maximum filter along the given axis. 

The lines of the array along the given axis are filtered with a 

maximum filter of given size. 

Parameters 

---------- 

%(input)s 

size : int 

Length along which to calculate the 1-D maximum. 

%(axis)s 

%(output)s 

%(mode)s 

%(cval)s 

%(origin)s 

Returns 

------- 

maximum1d : ndarray, None 

Maximum-filtered array with same shape as input. 

None if `output` is not None 

Notes 

----- 

This function implements the MAXLIST algorithm [1]_, as described by 

Richard Harter [2]_, and has a guaranteed O(n) performance, `n` being 

the `input` length, regardless of filter size. 

References 

---------- 

.. [1] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777 

.. [2] http://www.richardhartersworld.com/cri/2001/slidingmin.html 

Examples 

-------- 

>>> from scipy.ndimage import maximum_filter1d 

>>> maximum_filter1d([2, 8, 0, 4, 1, 9, 9, 0], size=3) 

array([8, 8, 8, 4, 9, 9, 9, 9]) 

""" 

input = numpy.asarray(input) 

if numpy.iscomplexobj(input): 

raise TypeError('Complex type not supported') 

axis = _ni_support._check_axis(axis, input.ndim) 

if size < 1: 

raise RuntimeError('incorrect filter size') 

output = _ni_support._get_output(output, input) 

if (size // 2 + origin < 0) or (size // 2 + origin >= size): 

raise ValueError('invalid origin') 

mode = _ni_support._extend_mode_to_code(mode) 

_nd_image.min_or_max_filter1d(input, size, axis, output, mode, cval, 

origin, 0)