# `ndimage.filters`¶

## Module Contents¶

### Functions¶

 `correlate1d`(input,weights,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a one-dimensional correlation along the given axis. `convolve1d`(input,weights,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a one-dimensional convolution along the given axis. `_gaussian_kernel1d`(sigma,order,radius) Computes a 1D Gaussian convolution kernel. `gaussian_filter1d`(input,sigma,axis=None,order=0,output=None,mode=”reflect”,cval=0.0,truncate=4.0) One-dimensional Gaussian filter. `gaussian_filter`(input,sigma,order=0,output=None,mode=”reflect”,cval=0.0,truncate=4.0) Multidimensional Gaussian filter. `prewitt`(input,axis=None,output=None,mode=”reflect”,cval=0.0) Calculate a Prewitt filter. `sobel`(input,axis=None,output=None,mode=”reflect”,cval=0.0) Calculate a Sobel filter. `generic_laplace`(input,derivative2,output=None,mode=”reflect”,cval=0.0,extra_arguments=tuple,extra_keywords=None) N-dimensional Laplace filter using a provided second derivative function. `laplace`(input,output=None,mode=”reflect”,cval=0.0) N-dimensional Laplace filter based on approximate second derivatives. `gaussian_laplace`(input,sigma,output=None,mode=”reflect”,cval=0.0,**kwargs) Multidimensional Laplace filter using gaussian second derivatives. `generic_gradient_magnitude`(input,derivative,output=None,mode=”reflect”,cval=0.0,extra_arguments=tuple,extra_keywords=None) Gradient magnitude using a provided gradient function. `gaussian_gradient_magnitude`(input,sigma,output=None,mode=”reflect”,cval=0.0,**kwargs) Multidimensional gradient magnitude using Gaussian derivatives. `_correlate_or_convolve`(input,weights,output,mode,cval,origin,convolution) `correlate`(input,weights,output=None,mode=”reflect”,cval=0.0,origin=0) Multi-dimensional correlation. `convolve`(input,weights,output=None,mode=”reflect”,cval=0.0,origin=0) Multidimensional convolution. `uniform_filter1d`(input,size,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a one-dimensional uniform filter along the given axis. `uniform_filter`(input,size=3,output=None,mode=”reflect”,cval=0.0,origin=0) Multi-dimensional uniform filter. `minimum_filter1d`(input,size,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a one-dimensional minimum filter along the given axis. `maximum_filter1d`(input,size,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a one-dimensional maximum filter along the given axis. `_min_or_max_filter`(input,size,footprint,structure,output,mode,cval,origin,minimum) `minimum_filter`(input,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a multi-dimensional minimum filter. `maximum_filter`(input,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a multi-dimensional maximum filter. `_rank_filter`(input,rank,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0,operation=”rank”) `rank_filter`(input,rank,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a multi-dimensional rank filter. `median_filter`(input,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a multidimensional median filter. `percentile_filter`(input,percentile,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0) Calculate a multi-dimensional percentile filter. `generic_filter1d`(input,function,filter_size,axis=None,output=None,mode=”reflect”,cval=0.0,origin=0,extra_arguments=tuple,extra_keywords=None) Calculate a one-dimensional filter along the given axis. `generic_filter`(input,function,size=None,footprint=None,output=None,mode=”reflect”,cval=0.0,origin=0,extra_arguments=tuple,extra_keywords=None) Calculate a multi-dimensional filter using the given function.
`correlate1d`(input, weights, axis=None, 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.

%(input)s weights : array

One-dimensional sequence of numbers.

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s

```>>> 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])
```
`convolve1d`(input, weights, axis=None, 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.

%(input)s weights : ndarray

One-dimensional sequence of numbers.

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s

convolve1d : ndarray
Convolved array with same shape as input
```>>> 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])
```
`_gaussian_kernel1d`(sigma, order, radius)

Computes a 1D Gaussian convolution kernel.

`gaussian_filter1d`(input, sigma, axis=None, order=0, output=None, mode="reflect", cval=0.0, truncate=4.0)

One-dimensional Gaussian filter.

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

gaussian_filter1d : ndarray

```>>> 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()
```
`gaussian_filter`(input, sigma, order=0, output=None, mode="reflect", cval=0.0, truncate=4.0)

Multidimensional Gaussian filter.

%(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.
gaussian_filter : ndarray
Returned array of same shape as input.

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.

```>>> 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()
```
`prewitt`(input, axis=None, output=None, mode="reflect", cval=0.0)

Calculate a Prewitt filter.

%(input)s %(axis)s %(output)s %(mode_multiple)s %(cval)s

```>>> 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()
```
`sobel`(input, axis=None, output=None, mode="reflect", cval=0.0)

Calculate a Sobel filter.

%(input)s %(axis)s %(output)s %(mode_multiple)s %(cval)s

```>>> 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()
```
`generic_laplace`(input, derivative2, output=None, mode="reflect", cval=0.0, extra_arguments=tuple, extra_keywords=None)

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

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

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

N-dimensional Laplace filter based on approximate second derivatives.

%(input)s %(output)s %(mode_multiple)s %(cval)s

```>>> 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()
```
`gaussian_laplace`(input, sigma, output=None, mode="reflect", cval=0.0, **kwargs)

Multidimensional Laplace filter using gaussian second derivatives.

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

```>>> 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()
```
`generic_gradient_magnitude`(input, derivative, output=None, mode="reflect", cval=0.0, extra_arguments=tuple, extra_keywords=None)

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

`gaussian_gradient_magnitude`(input, sigma, output=None, mode="reflect", cval=0.0, **kwargs)

Multidimensional gradient magnitude using Gaussian derivatives.

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

Filtered array. Has the same shape as input.
```>>> 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()
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
```
`_correlate_or_convolve`(input, weights, output, mode, cval, origin, convolution)
`correlate`(input, weights, output=None, mode="reflect", cval=0.0, origin=0)

Multi-dimensional correlation.

The array is correlated with the given kernel.

input : array-like
input array to filter
weights : ndarray
array of weights, same number of dimensions as input
output : array, optional
The `output` parameter passes an array in which to store the filter output. Output array should have different name as compared to input array to avoid aliasing errors.
mode : {‘reflect’,’constant’,’nearest’,’mirror’, ‘wrap’}, optional
The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘reflect’
cval : scalar, optional
Value to fill past edges of input if `mode` is ‘constant’. Default is 0.0
origin : scalar, optional
The `origin` parameter controls the placement of the filter. Default 0

convolve : Convolve an image with a kernel.

`convolve`(input, weights, output=None, mode="reflect", cval=0.0, origin=0)

Multidimensional convolution.

The array is convolved with the given kernel.

input : array_like
Input array to filter.
weights : array_like
Array of weights, same number of dimensions as input
output : ndarray, optional
The output parameter passes an array in which to store the filter output. Output array should have different name as compared to input array to avoid aliasing errors.
mode : {‘reflect’,’constant’,’nearest’,’mirror’, ‘wrap’}, optional
the mode parameter determines how the array borders are handled. For ‘constant’ mode, values beyond borders are set to be cval. Default is ‘reflect’.
cval : scalar, optional
Value to fill past edges of input if mode is ‘constant’. Default is 0.0
origin : array_like, optional
The origin parameter controls the placement of the filter, relative to the centre of the current element of the input. Default of 0 is equivalent to `(0,)*input.ndim`.
result : ndarray
The result of convolution of input with weights.

correlate : Correlate an image with a kernel.

Each value in result is , where W is the weights kernel, j is the n-D spatial index over , I is the input and k is the coordinate of the center of W, specified by origin in the input parameters.

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]])
```
`uniform_filter1d`(input, size, axis=None, 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.

%(input)s size : int

length of uniform filter

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s

```>>> 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])
```
`uniform_filter`(input, size=3, output=None, mode="reflect", cval=0.0, origin=0)

Multi-dimensional uniform filter.

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

uniform_filter : ndarray
Filtered array. Has the same shape as input.

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.

```>>> 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()
```
`minimum_filter1d`(input, size, axis=None, 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.

%(input)s size : int

length along which to calculate 1D minimum

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s

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.

```>>> 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])
```
`maximum_filter1d`(input, size, axis=None, 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.

%(input)s size : int

Length along which to calculate the 1-D maximum.

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s

maximum1d : ndarray, None
Maximum-filtered array with same shape as input. None if output is not None

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.

```>>> 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])
```
`_min_or_max_filter`(input, size, footprint, structure, output, mode, cval, origin, minimum)
`minimum_filter`(input, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0)

Calculate a multi-dimensional minimum filter.

%(input)s %(size_foot)s %(output)s %(mode_multiple)s %(cval)s %(origin)s

minimum_filter : ndarray
Filtered array. Has the same shape as input.
```>>> 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()
```
`maximum_filter`(input, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0)

Calculate a multi-dimensional maximum filter.

%(input)s %(size_foot)s %(output)s %(mode_multiple)s %(cval)s %(origin)s

maximum_filter : ndarray
Filtered array. Has the same shape as input.
```>>> 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()
```
`_rank_filter`(input, rank, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0, operation="rank")
`rank_filter`(input, rank, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0)

Calculate a multi-dimensional rank filter.

%(input)s rank : int

The rank parameter may be less then zero, i.e., rank = -1 indicates the largest element.

%(size_foot)s %(output)s %(mode)s %(cval)s %(origin)s

rank_filter : ndarray
Filtered array. Has the same shape as input.
```>>> 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()
```
`median_filter`(input, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0)

Calculate a multidimensional median filter.

%(input)s %(size_foot)s %(output)s %(mode)s %(cval)s %(origin)s

median_filter : ndarray
Filtered array. Has the same shape as input.
```>>> 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()
```
`percentile_filter`(input, percentile, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0)

Calculate a multi-dimensional percentile filter.

%(input)s percentile : scalar

The percentile parameter may be less then zero, i.e., percentile = -20 equals percentile = 80

%(size_foot)s %(output)s %(mode)s %(cval)s %(origin)s

percentile_filter : ndarray
Filtered array. Has the same shape as input.
```>>> 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()
```
`generic_filter1d`(input, function, filter_size, axis=None, output=None, mode="reflect", cval=0.0, origin=0, extra_arguments=tuple, extra_keywords=None)

Calculate a one-dimensional filter along the given axis.

generic_filter1d iterates over the lines of the array, calling the given function at each line. The arguments of the line are the input line, and the output line. The input and output lines are 1D double arrays. The input line is extended appropriately according to the filter size and origin. The output line must be modified in-place with the result.

%(input)s function : {callable, scipy.LowLevelCallable}

Function to apply along given axis.
filter_size : scalar
Length of the filter.

%(axis)s %(output)s %(mode)s %(cval)s %(origin)s %(extra_arguments)s %(extra_keywords)s

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

```int function(double *input_line, npy_intp input_length,
double *output_line, npy_intp output_length,
void *user_data)
int function(double *input_line, intptr_t input_length,
double *output_line, intptr_t output_length,
void *user_data)
```

The calling function iterates over the lines of the input and output arrays, calling the callback function at each line. The current line is extended according to the border conditions set by the calling function, and the result is copied into the array that is passed through `input_line`. The length of the input line (after extension) is passed through `input_length`. The callback function should apply the filter and store the result in the array passed through `output_line`. The length of the output line is passed through `output_length`. `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.

`generic_filter`(input, function, size=None, footprint=None, output=None, mode="reflect", cval=0.0, origin=0, extra_arguments=tuple, extra_keywords=None)

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.

%(input)s function : {callable, scipy.LowLevelCallable}

Function to apply at each element.

%(size_foot)s %(output)s %(mode)s %(cval)s %(origin)s %(extra_arguments)s %(extra_keywords)s

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.