SciPy 1.12 中文文档（十九）
scipy.ndimage.gaussian_gradient_magnitude
scipy.ndimage.gaussian_gradient_magnitude(input, sigma, output=None, mode='reflect', cval=0.0, **kwargs)
使用高斯导数的多维梯度幅度。
参数：
inputarray_like
输入数组。
sigma标量或标量序列
高斯滤波器的标准偏差分别给出每个轴作为序列，或作为一个单一的数字，其中它对所有轴是相等的。
output数组或 dtype，可选
放置输出的数组，或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
modestr 或序列，可选
mode参数确定在过滤器重叠边界时如何扩展输入数组。通过传递与输入数组维数相等长度的模式序列，可以指定每个轴上的不同模式。默认值为‘reflect’。有效值及其行为如下：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过关于最后一个像素边缘的反射来扩展。有时这种模式也称为半样本对称。
‘constant’ (k k k k | a b c d | k k k k)
输入通过用由cval参数定义的相同常量值填充边缘之外的所有值来扩展。
‘nearest’ (a a a a | a b c d | d d d d)
输入通过复制最后一个像素来扩展。
‘mirror’ (d c b | a b c d | c b a)
输入通过关于最后一个像素中心的反射来扩展。有时这种模式也称为整体样本对称。
‘wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相对的边缘来扩展。
为了与插值函数保持一致，以下模式名称也可以使用：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，用来填充输入边缘之外的值。默认值为 0.0。
额外的关键字参数将传递给 gaussian_filter()。
返回：
gaussian_gradient_magnitudendarray
过滤后的数组。与input具有相同的形状。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.gaussian_gradient_magnitude(ascent, sigma=5)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.gaussian_laplace
scipy.ndimage.gaussian_laplace(input, sigma, output=None, mode='reflect', cval=0.0, **kwargs)
使用高斯二阶导数的多维拉普拉斯滤波器。
参数：
input array_like
输入数组。
sigma 标量或标量序列
高斯滤波器的标准差以序列的形式给出，或者作为单个数字，此时对所有轴都是相等的。
output array 或 dtype，可选
用于放置输出的数组，或者返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
modestr 或者序列，可选
mode 参数决定了当滤波器重叠边界时如何扩展输入数组。通过传递与输入数组维度数目相等长度的模式序列，可以指定沿每个轴的不同模式。默认值是“reflect”。有效的值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射进行扩展。有时也称为半样本对称模式。
‘constant’（k k k k | a b c d | k k k k）
输入通过使用由cval参数定义的相同常量值填充超出边缘的所有值进行扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射进行扩展。有时也称为全样本对称模式。
‘wrap’（a b c d | a b c d | a b c d）
输入通过围绕到相反边缘进行扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-constant’
这是“constant”的同义词。
‘grid-mirror’
这是“reflect”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入超出边缘的值。默认值为 0.0。
额外的关键字参数将被传递给 gaussian_filter()。
返回：
gaussian_laplace ndarray
过滤后的数组。与input具有相同的形状。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> ascent = datasets.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()
scipy.ndimage.generic_filter
scipy.ndimage.generic_filter(input, function, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, extra_arguments=(), extra_keywords=None)
使用给定函数计算多维滤波器。
在每个元素处调用提供的函数。在该元素处的滤波器足迹内的输入值作为双值数组传递给函数。
参数：
input类似数组
输入数组。
function{callable, scipy.LowLevelCallable}
在每个元素上应用的函数。
size标量或元组，可选
见 footprint，如果给出了 footprint，则忽略。
footprint数组，可选
必须定义size或footprint之一。size表示从输入数组中的每个元素位置获取的形状，以定义滤波器函数的输入。footprint是一个布尔数组，隐式指定了一个形状，但也指定了该形状内部哪些元素将传递给滤波器函数。因此，size=(n,m)等同于footprint=np.ones((n,m))。我们根据输入数组的维数调整size，因此如果输入数组形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。如果给定了footprint，则size将被忽略。
output数组或 dtype，可选
放置输出的数组或返回数组的 dtype，可选，默认情况下将创建与输入相同 dtype 的数组。
mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
mode参数决定如何扩展输入数组超出其边界的方式。默认为‘reflect’。每个有效值的行为如下：
‘reflect’ (d c b a | a b c d | d c b a)
通过反射关于最后一个像素的边界来扩展输入。此模式有时也称为半样本对称。
‘constant’ (k k k k | a b c d | k k k k)
通过填充所有超出边缘的值来扩展输入，填充值由cval参数定义。
‘nearest’ (a a a a | a b c d | d d d d)
通过复制最后一个像素来扩展输入。
‘mirror’ (d c b | a b c d | c b a)
通过关于最后一个像素中心的反射来扩展输入。此模式有时也称为全样本对称。
‘wrap’ (a b c d | a b c d | a b c d)
通过环绕到相对边缘来扩展输入。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-constant’
这是‘constant’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘的值。默认为 0.0。
origin整数或序列，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中在像素上，正值将滤波器向左移动，负值将其向右移动。通过传递长度等于输入数组维数的起源序列，可以指定每个轴上的不同移位。
extra_argumentssequence, optional
需要传递给传递函数的额外位置参数的序列。
extra_keywordsdict, optional
需要传递给传递函数的额外关键字参数的字典。
返回：
generic_filterndarray
过滤后的数组。形状与input相同。
注释
此函数还接受具有以下签名之一的低级回调函数，并包装在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)
调用函数在输入和输出数组的元素上进行迭代，每个元素调用回调函数。当前元素处于滤波器足迹内的元素通过buffer参数传递，足迹内元素的数量通过filter_size传递。计算得到的值在return_value中返回。user_data作为scipy.LowLevelCallable的数据指针提供。
回调函数必须返回整数错误状态，如果出现问题则为零，否则为一。如果发生错误，通常应在返回之前设置 Python 错误状态并附上信息，否则调用函数会设置默认错误消息。
此外，还接受一些其他低级函数指针规范，但这些仅用于向后兼容，不应在新代码中使用。
示例
导入必要的模块并加载用于过滤的示例图像。
>>> import numpy as np
>>> from scipy import datasets
>>> from scipy.ndimage import generic_filter
>>> import matplotlib.pyplot as plt
>>> ascent = datasets.ascent()
通过将简单的 NumPy 聚合函数作为function的参数来计算大小为 10 的最大滤波器。
>>> maximum_filter_result = generic_filter(ascent, np.amax, [10, 10])
虽然也可以直接使用maximum_filter获取最大滤波器，但generic_filter允许使用通用 Python 函数或scipy.LowLevelCallable作为滤波器。在这里，我们计算了大小为 5 的核的最大值和最小值之间的范围作为示例。
>>> def custom_filter(image):
... return np.amax(image) - np.amin(image)
>>> custom_filter_result = generic_filter(ascent, custom_filter, [5, 5])
绘制原始和过滤后的图像。
>>> fig, axes = plt.subplots(3, 1, figsize=(4, 12))
>>> plt.gray() # show the filtered result in grayscale
>>> top, middle, bottom = axes
>>> for ax in axes:
... ax.set_axis_off() # remove coordinate system
>>> top.imshow(ascent)
>>> top.set_title("Original image")
>>> middle.imshow(maximum_filter_result)
>>> middle.set_title("Maximum filter, Kernel: 10x10")
>>> bottom.imshow(custom_filter_result)
>>> bottom.set_title("Custom filter, Kernel: 5x5")
>>> fig.tight_layout()
scipy.ndimage.generic_filter1d
scipy.ndimage.generic_filter1d(input, function, filter_size, axis=-1, output=None, mode='reflect', cval=0.0, origin=0, extra_arguments=(), extra_keywords=None)
计算给定轴上的 1-D 滤波器。
generic_filter1d迭代数组的行，每行调用给定的函数。行的参数是输入行和输出行。输入和输出行是 1-D 双精度数组。根据滤波器大小和原点适当地扩展输入行。输出行必须通过结果就地修改。
参数：
input类似数组
输入数组。
function{可调用对象，scipy.LowLevelCallable}
在给定轴上应用的函数。
filter_size标量
滤波器的长度。
axis整数，可选
input的轴沿其计算的轴。默认为-1。
output数组或 dtype，可选
用于放置输出的数组或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
mode{‘reflect’，‘constant’，‘nearest’，‘mirror’，‘wrap’}，可选
mode参数确定如何扩展输入数组超出其边界。默认为“reflect”。每个有效值的行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射来扩展。有时也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过用由cval参数定义的相同常量值填充超出边缘的所有值来扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素来扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射来扩展。有时也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入通过环绕到相反边缘来扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cval标量，可选
如果mode为‘constant’，则在输入边缘之外填充值。默认值为 0.0。
origin整数，可选
控制滤波器放置在输入数组像素上的位置。值为 0（默认值）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。
extra_arguments序列，可选
传递给传递函数的额外位置参数序列。
extra_keywords字典，可选
传递给传递函数的额外关键字参数字典。
返回：
generic_filter1d ndarray
过滤后的数组。与input具有相同的形状。
注意
该函数还接受带有以下签名之一的低级回调函数，并且包装在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)
调用函数迭代输入和输出数组的各行，并在每行调用回调函数。当前行根据调用函数设定的边界条件进行扩展，并将结果复制到通过input_line传递的数组中。输入行的长度（扩展后）通过input_length传递。回调函数应用过滤器并将结果存储在通过output_line传递的数组中。输出行的长度通过output_length传递。user_data是作为scipy.LowLevelCallable提供给数据指针。
回调函数必须返回一个整数错误状态，如果出现问题则为零，否则为一。如果发生错误，通常应在返回之前设置带有详细信息的 Python 错误状态，否则调用函数将设置默认错误消息。
此外，还接受其他一些低级功能指针规范，但这些仅用于向后兼容，不应在新代码中使用。
scipy.ndimage.generic_gradient_magnitude
scipy.ndimage.generic_gradient_magnitude(input, derivative, output=None, mode='reflect', cval=0.0, extra_arguments=(), extra_keywords=None)
使用提供的梯度函数计算梯度幅值。
参数：
input 类似数组
输入数组。
derivative 可调用函数
具有以下签名的可调用函数：
derivative(input, axis, output, mode, cval,
*extra_arguments, **extra_keywords)
请参见下文的 extra_arguments，extra_keywords。derivative 可以假定 input 和 output 是 ndarray。请注意，derivative 的输出在原地修改；在返回之前复制重要输入时请小心。
output 数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下将创建与输入相同 dtype 的数组。
mode 字符串或序列，可选
mode 参数确定在滤波器重叠边界时如何扩展输入数组。通过传递与输入数组维数相同长度的模式序列，可以指定每个轴上的不同模式。默认值为 ‘reflect’。有效值及其行为如下：
‘reflect’ （d c b a | a b c d | d c b a）
通过关于最后一个像素边缘的反射来扩展输入。有时此模式也称为半采样对称。
‘constant’ （k k k k | a b c d | k k k k）
通过使用由 cval 参数定义的相同常量值填充边缘之外的所有值来扩展输入。
‘nearest’ （a a a a | a b c d | d d d d）
通过复制最后一个像素来扩展输入。
‘mirror’ （d c b | a b c d | c b a）
通过关于最后一个像素中心的反射来扩展输入。有时此模式也称为整体采样对称。
‘wrap’ （a b c d | a b c d | a b c d）
通过绕到相对边缘来扩展输入。
为保持与插值函数的一致性，还可以使用以下模式名称：
‘grid-constant’
这是 ‘constant’ 的同义词。
‘grid-mirror’
这是 ‘reflect’ 的同义词。
‘grid-wrap’
这是 ‘wrap’ 的同义词。
cval 标量，可选
如果 mode 是 ‘constant’，则填充输入边缘之外的值的值。默认值为 0.0。
extra_keywords 字典，可选
传递给传递函数的额外关键字参数的字典。
extra_arguments 序列，可选
传递给传递函数的额外位置参数序列。
返回：
generic_gradient_matnitude ndarray
过滤后的数组。具有与 input 相同的形状。
scipy.ndimage.generic_laplace
scipy.ndimage.generic_laplace(input, derivative2, output=None, mode='reflect', cval=0.0, extra_arguments=(), extra_keywords=None)
使用提供的二阶导数函数的 N-D Laplace 滤波器。
参数：
inputarray_like
输入数组。
derivative2可调用
具有以下签名的可调用函数：
derivative2(input, axis, output, mode, cval,
*extra_arguments, **extra_keywords)
参见下面的extra_arguments，extra_keywords。
output数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
modestr 或序列，可选
mode参数确定过滤器在重叠边界时如何扩展输入数组。通过传递与输入数组维数相等的模式序列，可以在每个轴上指定不同的模式。默认值为‘reflect’。有效值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a)
输入通过关于最后像素边缘的反射进行扩展。这种模式有时也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k)
输入通过使用相同的常量值填充超出边缘的所有值进行扩展，该常量值由cval参数定义。
‘nearest’（a a a a | a b c d | d d d d)
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a)
输入通过关于最后一个像素中心的反射进行扩展。这种模式有时也称为整样本对称。
‘wrap’（a b c d | a b c d | a b c d)
输入通过包裹到相反边缘来扩展。
为了与插值函数的一致性，还可以使用以下模式名称：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外的值的值。默认值为 0.0。
extra_keywords字典，可选
传递给传递函数的额外关键字参数的字典。
extra_arguments序列，可选
要传递给传递函数的额外位置参数序列。
返回：
generic_laplacendarray
过滤后的数组。具有与input相同的形状。
scipy.ndimage.laplace
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.laplace.html#scipy.ndimage.laplace
scipy.ndimage.laplace(input, output=None, mode='reflect', cval=0.0)
基于近似二阶导数的 N 维拉普拉斯滤波器。
参数：
输入array_like
输入数组。
输出数组或 dtype，可选项。
放置输出的数组，或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
模式str 或序列，可选项。
mode参数确定滤波器重叠边界时如何扩展输入数组。通过传递与输入数组维数相等长度的模式序列，可以指定每个轴上的不同模式。默认值为'reflect'。有效的值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射进行扩展。此模式有时也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过使用由cval参数定义的相同常量值填充超出边缘的所有值进行扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射进行扩展。此模式有时也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入被绕到相对边缘以扩展。
为了与插值函数保持一致，以下模式名称也可以使用：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选项
如果mode为'constant'，则用于填充输入的过去边缘的值。默认为 0.0。
返回：
拉普拉斯ndarray
过滤后的数组。与input具有相同的形状。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.laplace(ascent)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.maximum_filter
scipy.ndimage.maximum_filter(input, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
计算多维最大滤波器。
参数：
input类似数组
输入数组。
size标量或元组，可选
请参见下面的 footprint。如果给定 footprint，则忽略。
footprint数组，可选
必须定义size或footprint之一。size给出从输入数组中的每个元素位置取得的形状，以定义滤波器函数的输入。footprint是一个布尔数组，指定（隐式地）一个形状，以及将传递给滤波器函数的这个形状中的元素。因此，size=(n,m)等同于footprint=np.ones((n,m))。我们将size调整为输入数组的维数，因此，如果输入数组形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。当给定footprint时，将忽略size。
output数组或 dtype，可选
输出数组的位置或返回数组的 dtype。默认情况下将创建与输入相同 dtype 的数组。
mode字符串或序列，可选
mode参数确定滤波器在重叠边界时如何扩展输入数组。通过传递与输入数组维度数相等长度的模式序列，可以沿每个轴指定不同的模式。默认值为‘反射’。有效值及其行为如下：
‘反射’ (d c b a | a b c d | d c b a)
通过关于最后像素边缘的反射来扩展输入。此模式有时也称为半样本对称。
‘常量’ (k k k k | a b c d | k k k k)
通过使用由cval参数定义的相同常数值填充超出边缘的所有值来扩展输入。
‘最近邻’ (a a a a | a b c d | d d d d)
通过复制最后一个像素来扩展输入。
‘镜像’ (d c b | a b c d | c b a)
通过关于最后像素中心的反射来扩展输入。此模式有时也称为整体样本对称。
‘包裹’ (a b c d | a b c d | a b c d)
通过包裹到相反边缘来扩展输入。
为了与插值函数保持一致，还可以使用以下模式名称：
‘网格常量’
这是“常量”的同义词。
‘网格镜像’
这是“反射”的同义词。
‘网格包裹’
这是“包裹”的同义词。
cval标量，可选
如果mode为‘常量’，则用来填充输入边缘之外的值。默认为 0.0。
origin整数或序列，可选
控制滤波器在输入数组像素上的放置位置。值为 0（默认）将滤波器居中在像素上，正值将滤波器向左移动，负值则向右移动。通过传递长度等于输入数组维度数量的起源序列，可以沿每个轴指定不同的移位。
轴整数或 None 的元组，可选
如果为 None，则在所有轴上对input进行过滤。否则，在指定的轴上对input进行过滤。当指定axes时，用于size、origin和/或mode的任何元组必须与axes的长度匹配。这些元组中的第 i 个条目对应于axes中的第 i 个条目。
返回：
maximum_filterndarray
过滤后的数组。形状与input相同。
注意
一系列模式（每个轴一个）仅在脚印可分离时受支持。否则，必须提供单个模式字符串。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.maximum_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.maximum_filter1d
scipy.ndimage.maximum_filter1d(input, size, axis=-1, output=None, mode='reflect', cval=0.0, origin=0)
沿指定轴计算 1-D 最大过滤器。
沿给定轴的数组行用给定大小的最大过滤器过滤。
参数：
输入array_like
输入数组。
大小int
沿其计算 1-D 最大值的长度。
轴int，可选
计算沿其进行的输入轴。默认为-1。
输出数组或数据类型，可选
用于放置输出的数组或返回数组的数据类型。默认情况下，将创建与输入相同 dtype 的数组。
模式{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
mode参数确定如何扩展输入数组超出其边界。默认为“reflect”。每个有效值的行为如下：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过反射关于最后一个像素的边界扩展。此模式有时也称为半样本对称。
‘constant’ (k k k k | a b c d | k k k k)
如果mode为“constant”，则通过填充所有超出输入边缘的值来扩展输入。
‘nearest’ (a a a a | a b c d | d d d d)
输入通过复制最后一个像素扩展。
‘mirror’ (d c b | a b c d | c b a)
输入通过最后一个像素的中心反射扩展。此模式有时也称为整样本对称。
‘wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到对立边界来扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cval标量，可选
用于填充输入边界以外值的值。如果mode为“constant”，默认值为 0.0。
原点int，可选
控制过滤器放置在输入数组像素上的位置。值为 0（默认）将过滤器居中在像素上，正值将过滤器向左移动，负值将其向右移动。
返回：
maximum1dndarray，无
与输入形状相同的最大过滤数组。如果output不为 None，则为 None
注意事项
此函数实现了 MAXLIST 算法[1]，由 Richard Harter 描述[2]，并保证 O(n)性能，n为input长度，无论过滤器大小如何。
参考文献
[1]
citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777
[2]
www.richardhartersworld.com/cri/2001/slidingmin.html
示例
>>> 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])
scipy.ndimage.median_filter
scipy.ndimage.median_filter(input, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
计算多维中值滤波器。
参数：
inputarray_like
输入数组。
size标量或元组，可选
查看下面的 footprint。如果给出 footprint，则忽略。
footprint数组，可选
必须定义size或footprint之一。size给出从输入数组的每个元素位置获取的形状，以定义滤波器函数的输入。footprint是一个布尔数组，隐式指定了一个形状，还指定了将传递给滤波器函数的这些形状中的元素。因此，size=(n,m)等效于footprint=np.ones((n,m))。我们根据输入数组的维度数调整size，因此，如果输入数组形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。给出footprint时，将忽略size。
output数组或数据类型，可选
放置输出的数组或返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
mode参数确定如何在其边界之外扩展输入数组。默认为‘reflect’。每个有效值的行为如下：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过关于最后一个像素边缘的反射来扩展。这种模式有时也称为半样本对称。
‘constant’ (k k k k | a b c d | k k k k)
输入通过填充超出边缘的所有值来扩展，这些值由cval参数定义的同一常量值填充。
‘nearest’ (a a a a | a b c d | d d d d)
输入通过复制最后一个像素来扩展。
‘mirror’ (d c b | a b c d | c b a)
输入通过关于最后一个像素的中心的反射来扩展。这种模式有时也称为全样本对称。
‘wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相对边缘来扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-constant’
这是‘constant’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外的值。默认值为 0.0。
originint 或序列，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。通过传递长度等于输入数组维度数量的起源序列，可以在每个轴上指定不同的偏移量。
axes整数元组或 None，可选
如果为 None，则在所有轴上对input进行过滤。否则，在指定的轴上对input进行过滤。
返回：
median_filterndarray
过滤后的数组。与input具有相同的形状。
参见
scipy.signal.medfilt2d
注意事项
对于具有uint8、float32或float64数据类型的二维图像，专用函数scipy.signal.medfilt2d可能更快。但是，它仅限于常数模式，cval=0。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.median_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.minimum_filter
scipy.ndimage.minimum_filter(input, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
计算多维最小滤波器。
参数：
input类数组
输入数组。
size标量或元组，可选
参见 footprint。如果给定了 footprint，则忽略 origin。
footprint数组，可选
必须定义size或footprint之一。size给出从输入数组中的每个元素位置获取形状，以定义滤波器函数的输入的形状。footprint是一个布尔数组，隐式指定形状，但也指定这个形状内哪些元素将传递给滤波器函数。因此，size=(n,m)等同于footprint=np.ones((n,m))。我们调整size以适应输入数组的维数，因此，如果输入数组形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。给定footprint时，size将被忽略。
output数组或数据类型，可选
用于放置输出的数组或返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
mode字符串或序列，可选
mode参数确定滤波器在过滤器与边界重叠时如何扩展输入数组。通过传递与输入数组维数相同长度的模式序列，可以指定每个轴上的不同模式。默认值为‘reflect’。有效值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射进行扩展。有时也称为半样本对称模式。
‘constant’（k k k k | a b c d | k k k k）
输入通过用由cval参数定义的相同常数值填充边缘之外的所有值进行扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射进行扩展。有时也称为整体样本对称模式。
‘wrap’（a b c d | a b c d | a b c d）
输入通过绕到相对边缘进行扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外的值。默认值为 0.0。
origin整数或序列，可选
控制滤波器放置在输入数组像素上的位置。值为 0（默认）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。通过传递长度等于输入数组维数的起源序列，可以指定每个轴上的不同移位。
axes整数或 None 的元组，可选
如果为 None，则input沿所有轴进行过滤。否则，input沿指定的轴进行过滤。当指定了axes时，用于size、origin和/或mode的任何元组必须与axes的长度匹配。这些元组中的第 i 个条目对应于axes中的第 i 个条目。
返回：
minimum_filter ndarray
过滤后的数组。与input具有相同的形状。
注意事项
仅当足迹是可分离的时，才支持一系列模式（每个轴一个）。否则，必须提供单个模式字符串。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.minimum_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.minimum_filter1d
scipy.ndimage.minimum_filter1d(input, size, axis=-1, output=None, mode='reflect', cval=0.0, origin=0)
沿给定轴计算 1-D 最小滤波器。
沿给定轴的数组行使用给定大小的最小滤波器进行过滤。
参数：
输入类似数组
输入数组。
大小整数
计算 1D 最小值的长度。
轴整数，可选
input中用于计算的轴。默认值为-1。
输出数组或数据类型，可选
要放置输出的数组或返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
模式{‘reflect’，‘constant’，‘nearest’，‘mirror’，‘wrap’}，可选
mode参数确定输入数组在其边界之外如何扩展。默认为“reflect”。每个有效值的行为如下：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过关于最后一个像素边缘的反射来扩展。有时这种模式也称为半采样对称。
‘constant’ (k k k k | a b c d | k k k k)
输入通过填充所有超出边缘的值来扩展，该常数值由cval参数定义。
‘nearest’ (a a a a | a b c d | d d d d)
输入通过复制最后一个像素来扩展。
‘mirror’ (d c b | a b c d | c b a)
输入通过关于最后一个像素中心的反射来扩展。有时这种模式也称为整数采样对称。
‘wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相反边缘来扩展。
为保持与插值函数一致，还可以使用以下模式名称：
‘grid-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cval标量，可选
如果mode为“constant”，则用于填充输入边缘之外的值。默认值为 0.0。
原点整数，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中在像素上，正值将滤波器向左移动，负值向右移动。
返回：
结果ndarray。
过滤后的图像。与input具有相同的形状。
注意事项
此函数实现 MINLIST 算法[1]，如 Richard Harter[2]所述，并保证 O(n)的性能，其中n是input长度，而不考虑滤波器大小。
参考资料
[1]
citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.2777
[2]
www.richardhartersworld.com/cri/2001/slidingmin.html
示例
>>> 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])
scipy.ndimage.percentile_filter
scipy.ndimage.percentile_filter(input, percentile, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
计算多维百分位数滤波器。
参数：
输入array_like
输入数组。
percentile标量
百分位参数可能小于零，即百分位=-20 等同于百分位=80
size标量或元组，可选
参见下面的 footprint。如果给定了 footprint，则忽略此参数。
footprint数组，可选
必须定义size或footprint中的一个。size给出从输入数组中的每个元素位置取出的形状，以定义滤波函数的输入。footprint是一个布尔数组，隐式指定了一个形状，同时也指定了将传递给滤波函数的这些形状内的元素。因此，size=(n,m)等同于footprint=np.ones((n,m))。我们调整size以适应输入数组的维数，因此，如果输入数组的形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。当给定footprint时，将忽略size。
输出数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
参数mode决定了如何扩展输入数组超出其边界的部分。默认是‘reflect’。每个有效值的行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射来扩展。这种模式有时也称为半采样对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过填充所有超出边缘的值，使用由参数cval定义的同一常量值来扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素来扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射来扩展。这种模式有时也称为全样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入通过环绕到相对边缘来扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-constant’
这是‘constant’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外的值的值。默认值为 0.0。
originint 或序列，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。通过传递与输入数组维数相等长度的原点序列，可以在每个轴上指定不同的移动。
axes整数元组或 None，可选
如果为 None，input在所有轴上进行过滤。否则，input沿指定轴进行过滤。
返回：
percentile_filterndarray
过滤后的数组。与input具有相同的形状。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.percentile_filter(ascent, percentile=20, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.prewitt
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.prewitt.html#scipy.ndimage.prewitt
scipy.ndimage.prewitt(input, axis=-1, output=None, mode='reflect', cval=0.0)
计算 Prewitt 滤波器。
参数：
输入类似数组
输入数组。
轴整数，可选
沿着计算的input轴。默认为-1。
输出数组或 dtype，可选
放置输出的数组或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
模式字符串或序列，可选
mode参数确定滤波器在重叠边界时如何扩展输入数组。通过传递与输入数组维度数相等的模式序列，可以指定不同的模式。默认值为‘reflect’。有效的值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射来扩展。有时也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k）
通过使用cval参数定义的相同常量值，填充所有超出边缘的值扩展输入。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素来扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射来扩展。有时也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
通过环绕到相反边缘来扩展输入。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则填充输入边缘的值。默认为 0.0。
返回：
prewitt数组
过滤后的数组。与input具有相同的形状。
另见
sobel
Sobel 滤波器
注意
此函数计算一维 Prewitt 滤波器。水平边缘使用水平变换（axis=0）进行强调，垂直边缘使用垂直变换（axis=1）进行强调，更高维度依此类推。这些可以组合以给出幅度。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> ascent = datasets.ascent()
>>> prewitt_h = ndimage.prewitt(ascent, axis=0)
>>> prewitt_v = ndimage.prewitt(ascent, axis=1)
>>> magnitude = np.sqrt(prewitt_h ** 2 + prewitt_v ** 2)
>>> magnitude *= 255 / np.max(magnitude) # Normalization
>>> fig, axes = plt.subplots(2, 2, figsize = (8, 8))
>>> plt.gray()
>>> axes[0, 0].imshow(ascent)
>>> axes[0, 1].imshow(prewitt_h)
>>> axes[1, 0].imshow(prewitt_v)
>>> axes[1, 1].imshow(magnitude)
>>> titles = ["original", "horizontal", "vertical", "magnitude"]
>>> for i, ax in enumerate(axes.ravel()):
... ax.set_title(titles[i])
... ax.axis("off")
>>> plt.show()
scipy.ndimage.rank_filter
scipy.ndimage.rank_filter(input, rank, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
计算多维排名滤波器。
参数：
输入类似数组
输入数组。
排名整数
排名参数可能小于零，即，排名 = -1 表示最大元素。
大小标量或元组，可选
请参见足迹（下文）。如果给定了足迹，则忽略此参数。
足迹数组，可选
必须定义大小或足迹之一。大小给出从输入数组中的每个元素位置提取的形状，以定义滤波器函数的输入。足迹是一个布尔数组，隐含地指定了一个形状，但也指定了该形状中哪些元素将传递给滤波器函数。因此，size=(n,m)等同于footprint=np.ones((n,m))。我们根据输入数组的维数调整size，因此，如果输入数组形状为(10,10,10)，而size为 2，则使用的实际大小为(2,2,2)。如果给定了footprint，则size将被忽略。
输出数组或数据类型，可选
用于放置输出的数组，或返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
模式{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
mode参数确定如何扩展输入数组超出其边界。默认值为‘reflect’。每个有效值的行为如下：
‘反射’ (d c b a | a b c d | d c b a)
输入通过最后一个像素的边缘反射扩展。这种模式有时也被称为半样本对称。
‘常量’ (k k k k | a b c d | k k k k)
输入通过使用由cval参数定义的相同常量值填充超出边缘的所有值进行扩展。
‘最近’ (a a a a | a b c d | d d d d)
输入通过复制最后一个像素扩展。
‘镜像’ (d c b | a b c d | c b a)
输入通过围绕最后一个像素的中心反射扩展。这种模式有时也被称为整体样本对称。
‘包裹’ (a b c d | a b c d | a b c d)
输入通过环绕到对立边缘进行扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘网格-镜像’
这是‘reflect’的同义词。
‘网格-常量’
这是‘constant’的同义词。
‘网格-包裹’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用来填充输入边缘之外的值的值。默认值为 0.0。
起源整数或序列，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。通过传递长度等于输入数组维度数的起点序列，可以沿每个轴指定不同的移动。
axes整数元组或 None，可选
如果为 None，则在所有轴上对input进行过滤。否则，沿指定轴对input进行过滤。
返回：
rank_filterndarray
过滤后的数组。与input具有相同的形状。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.rank_filter(ascent, rank=42, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.sobel
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.sobel.html#scipy.ndimage.sobel
scipy.ndimage.sobel(input, axis=-1, output=None, mode='reflect', cval=0.0)
计算 Sobel 滤波器。
参数：
inputarray_like
输入数组。
axisint，可选
input 的轴向来计算。默认为 -1。
outputarray 或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
modestr 或序列，可选
mode 参数确定当滤波器重叠边界时如何扩展输入数组。通过传递与输入数组维数相等的模式序列，可以指定每个轴向的不同模式。默认值为 ‘reflect’。有效的值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射进行扩展。这种模式有时也称为半采样对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过填充所有超出边缘的值的相同常量值来扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射进行扩展。这种模式有时也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入通过环绕到相反边缘进行扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-constant’
这是 ‘constant’ 的同义词。
‘grid-mirror’
这是 ‘reflect’ 的同义词。
‘grid-wrap’
这是 ‘wrap’ 的同义词。
cval标量，可选
如果 mode 为 ‘constant’，用于填充输入之外的值。默认为 0.0。
返回：
sobelndarray
过滤后的数组。形状与 input 相同。
注意事项
此函数计算特定轴向的 Sobel 梯度。通过水平变换（axis=0）可以突出水平边缘，通过垂直变换（axis=1）可以突出垂直边缘，等等，对于更高维度也是如此。这些可以组合以给出梯度的大小。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> ascent = datasets.ascent().astype('int32')
>>> sobel_h = ndimage.sobel(ascent, 0) # horizontal gradient
>>> sobel_v = ndimage.sobel(ascent, 1) # vertical gradient
>>> magnitude = np.sqrt(sobel_h**2 + sobel_v**2)
>>> magnitude *= 255.0 / np.max(magnitude) # normalization
>>> fig, axs = plt.subplots(2, 2, figsize=(8, 8))
>>> plt.gray() # show the filtered result in grayscale
>>> axs[0, 0].imshow(ascent)
>>> axs[0, 1].imshow(sobel_h)
>>> axs[1, 0].imshow(sobel_v)
>>> axs[1, 1].imshow(magnitude)
>>> titles = ["original", "horizontal", "vertical", "magnitude"]
>>> for i, ax in enumerate(axs.ravel()):
... ax.set_title(titles[i])
... ax.axis("off")
>>> plt.show()
scipy.ndimage.uniform_filter
scipy.ndimage.uniform_filter(input, size=3, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)
多维均匀滤波器。
参数：
输入array_like
输入数组。
sizeint 或整数序列，可选
给定每个轴的均匀滤波器尺寸作为序列，或作为单个数字，此时尺寸对所有轴均相等。
输出数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
modestr 或序列，可选
mode参数确定当过滤器重叠边界时如何扩展输入数组。通过传递与输入数组维度数目相等长度的模式序列，可以指定每个轴上的不同模式。默认值为‘reflect’。有效的值及其行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射进行扩展。这种模式有时也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过用由cval参数定义的相同常数值填充所有超出边缘的值进行扩展。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素进行扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射进行扩展。这种模式有时也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入通过绕到对立边缘进行扩展。
为了与插值函数保持一致，还可以使用以下模式名称：
‘grid-constant’
这是‘constant’的同义词。
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外值的值。默认值为 0.0。
originint 或序列，可选
控制滤波器在输入数组像素上的放置。值为 0（默认值）将滤波器居中在像素上，正值将滤波器向左移动，负值将向右移动。通过传递与输入数组维度数目相等长度的原点序列，可以指定每个轴上的不同偏移量。
轴int 元组或 None，可选
如果为 None，则在所有轴上过滤input。否则，在指定的轴上过滤input。当指定axes时，用于size、origin和/或mode的任何元组必须与axes的长度匹配。任何这些元组中的第 i 个条目对应于axes中的第 i 个条目。
返回：
uniform_filterndarray
过滤后的数组。具有与input相同的形状。
注意事项
多维过滤器被实现为一系列 1-D 均匀过滤器。中间数组以与输出相同的数据类型存储。因此，对于具有有限精度的输出类型，由于中间结果可能以不足的精度存储，结果可能不精确。
示例
>>> from scipy import ndimage, datasets
>>> 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 = datasets.ascent()
>>> result = ndimage.uniform_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.uniform_filter1d
scipy.ndimage.uniform_filter1d(input, size, axis=-1, output=None, mode='reflect', cval=0.0, origin=0)
沿给定轴计算 1-D 统一滤波器。
沿给定轴的数组行使用给定大小的统一滤波器进行过滤。
参数：
inputarray_like
输入数组。
sizeint
统一滤波器的长度
axisint，可选
input沿着其计算的轴。默认为 -1。
output数组或 dtype，可选
用于放置输出的数组或返回数组的 dtype。默认情况下将创建与输入相同 dtype 的数组。
mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}，可选
mode参数确定如何扩展输入数组超出其边界的行为。默认为‘reflect’。每个有效值的行为如下：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射来扩展。有时此模式也称为半样本对称。
‘constant’（k k k k | a b c d | k k k k）
输入通过填充所有超出边缘的值来扩展，由cval参数定义常量值。
‘nearest’（a a a a | a b c d | d d d d）
输入通过复制最后一个像素来扩展。
‘mirror’（d c b | a b c d | c b a）
输入通过关于最后一个像素中心的反射来扩展。有时此模式也称为整体样本对称。
‘wrap’（a b c d | a b c d | a b c d）
输入通过绕到对立边缘来扩展。
为了与插值函数保持一致，也可以使用以下模式名称：
‘grid-mirror’
这是‘reflect’的同义词。
‘grid-constant’
这是‘constant’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量，可选
如果mode为‘constant’，用于填充输入边缘之外的值。默认为 0.0。
originint，可选
控制滤波器在输入数组像素上的放置。值为 0（默认）将滤波器居中于像素上，正值将滤波器向左移动，负值向右移动。
返回：
resultndarray
过滤后的数组。具有与input相同的形状。
示例
>>> 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])
scipy.ndimage.fourier_ellipsoid
scipy.ndimage.fourier_ellipsoid(input, size, n=-1, axis=-1, output=None)
多维椭球傅里叶滤波器。
数组与给定大小的椭球体的傅里叶变换相乘。
参数：
inputarray_like
输入数组。
sizefloat 或序列
用于过滤的盒子的大小。如果是浮点数，size对所有轴是相同的。如果是序列，size必须包含每个轴的一个值。
nint，可选
如果n为负（默认值），则假定输入为复杂 fft 的结果。如果n大于或等于零，则假定输入为实 fft 的结果，n给出了变换前数组沿实数变换方向的长度。
axisint，可选
实数变换的轴。
outputndarray，可选
如果给定，则将输入的过滤结果放置在此数组中。
返回值：
fourier_ellipsoidndarray
过滤后的输入。
注意事项
本函数适用于秩为 1、2 或 3 的数组。
示例
>>> from scipy import ndimage, datasets
>>> import numpy.fft
>>> import matplotlib.pyplot as plt
>>> fig, (ax1, ax2) = plt.subplots(1, 2)
>>> plt.gray() # show the filtered result in grayscale
>>> ascent = datasets.ascent()
>>> input_ = numpy.fft.fft2(ascent)
>>> result = ndimage.fourier_ellipsoid(input_, size=20)
>>> result = numpy.fft.ifft2(result)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result.real) # the imaginary part is an artifact
>>> plt.show()
scipy.ndimage.fourier_gaussian
scipy.ndimage.fourier_gaussian(input, sigma, n=-1, axis=-1, output=None)
多维高斯傅里叶滤波器。
数组与高斯核的傅里叶变换相乘。
参数：
inputarray_like
输入数组。
sigmafloat 或 序列
高斯核的 sigma 值。如果是浮点数，则所有轴的 sigma 值相同。如果是序列，则 sigma 必须包含每个轴的一个值。
nint, 可选
如果n为负（默认），则假定输入是复数 fft 的结果。如果n大于或等于零，则假定输入是实数 fft 的结果，n表示变换前沿着实部变换方向的数组长度。
axisint, 可选
实部变换的轴。
outputndarray, 可选
如果给定，输入过滤的结果将放置在此数组中。
返回：
fourier_gaussianndarray
过滤后的输入。
示例
>>> from scipy import ndimage, datasets
>>> import numpy.fft
>>> import matplotlib.pyplot as plt
>>> fig, (ax1, ax2) = plt.subplots(1, 2)
>>> plt.gray() # show the filtered result in grayscale
>>> ascent = datasets.ascent()
>>> input_ = numpy.fft.fft2(ascent)
>>> result = ndimage.fourier_gaussian(input_, sigma=4)
>>> result = numpy.fft.ifft2(result)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result.real) # the imaginary part is an artifact
>>> plt.show()
