SciPy 1.12 中文文档（二十）
scipy.ndimage.fourier_shift
scipy.ndimage.fourier_shift(input, shift, n=-1, axis=-1, output=None)
多维傅里叶变换滤波器。
该数组与移位操作的傅里叶变换相乘。
参数：
输入array_like
输入数组。
移位浮点数或序列
用于过滤的盒子的大小。如果是浮点数，shift在所有轴上都相同。如果是序列，shift必须包含每个轴的一个值。
n整数，可选
如果n为负（默认情况），则假定输入是复数 fft 的结果。如果n大于或等于零，则假定输入是实数 fft 的结果，n给出了在实变换方向上变换前数组的长度。
轴整数，可选
实变换的轴。
输出ndarray，可选
如果给定，输入的移位结果将放置在此数组中。
返回：
傅里叶移位ndarray
移位后的输入。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> import numpy.fft
>>> 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_shift(input_, shift=200)
>>> result = numpy.fft.ifft2(result)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result.real) # the imaginary part is an artifact
>>> plt.show()
scipy.ndimage.fourier_uniform
scipy.ndimage.fourier_uniform(input, size, n=-1, axis=-1, output=None)
多维均匀傅里叶滤波器。
数组与给定大小的盒子的傅里叶变换相乘。
参数：
inputarray_like
输入数组。
sizefloat 或 序列
用于过滤的盒子的大小。如果是浮点数，则size对所有轴都相同。如果是序列，则size必须包含每个轴的一个值。
nint，可选
如果n为负（默认），则假定输入是复数 fft 的结果。如果n大于或等于零，则假定输入是实数 fft 的结果，并且n给出了变换前数组沿实部变换方向的长度。
axisint，可选
实部变换的轴。
outputndarray，可选
如果给定，则将输入的过滤结果放入此数组中。
返回：
fourier_uniformndarray
过滤后的输入。
示例
>>> 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_uniform(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.affine_transform
scipy.ndimage.affine_transform(input, matrix, offset=0.0, output_shape=None, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
应用仿射变换。
给定输出图像像素索引向量 o，像素值由输入图像中位置 np.dot(matrix, o) + offset 确定。
这会执行‘pull’（或‘backward’）重采样，将输出空间转换为输入空间以定位数据。仿射变换通常描述为‘push’（或‘forward’）方向，将输入转换为输出。如果有‘push’变换的矩阵，请在此函数中使用其逆矩阵（numpy.linalg.inv）。
参数：
inputarray_like
输入数组。
matrixndarray
反向坐标变换矩阵，将输出坐标映射到输入坐标。如果 ndim 是input的维数，则给定的矩阵必须具有以下形状之一：
(ndim, ndim)：每个输出坐标的线性变换矩阵。(ndim,)：假设 2-D 变换矩阵是对角线的，对角线由给定值指定。然后使用一种更有效的算法，利用问题的可分离性。(ndim + 1, ndim + 1)：假设变换使用齐次坐标[1]指定。在这种情况下，忽略传递给offset的任何值。(ndim, ndim + 1)：如上，但是齐次变换矩阵的底部行始终为[0, 0, ..., 1]，可以省略。
offset浮点数或序列，可选
在数组中应用变换的偏移量。如果是浮点数，offset 对于每个轴都相同。如果是序列，offset 应包含每个轴的一个值。
output_shape整数元组，可选
形状元组。
output数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
orderint，可选
样条插值的顺序，默认为 3。顺序必须在 0-5 范围内。
mode{‘reflect’，‘grid-mirror’，‘constant’，‘grid-constant’，‘nearest’，‘mirror’，‘grid-wrap’，‘wrap’}，可选
mode 参数确定如何扩展输入数组超出其边界。默认为‘constant’。每个有效值的行为如下（参见边界模式中的额外图表和细节）：
‘reflect’（d c b a | a b c d | d c b a）
输入通过关于最后一个像素边缘的反射来扩展。有时也称为半样本对称模式。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’（k k k k | a b c d | k k k k）
输入通过使用由cval参数定义的相同常量值填充所有超出边缘的值进行扩展。在输入的边缘之外不执行插值。
‘grid-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)
输入通过关于最后一个像素的中心进行反射来进行扩展。此模式有时也称为整体样本对称。
‘grid-wrap’ (a b c d | a b c d | a b c d)
输入通过在对立边缘进行包装来进行扩展。
‘wrap’ (d b c d | a b c d | b c a b)
输入通过在对立边缘进行包装来进行扩展，但以使最后一个点和初始点完全重叠的方式。在这种情况下，不清楚在重叠点选择哪个样本。
cval标量，可选
如果mode为‘constant’，则确定填充输入边缘之外的值的常量值。默认为 0.0。
prefilter布尔值，可选
确定是否在插值之前使用spline_filter对输入数组进行预过滤。默认值为 True，如果order > 1，则会创建一组经过滤波的float64值的临时数组。如果将其设置为 False，则如果order > 1，则输出将略有模糊，除非对输入进行了预过滤，即对原始输入调用spline_filter的结果。
返回：
affine_transform ndarray
转换后的输入。
注释
使用给定的矩阵和偏移量来通过仿射变换找到输出中每个点对应的输入坐标。输入在请求的阶数的样条插值决定的坐标值。超出输入边界的点根据给定的模式进行填充。
自版本 0.18.0 更改：以前，仿射变换的确切解释取决于矩阵是作为 1-D 数组还是 2-D 数组提供的。如果将 1-D 数组提供给矩阵参数，则在索引o处的输出像素值是从输入图像在位置matrix * (o + offset)处确定的。
对于复数值输入，此函数独立地转换实部和虚部。
从版本 1.6.0 开始：添加了对复数值的支持。
参考文献
[1]
scipy.ndimage.geometric_transform
scipy.ndimage.geometric_transform(input, mapping, output_shape=None, output=None, order=3, mode='constant', cval=0.0, prefilter=True, extra_arguments=(), extra_keywords={})
应用任意几何变换。
给定的映射函数用于找出输出中每个点在输入中对应的坐标。请求顺序的样条插值确定这些坐标处的输入值。
参数：
inputarray_like
输入数组。
mapping{callable, scipy.LowLevelCallable}
一个可调用对象，接受与输出数组秩相等长度的元组，并返回相应的输入坐标作为与输入数组秩相等长度的元组。
output_shape整数元组，可选
形状元组。
output数组或 dtype，可选
用于放置输出的数组，或者返回数组的 dtype。默认情况下将创建与输入相同 dtype 的数组。
order整数，可选
样条插值的顺序，默认为 3。顺序必须在 0-5 范围内。
mode{‘reflect’, ‘grid-mirror’, ‘constant’, ‘grid-constant’, ‘nearest’, ‘mirror’, ‘grid-wrap’, ‘wrap’}，可选
mode参数决定了如何扩展输入数组超出其边界。默认为‘constant’。每个有效值的行为如下（详见边界模式的额外图形和详细信息）：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过反射到最后像素的边缘来扩展。此模式有时也称为半样本对称。
‘grid-mirror’
这是“reflect”的同义词。
‘constant’ (k k k k | a b c d | k k k k)
输入通过填充所有超出边缘的值为相同的常量值来扩展，该常量由cval参数定义。在输入边缘之外不执行插值。
‘grid-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)
输入通过在最后像素的中心点进行反射来扩展。此模式有时也称为整体样本对称。
‘grid-wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相对边缘来扩展。
‘wrap’ (d b c d | a b c d | b c a b)
输入通过环绕到相对边缘来扩展，但是以确保最后一个点和初始点完全重叠的方式。在这种情况下，不清楚在重叠点会选择哪个样本。
cval标量，可选
如果mode为'constant'，则在输入边缘之外填充的值。默认为 0.0。
prefilter布尔值，可选
决定在插值之前是否对输入数组使用spline_filter进行预过滤。默认为 True，如果order > 1，将创建一个临时的float64数组来存储过滤后的值。如果设置为 False，则输出在order > 1时会略微模糊，除非输入已经进行了预过滤，即调用spline_filter得到的结果。
extra_arguments元组，可选
传递给mapping的额外参数。
extra_keywords字典，可选
传递给mapping的额外关键字。
返回：
output ndarray
过滤后的输入。
另请参阅
map_coordinates，affine_transform，spline_filter1d
Notes
此函数还接受具有以下签名之一的低级回调函数，并包装在scipy.LowLevelCallable中：
int mapping(npy_intp *output_coordinates, double *input_coordinates,
int output_rank, int input_rank, void *user_data)
int mapping(intptr_t *output_coordinates, double *input_coordinates,
int output_rank, int input_rank, void *user_data)
调用函数迭代输出数组的元素，调用回调函数处理每个元素。当前输出元素的坐标通过output_coordinates传递。回调函数必须返回input_coordinates中插值输入的坐标。输入和输出数组的秩分别由input_rank和output_rank给出。user_data是作为参数提供给scipy.LowLevelCallable的数据指针。
如果出现错误，回调函数必须返回整数错误状态，如果发生错误应返回零，否则返回一。如果发生错误，通常应设置 Python 错误状态并返回具有信息性消息，否则由调用函数设置默认错误消息。
此外，还接受一些其他低级函数指针规范，但这些仅供向后兼容性，不应在新代码中使用。
对于复数值input，此函数独立地转换实部和虚部。
自 1.6.0 版新增：增加复数值支持。
示例
>>> import numpy as np
>>> from scipy.ndimage import geometric_transform
>>> a = np.arange(12.).reshape((4, 3))
>>> def shift_func(output_coords):
... return (output_coords[0] - 0.5, output_coords[1] - 0.5)
...
>>> geometric_transform(a, shift_func)
array([[ 0\. , 0\. , 0\. ],
[ 0\. , 1.362, 2.738],
[ 0\. , 4.812, 6.187],
[ 0\. , 8.263, 9.637]])
>>> b = [1, 2, 3, 4, 5]
>>> def shift_func(output_coords):
... return (output_coords[0] - 3,)
...
>>> geometric_transform(b, shift_func, mode='constant')
array([0, 0, 0, 1, 2])
>>> geometric_transform(b, shift_func, mode='nearest')
array([1, 1, 1, 1, 2])
>>> geometric_transform(b, shift_func, mode='reflect')
array([3, 2, 1, 1, 2])
>>> geometric_transform(b, shift_func, mode='wrap')
array([2, 3, 4, 1, 2])
scipy.ndimage.map_coordinates
scipy.ndimage.map_coordinates(input, coordinates, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
将输入数组通过插值映射到新的坐标。
坐标数组用于找到输出中每个点对应的输入中的坐标。在请求的顺序的样条插值决定的输入值在这些坐标处。
输出的形状由坐标数组的形状推导而来，通过舍弃第一个轴。数组沿着第一个轴的值是在输入数组中找到输出值的坐标。
参数：
inputarray_like
输入数组。
coordinatesarray_like
评估input的坐标。
outputarray or dtype, optional
用于放置输出的数组，或者返回数组的数据类型。默认情况下，将创建与输入相同数据类型的数组。
orderint, optional
样条插值的顺序，默认为 3。顺序必须在 0-5 范围内。
mode{‘reflect’, ‘grid-mirror’, ‘constant’, ‘grid-constant’, ‘nearest’, ‘mirror’, ‘grid-wrap’, ‘wrap’}, optional
mode参数决定了如何扩展输入数组超出其边界。默认为‘constant’。每个有效值的行为如下（请参阅边界模式上的额外图表和详细信息）：
‘reflect’ (d c b a | a b c d | d c b a)
通过反射最后一个像素的边界进行扩展。有时也称为半样本对称。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’ (k k k k | a b c d | k k k k)
输入通过填充超出边界的所有值以相同常量值进行扩展，由cval参数定义。超出输入边界不进行插值。
‘grid-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)
通过反射关于最后一个像素的中心进行扩展。有时也称为整个样本对称。
‘grid-wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到对立边缘进行扩展。
‘wrap’ (d b c d | a b c d | b c a b)
输入通过环绕到对立边缘进行扩展，但以使最后点和初始点完全重叠的方式。在这种情况下，不明确定义在重叠点选择哪个样本。
cvalscalar, optional
如果mode为'constant'，则用来填充输入边缘之外的值。默认为 0.0。
prefilterbool，可选
确定输入数组在插值前是否使用spline_filter预过滤。默认为 True，如果order > 1，将创建一个临时的float64数组进行过滤数值。如果设置为 False，则在order > 1时输出将略微模糊，除非输入已经预过滤，即是调用原始输入的spline_filter的结果。
返回值：
map_coordinatesndarray
转换输入的结果。输出的形状由coordinates的形状通过丢弃第一个轴得到。
另请参阅
spline_filter，geometric_transform，scipy.interpolate
注意事项
对于复数input，该函数独立映射实部和虚部。
新版本 1.6.0 中新增了复数支持。
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.arange(12.).reshape((4, 3))
>>> a
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.]])
>>> ndimage.map_coordinates(a, [[0.5, 2], [0.5, 1]], order=1)
array([ 2., 7.])
在上述示例中，a[0.5, 0.5]的插值值给出 output[0]，而 a[2, 1]的插值值给出 output[1]。
>>> inds = np.array([[0.5, 2], [0.5, 4]])
>>> ndimage.map_coordinates(a, inds, order=1, cval=-33.3)
array([ 2\. , -33.3])
>>> ndimage.map_coordinates(a, inds, order=1, mode='nearest')
array([ 2., 8.])
>>> ndimage.map_coordinates(a, inds, order=1, cval=0, output=bool)
array([ True, False], dtype=bool)
scipy.ndimage.rotate
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.rotate.html#scipy.ndimage.rotate
scipy.ndimage.rotate(input, angle, axes=(1, 0), reshape=True, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
旋转数组。
使用请求的阶数的样条插值，围绕由axes参数给出的两个轴定义的平面旋转数组。
参数：
inputarray_like
输入数组。
anglefloat
旋转角度（以度为单位）。
axes两个整数的元组，可选
定义旋转平面的两个轴。默认值为前两个轴。
reshapebool，可选
如果reshape为真，则调整输出形状，以便输入数组完全包含在输出中。默认为 True。
outputarray 或 dtype，可选
要放置输出的数组，或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
orderint，可选
样条插值的顺序，默认为 3。顺序必须在 0-5 范围内。
mode{‘reflect’，‘grid-mirror’，‘constant’，‘grid-constant’，‘nearest’，‘mirror’，‘grid-wrap’，‘wrap’}，可选
mode参数确定如何扩展输入数组超出其边界。默认为‘constant’。每个有效值的行为如下（请参见边界模式的附加图和细节）：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过关于最后一个像素边缘的反射来扩展。这种模式有时也称为半采样对称。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’ (k k k k | a b c d | k k k k)
输入通过使用由cval参数定义的相同常数值来填充边缘之外的所有值来扩展。不在输入边缘之外执行插值。
‘grid-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)
输入通过关于最后一个像素中心的反射来扩展。这种模式有时也称为整采样对称。
‘grid-wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相反边缘进行扩展。
‘wrap’ (d b c d | a b c d | b c a b)
输入通过环绕到相反边缘的方式进行扩展，但最后一个点和初始点完全重叠。在这种情况下，在重叠点选择哪个样本是不明确的。
cval标量，可选
如果mode为‘constant’，则用于填充输入边缘之外的值。默认值为 0.0。
prefilterbool，可选
决定是否对输入数组进行预过滤，使用spline_filter进行插值之前。默认为 True，如果order > 1，将创建一个临时的float64数组来存储过滤后的值。如果将其设置为 False，则输出在order > 1时会稍微模糊，除非输入已经经过预过滤，即调用spline_filter处理过原始输入。
返回：
rotate ndarray
旋转后的输入图像。
注意
对于复数input，此函数独立旋转实部和虚部。
1.6.0 版新增：支持复数数值。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure(figsize=(10, 3))
>>> ax1, ax2, ax3 = fig.subplots(1, 3)
>>> img = datasets.ascent()
>>> img_45 = ndimage.rotate(img, 45, reshape=False)
>>> full_img_45 = ndimage.rotate(img, 45, reshape=True)
>>> ax1.imshow(img, cmap='gray')
>>> ax1.set_axis_off()
>>> ax2.imshow(img_45, cmap='gray')
>>> ax2.set_axis_off()
>>> ax3.imshow(full_img_45, cmap='gray')
>>> ax3.set_axis_off()
>>> fig.set_layout_engine('tight')
>>> plt.show()
>>> print(img.shape)
(512, 512)
>>> print(img_45.shape)
(512, 512)
>>> print(full_img_45.shape)
(724, 724)
scipy.ndimage.shift
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.shift.html#scipy.ndimage.shift
scipy.ndimage.shift(input, shift, output=None, order=3, mode='constant', cval=0.0, prefilter=True)
移动数组。
数组使用请求的阶数的样条插值进行移动。超出输入边界的点根据给定的模式进行填充。
参数：
inputarray_like
输入数组。
shift浮点数或序列
轴上的移动量。如果是浮点数，shift对每个轴都是相同的。如果是序列，shift应包含每个轴的一个值。
output数组或 dtype，可选
用于放置输出的数组，或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
order整数，可选
样条插值的顺序，默认为 3。顺序必须在 0-5 的范围内。
mode{‘reflect’, ‘grid-mirror’, ‘constant’, ‘grid-constant’, ‘nearest’, ‘mirror’, ‘grid-wrap’, ‘wrap’}，可选
mode参数决定了如何扩展输入数组超出其边界的部分。默认为‘constant’。每个有效值的行为如下（请参阅边界模式的额外图表和详细信息）：
‘reflect’（d c b a | a b c d | d c b a）
输入通过在最后一个像素的边缘周围反射来进行扩展。有时也称为半样本对称。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’（k k k k | a b c d | k k k k）
输入通过使用由cval参数定义的相同常量值来填充超出边缘的所有值来进行扩展。超出输入边界的地方不执行插值。
‘grid-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）
输入通过在最后一个像素的中心周围反射来进行扩展。有时也称为整样本对称。
‘grid-wrap’（a b c d | a b c d | a b c d）
输入通过围绕到相对边缘的对面来进行扩展。
‘wrap’（d b c d | a b c d | b c a b）
输入通过围绕到相对边缘的对面来进行扩展，但是以使最后点和初始点完全重叠的方式。在这种情况下，不清楚在重叠点会选择哪个样本。
cval标量，可选
如果mode为‘constant’，用于填充输入边界之外的值。默认为 0.0。
prefilter布尔值，可选
确定输入数组在插值之前是否使用spline_filter进行预过滤。默认为 True，如果order > 1，将创建一个临时的float64数组来存储过滤后的值。如果设置为 False，则输出会略微模糊，除非输入已预过滤，即调用spline_filter后的原始输入。
返回：
shift ndarray
移动后的输入。
另请参阅
affine_transform
仿射变换
注意
对于复数input，此函数独立移动实部和虚部。
自1.6.0版本新增：添加复数支持。
示例
导入必要的模块和示例图像。
>>> from scipy.ndimage import shift
>>> import matplotlib.pyplot as plt
>>> from scipy import datasets
>>> image = datasets.ascent()
将图像垂直向上移动20像素。
>>> image_shifted_vertically = shift(image, (20, 0))
将图像垂直向上移动-200像素，水平向右移动100像素。
>>> image_shifted_both_directions = shift(image, (-200, 100))
绘制原始图像和移动后的图像。
>>> 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(image)
>>> top.set_title("Original image")
>>> middle.imshow(image_shifted_vertically)
>>> middle.set_title("Vertically shifted image")
>>> bottom.imshow(image_shifted_both_directions)
>>> bottom.set_title("Image shifted in both directions")
>>> fig.tight_layout()
scipy.ndimage.spline_filter
scipy.ndimage.spline_filter(input, order=3, output=<class 'numpy.float64'>, mode='mirror')
多维样条滤波器。
参数：
inputarray_like
输入数组。
orderint，可选
样条的顺序，默认为 3。
outputndarray 或 dtype，可选
用于放置输出的数组或返回数组的数据类型。默认为numpy.float64。
mode{‘reflect’，‘grid-mirror’，‘constant’，‘grid-constant’，‘nearest’，‘mirror’，‘grid-wrap’，‘wrap’}，可选
mode参数确定输入数组在其边界之外如何扩展。默认为‘mirror’。每个有效值的行为如下（参见边界模式的附加图和详细信息）：
‘reflect’（d c b a | a b c d | d c b a)
输入通过最后一个像素的边缘反射进行扩展。此模式有时也称为半样本对称。
‘grid-mirror’
这是“reflect”的同义词。
‘constant’（k k k k | a b c d | k k k k)
输入通过填充所有超出边缘的值相同的常量值（由cval参数定义）进行扩展。超出输入边界的部分不进行插值。
‘grid-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)
输入通过最后一个像素的中心反射进行扩展。此模式有时也称为整样本对称。
‘grid-wrap’（a b c d | a b c d | a b c d)
输入通过环绕到相反边缘进行扩展。
‘wrap’（d b c d | a b c d | b c a b)
输入通过包装到相反边缘进行扩展，但以确保最后一个点和初始点完全重叠的方式。在这种情况下，无法定义在重叠点选择哪个样本。
返回：
spline_filterndarray
过滤后的数组。形状与input相同。
另见
spline_filter1d
沿给定轴计算 1-D 样条滤波器。
注意事项
多维滤波器实现为一系列 1-D 样条滤波器。中间数组以与输出相同的数据类型存储。因此，对于精度有限的输出类型，结果可能不精确，因为中间结果可能存储有限精度。
对于复值input，此函数独立处理实部和虚部。
自 1.6.0 版本开始：增加了对复数支持。
示例
我们可以使用多维样条对图像进行滤波：
>>> from scipy.ndimage import spline_filter
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> orig_img = np.eye(20) # create an image
>>> orig_img[10, :] = 1.0
>>> sp_filter = spline_filter(orig_img, order=3)
>>> f, ax = plt.subplots(1, 2, sharex=True)
>>> for ind, data in enumerate([[orig_img, "original image"],
... [sp_filter, "spline filter"]]):
... ax[ind].imshow(data[0], cmap='gray_r')
... ax[ind].set_title(data[1])
>>> plt.tight_layout()
>>> plt.show()
scipy.ndimage.spline_filter1d
scipy.ndimage.spline_filter1d(input, order=3, axis=-1, output=<class 'numpy.float64'>, mode='mirror')
沿给定轴计算 1-D 样条滤波器。
沿给定轴的数组行通过样条滤波器进行滤波。样条的顺序必须 >= 2 且 <= 5。
参数：
inputarray_like
输入数组。
orderint，可选
样条的顺序，默认为 3。
axisint，可选
应用样条滤波器的轴。默认为最后一个轴。
outputndarray 或 dtype，可选
放置输出的数组或返回数组的 dtype。默认为numpy.float64。
mode{‘reflect’, ‘grid-mirror’, ‘constant’, ‘grid-constant’, ‘nearest’, ‘mirror’, ‘grid-wrap’, ‘wrap’}，可选
mode 参数决定了如何扩展输入数组超出其边界。默认为‘mirror’。每个有效值的行为如下（请参见边界模式上的附加图和详细信息）：
‘reflect’（d c b a | a b c d | d c b a）
输入通过反射最后一个像素的边缘来扩展。这种模式有时也称为半样本对称。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’（k k k k | a b c d | k k k k）
通过使用由 cval 参数定义的相同常量值填充超出边缘的所有值来扩展输入。超出输入边缘不执行插值。
‘grid-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）
输入通过反射最后一个像素的中心来扩展。这种模式有时也称为全样本对称。
‘grid-wrap’（a b c d | a b c d | a b c d）
输入通过环绕到相对边缘来扩展。
‘wrap’（d b c d | a b c d | b c a b）
输入通过环绕到相对边缘，但在最后点和初始点完全重叠的方式扩展。在这种情况下，不确定在重叠点将选择哪个样本。
返回：
spline_filter1dndarray
过滤后的输入。
参见
多维样条滤波器。
注释
ndimage中的所有插值函数都对输入图像进行样条插值。如果使用阶数 > 1的 B 样条，则必须先将输入图像值转换为 B 样条系数，这是通过依次沿输入的所有轴应用此 1-D 滤波器来完成的。所有需要 B 样条系数的函数将自动过滤它们的输入，这种行为可以通过prefilter关键字参数进行控制。对于接受mode参数的函数，仅当结果与滤波时使用的mode匹配时，结果才正确。
对于复数输入，该函数独立处理实部和虚部。
新功能在版本 1.6.0 中添加：增加了对复数支持。
示例
我们可以沿指定轴使用 1-D 样条滤波来过滤图像：
>>> from scipy.ndimage import spline_filter1d
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> orig_img = np.eye(20) # create an image
>>> orig_img[10, :] = 1.0
>>> sp_filter_axis_0 = spline_filter1d(orig_img, axis=0)
>>> sp_filter_axis_1 = spline_filter1d(orig_img, axis=1)
>>> f, ax = plt.subplots(1, 3, sharex=True)
>>> for ind, data in enumerate([[orig_img, "original image"],
... [sp_filter_axis_0, "spline filter (axis=0)"],
... [sp_filter_axis_1, "spline filter (axis=1)"]]):
... ax[ind].imshow(data[0], cmap='gray_r')
... ax[ind].set_title(data[1])
>>> plt.tight_layout()
>>> plt.show()
scipy.ndimage.zoom
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.zoom.html#scipy.ndimage.zoom
scipy.ndimage.zoom(input, zoom, output=None, order=3, mode='constant', cval=0.0, prefilter=True, *, grid_mode=False)
缩放数组。
通过请求的顺序进行样条插值来缩放数组。
参数：
inputarray_like
输入数组。
zoomfloat or sequence
沿轴的缩放因子。如果是浮点数，zoom对每个轴都是相同的。如果是序列，zoom应包含每个轴的一个值。
outputarray or dtype, optional
放置输出的数组或返回数组的 dtype。默认情况下，将创建与输入相同 dtype 的数组。
orderint, optional
样条插值的顺序，默认为 3。顺序必须在 0-5 的范围内。
mode{‘reflect’, ‘grid-mirror’, ‘constant’, ‘grid-constant’, ‘nearest’, ‘mirror’, ‘grid-wrap’, ‘wrap’}, optional
mode参数确定如何扩展输入数组超出其边界的方式。默认值为‘constant’。每个有效值的行为如下（参见边界模式的其他图表和详细信息）：
‘reflect’ (d c b a | a b c d | d c b a)
输入通过关于最后一个像素的边缘进行反射来扩展。此模式有时也称为半样本对称。
‘grid-mirror’
这是‘reflect’的同义词。
‘constant’ (k k k k | a b c d | k k k k)
输入通过使用定义的cval参数填充超出输入边缘的所有值进行扩展。超出输入边缘不执行插值。
‘grid-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)
输入通过关于最后一个像素的中心进行反射来扩展。此模式有时也称为整样本对称。
‘grid-wrap’ (a b c d | a b c d | a b c d)
输入通过环绕到相反边缘进行扩展。
‘wrap’ (d b c d | a b c d | b c a b)
输入通过环绕到相反边缘来进行扩展，但最后一个点和初始点完全重叠。在这种情况下，无法定义在重叠点选择哪个样本。
cvalscalar, optional
如果mode是‘constant’，用于填充输入边缘之外的值的值。默认值为 0.0。
prefilterbool, optional
确定输入数组在插值之前是否使用了spline_filter进行预过滤。默认值为 True，如果order > 1，将创建一个临时的float64数组来存储过滤后的值。如果将其设置为 False，则在order > 1时输出会稍微模糊，除非输入已经预过滤，即调用spline_filter得到的结果。
grid_modebool，可选
如果为 False，则从像素中心的距离被缩放。否则，包括完整像素范围的距离被使用。例如，长度为 5 的 1 维信号在grid_mode为 False 时被认为有长度 4，但在grid_mode为 True 时长度为 5。参见以下视觉说明：
| pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 |
|<-------------------------------------->|
vs.
|<----------------------------------------------->|
上图箭头的起始点对应每种模式中坐标位置 0。
返回：
zoomndarray
缩放后的输入。
注释
对于复数输入，此函数将独立缩放实部和虚部。
自版本 1.6.0 起：增加了对复数支持。
示例
>>> from scipy import ndimage, datasets
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> ax1 = fig.add_subplot(121) # left side
>>> ax2 = fig.add_subplot(122) # right side
>>> ascent = datasets.ascent()
>>> result = ndimage.zoom(ascent, 3.0)
>>> ax1.imshow(ascent, vmin=0, vmax=255)
>>> ax2.imshow(result, vmin=0, vmax=255)
>>> plt.show()
>>> print(ascent.shape)
(512, 512)
>>> print(result.shape)
(1536, 1536)
scipy.ndimage.center_of_mass
scipy.ndimage.center_of_mass(input, labels=None, index=None)
在标签处计算数组值的质心。
参数：
输入ndarray
用于计算质心的数据。质量可以是正或负。
标签ndarray，可选
输入中对象的标签，由ndimage.label生成。仅与索引一起使用。维度必须与输入相同。
索引int 或整数序列，可选
用于计算质心的标签。如果未指定，则将计算大于零的所有标签的组合质心。仅与标签一起使用。
返回：
质心元组或元组列表
质心坐标。
示例
>>> import numpy as np
>>> a = np.array(([0,0,0,0],
... [0,1,1,0],
... [0,1,1,0],
... [0,1,1,0]))
>>> from scipy import ndimage
>>> ndimage.center_of_mass(a)
(2.0, 1.5)
图像中多个对象的计算
>>> b = np.array(([0,1,1,0],
... [0,1,0,0],
... [0,0,0,0],
... [0,0,1,1],
... [0,0,1,1]))
>>> lbl = ndimage.label(b)[0]
>>> ndimage.center_of_mass(b, lbl, [1,2])
[(0.33333333333333331, 1.3333333333333333), (3.5, 2.5)]
接受负质量，例如当由于随机噪声而从测量数据中去除偏差时可能发生。
>>> c = np.array(([-1,0,0,0],
... [0,-1,-1,0],
... [0,1,-1,0],
... [0,1,1,0]))
>>> ndimage.center_of_mass(c)
(-4.0, 1.0)
如果存在除零问题，该函数不会引发错误，而是在返回 inf 和/或 NaN 之前发出 RuntimeWarning。
>>> d = np.array([-1, 1])
>>> ndimage.center_of_mass(d)
(inf,)
scipy.ndimage.extrema
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.extrema.html#scipy.ndimage.extrema
scipy.ndimage.extrema(input, labels=None, index=None)
计算数组在标签处的值的最小值和最大值，以及它们的位置。
参数：
input ndarray
要处理的 N-D 图像数据。
labels ndarray，可选
输入中的特征标签。如果不是 None，则必须与input的形状相同。
index int 或 int 序列，可选
要包含在输出中的标签。如果为 None（默认），则使用所有非零标签的值。
返回：
minimums, maximums int 或 ndarray
每个特征中最小值和最大值的值。
min_positions, max_positions tuple 或 元组列表
每个元组给出相应最小值或最大值的 N-D 坐标。
另请参见
maximum, minimum, maximum_position, minimum_position, center_of_mass
示例
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.extrema(a)
(0, 9, (0, 2), (3, 0))
可以使用标签和索引来指定要处理的特征：
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.extrema(a, lbl, index=np.arange(1, nlbl+1))
(array([1, 4, 3]),
array([5, 7, 9]),
[(0, 0), (1, 3), (3, 1)],
[(1, 0), (2, 3), (3, 0)])
如果未给出索引，则处理非零标签：
>>> ndimage.extrema(a, lbl)
(1, 9, (0, 0), (3, 0))
scipy.ndimage.find_objects
scipy.ndimage.find_objects(input, max_label=0)
在标记数组中查找对象。
参数：
input整数的 ndarray
包含由不同标签定义的对象的数组。值为 0 的标签将被忽略。
max_label整数，可选
在输入中要搜索的最大标签。如果未给出 max_label，则返回所有对象的位置。
返回值：
object_slices元组列表
一个元组列表，每个元组包含 N 个切片（其中 N 是输入数组的维数）。切片对应于包含对象的最小平行四边形体。如果有数字缺失，则返回 None 而不是切片。标签l对应于返回列表中的索引l-1。
另请参阅
注意事项
此函数非常适用于在 3D 数组中隔离感兴趣的体积，无法“透视”。
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.zeros((6,6), dtype=int)
>>> a[2:4, 2:4] = 1
>>> a[4, 4] = 1
>>> a[:2, :3] = 2
>>> a[0, 5] = 3
>>> a
array([[2, 2, 2, 0, 0, 3],
[2, 2, 2, 0, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0]])
>>> ndimage.find_objects(a)
[(slice(2, 5, None), slice(2, 5, None)),
(slice(0, 2, None), slice(0, 3, None)),
(slice(0, 1, None), slice(5, 6, None))]
>>> ndimage.find_objects(a, max_label=2)
[(slice(2, 5, None), slice(2, 5, None)), (slice(0, 2, None), slice(0, 3, None))]
>>> ndimage.find_objects(a == 1, max_label=2)
[(slice(2, 5, None), slice(2, 5, None)), None]
>>> loc = ndimage.find_objects(a)[0]
>>> a[loc]
array([[1, 1, 0],
[1, 1, 0],
[0, 0, 1]])
scipy.ndimage.histogram
scipy.ndimage.histogram(input, min, max, bins, labels=None, index=None)
计算数组值的直方图，可选择在标签处。
直方图计算数组中在由 min、max 和 bins 决定的区间内数值的频率。labels 和 index 关键字可以限制直方图的范围到数组中指定的子区域。
参数：
input类数组
要计算直方图的数据。
min, max整数
直方图区间的最小值和最大值。
bins整数
bins 的数量。
labels类数组，可选
input 中对象的标签。如果不为 None，则必须与 input 的形状相同。
index整数或整数序列，可选
计算直方图时要使用的标签或标签。如果为 None，则使用标签大于零的所有值。
返回：
hist ndarray
直方图计数。
示例
>>> import numpy as np
>>> a = np.array([[ 0. , 0.2146, 0.5962, 0. ],
... [ 0. , 0.7778, 0. , 0. ],
... [ 0. , 0. , 0. , 0. ],
... [ 0. , 0. , 0.7181, 0.2787],
... [ 0. , 0. , 0.6573, 0.3094]])
>>> from scipy import ndimage
>>> ndimage.histogram(a, 0, 1, 10)
array([13, 0, 2, 1, 0, 1, 1, 2, 0, 0])
使用标签而没有索引时，将计算非零元素：
>>> lbl, nlbl = ndimage.label(a)
>>> ndimage.histogram(a, 0, 1, 10, lbl)
array([0, 0, 2, 1, 0, 1, 1, 2, 0, 0])
可以使用索引来仅计数特定对象：
>>> ndimage.histogram(a, 0, 1, 10, lbl, 2)
array([0, 0, 1, 1, 0, 0, 1, 1, 0, 0])
scipy.ndimage.label
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.label.html#scipy.ndimage.label
scipy.ndimage.label(input, structure=None, output=None)
在数组中标记特征。
参数：
输入array_like
要标记的类似数组对象。输入中的任何非零值都将被视为特征，而零值将被视为背景。
结构array_like，可选
定义特征连接的结构元素。结构必须是中心对称的（见注释）。如果未提供结构元素，则将自动生成一个平方连接度为 1 的结构元素。即，对于 2-D 输入数组，默认结构元素是：
[[0,1,0],
[1,1,1],
[0,1,0]]
输出(None, 数据类型, array_like)，可选
如果输出是数据类型，则指定结果标记特征数组的类型。如果输出是类似数组的对象，则将从此函数中的标记特征更新输出。此函数可以通过将 output=input 来原位操作。请注意，输出必须能够存储最大的标签，否则此函数将引发异常。
返回：
标签ndarray 或 int
整数 ndarray，其中输入中的每个唯一特征在返回的数组中有一个唯一标签。
num_featuresint
找到了多少个对象。
如果输出为 None，则此函数返回一个元组（labeled_array，num_features）。
如果输出是一个 ndarray，则它将使用labeled_array中的值进行更新，并且此函数仅返回num_features。
另请参阅
find_objects
生成用于标记特征（或对象）位置或尺寸的切片列表
注释
中心对称矩阵是关于中心对称的矩阵。有关更多信息，请参见[1]。
结构矩阵必须是中心对称的，以确保双向连接。例如，如果结构矩阵不是中心对称的，并定义为：
[[0,1,0],
[1,1,0],
[0,0,0]]
并且输入是：
[[1,2],
[0,3]]
那么结构矩阵将指示输入中的条目 2 连接到 1，但 1 不连接到 2。
参考文献
[1]
James R. Weaver，“中心对称（交叉对称）矩阵，它们的基本属性，特征值和特征向量。” 美国数学月刊 92.10（1985）：711-717。
示例
创建一个具有一些特征的图像，然后使用默认的（十字形的）结构元素对其进行标记：
>>> from scipy.ndimage import label, generate_binary_structure
>>> import numpy as np
>>> a = np.array([[0,0,1,1,0,0],
... [0,0,0,1,0,0],
... [1,1,0,0,1,0],
... [0,0,0,1,0,0]])
>>> labeled_array, num_features = label(a)
每个特征都用不同的整数标记：
>>> num_features
4
>>> labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 3, 0],
[0, 0, 0, 4, 0, 0]])
生成一个将考虑特征连接的结构元素，即使它们对角接触：
>>> s = generate_binary_structure(2,2)
或者，
>>> s = [[1,1,1],
... [1,1,1],
... [1,1,1]]
使用新的结构元素标记图像：
>>> labeled_array, num_features = label(a, structure=s)
显示 2 个标记的特征（请注意，上述的特征 1、3 和 4 现在被视为单个特征）：
>>> num_features
2
>>> labeled_array
array([[0, 0, 1, 1, 0, 0],
[0, 0, 0, 1, 0, 0],
[2, 2, 0, 0, 1, 0],
[0, 0, 0, 1, 0, 0]])
scipy.ndimage.labeled_comprehension
scipy.ndimage.labeled_comprehension(input, labels, index, func, out_dtype, default, pass_positions=False)
大致相当于[func(input[labels == i]) for i in index]。
顺序地将任意函数（适用于类似数组的输入）应用于由labels和index指定的 N-D 图像数组的子集。有选项以位置参数形式提供函数作为第二个参数。
参数：
input类似数组
数据用于选择处理标签。
labels类似数组或 None
input中对象的标签。如果不为 None，则数组必须与input具有相同的形状。如果为 None，则将func应用于展平的input。
indexint、int 序列或 None
要应用func的labels子集。如果是标量，则返回单个值。如果为 None，则将func应用于labels的所有非零值。
func可调用对象
应用于input中的labels的 Python 函数。
out_dtype数据类型
用于result的数据类型。
defaultint、float 或 None
当index的元素在labels中不存在时的默认返回值。
pass_positions布尔值，可选
如果为 True，则将线性索引作为第二个参数传递给func。默认为 False。
返回：
result ndarray
将func应用于input中的每个labels到index的结果。
示例
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> lbl, nlbl = ndimage.label(a)
>>> lbls = np.arange(1, nlbl+1)
>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, 0)
array([ 2.75, 5.5 , 6\. ])
返回到default：
>>> lbls = np.arange(1, nlbl+2)
>>> ndimage.labeled_comprehension(a, lbl, lbls, np.mean, float, -1)
array([ 2.75, 5.5 , 6\. , -1\. ])
传递位置：
>>> def fn(val, pos):
... print("fn says: %s : %s" % (val, pos))
... return (val.sum()) if (pos.sum() % 2 == 0) else (-val.sum())
...
>>> ndimage.labeled_comprehension(a, lbl, lbls, fn, float, 0, True)
fn says: [1 2 5 3] : [0 1 4 5]
fn says: [4 7] : [ 7 11]
fn says: [9 3] : [12 13]
array([ 11., 11., -12., 0.])
scipy.ndimage.maximum
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.maximum.html#scipy.ndimage.maximum
scipy.ndimage.maximum(input, labels=None, index=None)
计算数组在标记区域上的最大值。
参数：
input：array_like
值的数组。对于由labels指定的每个区域，计算input在该区域内的最大值。
labels：array_like，可选
一个整数数组，标记了要计算input最大值的不同区域。labels必须与input具有相同的形状。如果未指定labels，则返回整个数组的最大值。
index：array_like，可选
一个包含用于计算最大值的区域标签的列表。如果index为 None，则返回labels非零的所有元素的最大值。
返回：
output：float 或 浮点数列表
返回input在labels确定的区域中的最大值列表，并且其索引在index中。如果未指定index或labels，则返回一个浮点数：如果labels为 None，则返回input的最大值；如果index为 None，则返回labels大于零的元素的最大值。
另请参见
label, minimum, median, maximum_position, extrema, sum, mean, variance
standard_deviation
注意
函数返回一个 Python 列表，而不是 NumPy 数组，使用np.array将列表转换为数组。
示例
>>> import numpy as np
>>> a = np.arange(16).reshape((4,4))
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> labels = np.zeros_like(a)
>>> labels[:2,:2] = 1
>>> labels[2:, 1:3] = 2
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 0],
[0, 2, 2, 0],
[0, 2, 2, 0]])
>>> from scipy import ndimage
>>> ndimage.maximum(a)
15.0
>>> ndimage.maximum(a, labels=labels, index=[1,2])
[5.0, 14.0]
>>> ndimage.maximum(a, labels=labels)
14.0
>>> b = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(b)
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.maximum(b, labels=labels, index=np.arange(1, labels_nb + 1))
[5.0, 7.0, 9.0]
scipy.ndimage.maximum_position
scipy.ndimage.maximum_position(input, labels=None, index=None)
查找数组值在标签处的最大值位置。
对于由labels指定的每个区域，返回input内最大值的位置。
参数：
input类似数组
数组或类似数组的值。
labels数组或类似数组，可选
一个标记了不同区域的整数数组，用于计算input的最大值位置。labels必须与input具有相同的形状。如果未指定labels，则返回整个数组的第一个极大值的位置。
参数labels指定时，index参数才有效。
index数组或类似数组，可选
一个包含区域标签的列表，用于找到极大值的位置。如果index为 None，则返回所有元素中第一个非零labels的最大值。
参数labels指定时，index参数才有效。
返回：
output整数元组列表
指定index中的索引并且由labels确定的input的最大值的位置的整数元组列表。
如果未指定index或labels，则返回一个整数元组，指定input的第一个最大值的位置。
参见
label, minimum, median, maximum_position, extrema, sum, mean, variance
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> ndimage.maximum_position(a)
(3, 0)
可使用labels和index指定要处理的特征：
>>> lbl = np.array([[0, 1, 2, 3],
... [0, 1, 2, 3],
... [0, 1, 2, 3],
... [0, 1, 2, 3]])
>>> ndimage.maximum_position(a, lbl, 1)
(1, 1)
如果没有给出索引，则处理非零labels：
>>> ndimage.maximum_position(a, lbl)
(2, 3)
如果没有极大值，则返回第一个元素的位置：
>>> ndimage.maximum_position(a, lbl, 2)
(0, 2)
scipy.ndimage.mean
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.mean.html#scipy.ndimage.mean
scipy.ndimage.mean(input, labels=None, index=None)
计算数组在标签处值的平均值。
参数：
input：array_like
要计算区域内元素平均值的数组。
labels：array_like，可选
具有与 input 相同形状的标签数组，或者可以广播到与 input 相同形状的数组。所有共享相同标签的元素形成一个区域，计算其元素的平均值。
index：int 或 int 序列，可选
要计算其平均值的对象的标签。默认为 None，此时计算标签大于 0 的所有值的平均值。
返回：
out：list
与 index 长度相同的序列，其中包含由 index 中标记的不同区域的平均值。
另请参阅
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.arange(25).reshape((5,5))
>>> labels = np.zeros_like(a)
>>> labels[3:5,3:5] = 1
>>> index = np.unique(labels)
>>> labels
array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 1, 1],
[0, 0, 0, 1, 1]])
>>> index
array([0, 1])
>>> ndimage.mean(a, labels=labels, index=index)
[10.285714285714286, 21.0]
scipy.ndimage.median
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.median.html#scipy.ndimage.median
scipy.ndimage.median(input, labels=None, index=None)
计算带有标记区域的数组值的中位数。
参数：
input 数组类型
数组值的 Array_like。对于labels指定的每个区域，计算input在该区域上的中位数值。
labels 数组类型，可选
一个整数数组，标记计算input中位数值的不同区域。labels必须与input具有相同的形状。如果未指定labels，则返回整个数组的中位数值。
index 数组类型，可选
用于计算中位数值的区域标签列表。如果index为 None，则返回labels非零的所有元素的中位数值。
返回值：
median 浮点数或浮点数列表
根据labels确定的区域上，返回index的中位数列表。如果index或labels未指定，则返回一个浮点数：如果labels为 None，则返回input的中位数值；如果index为 None，则返回labels大于零的元素的中位数值。
另请参阅
label，minimum，maximum，extrema，sum，mean，variance，standard_deviation
注意
函数返回 Python 列表而不是 NumPy 数组，使用np.array将列表转换为数组。
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 1],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(a)
>>> labels
array([[1, 1, 0, 2],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.median(a, labels=labels, index=np.arange(1, labels_nb + 1))
[2.5, 4.0, 6.0]
>>> ndimage.median(a)
1.0
>>> ndimage.median(a, labels=labels)
3.0
scipy.ndimage.minimum
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.ndimage.minimum.html#scipy.ndimage.minimum
scipy.ndimage.minimum(input, labels=None, index=None)
计算数组中标记区域上的值的最小值。
参数：
输入array_like
值的数组。对于 labels 指定的每个区域，计算区域内 input 的最小值。
标签array_like，可选
一个整数的数组，标记了要计算 input 最小值的不同区域。labels 必须与 input 的形状相同。如果未指定 labels，则返回整个数组的最小值。
索引array_like，可选
一个区域标签列表，用于计算最小值。如果索引为 None，则返回 labels 非零元素的所有元素的最小值。
返回：
最小值浮点数或浮点数列表
labels 确定的区域内 input 的最小值列表，其索引在 index 中。如果未指定 index 或 labels，则返回一个浮点数：如果 labels 为 None，则返回 input 的最小值，如果 index 为 None，则返回 labels 大于零的元素的最小值。
另请参阅
标签, 最大, 中位数, 最小位置, 极值, 和, 均值, 方差
注意
函数返回一个 Python 列表而不是 NumPy 数组，使用 np.array 将列表转换为数组。
示例
>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> labels, labels_nb = ndimage.label(a)
>>> labels
array([[1, 1, 0, 0],
[1, 1, 0, 2],
[0, 0, 0, 2],
[3, 3, 0, 0]])
>>> ndimage.minimum(a, labels=labels, index=np.arange(1, labels_nb + 1))
[1.0, 4.0, 3.0]
>>> ndimage.minimum(a)
0.0
>>> ndimage.minimum(a, labels=labels)
1.0
scipy.ndimage.minimum_position
scipy.ndimage.minimum_position(input, labels=None, index=None)
在标签处找到数组值的最小值位置。
参数：
inputarray_like
数值数组。
labelsarray_like，可选
一个整数数组，标记了计算input最小值位置的不同区域。labels必须与input具有相同的形状。如果未指定labels，则返回整个数组的第一个最小值位置。
labels参数仅在指定index时有效。
indexarray_like，可选
一个区域标签列表，用于查找最小值位置。如果index为 None，则返回所有labels非零元素处的第一个最小值。
index参数仅在指定labels时有效。
返回：
output整数元组列表
一个整数元组或整数元组列表，指定了input在由labels确定的区域中的最小值位置，并且其索引在index中。
如果未指定index或labels，则返回一个整数元组，指定了input的第一个最小值位置。
参见
label，minimum，median，maximum_position，extrema，sum，mean，variance
standard_deviation
示例
>>> import numpy as np
>>> a = np.array([[10, 20, 30],
... [40, 80, 100],
... [1, 100, 200]])
>>> b = np.array([[1, 2, 0, 1],
... [5, 3, 0, 4],
... [0, 0, 0, 7],
... [9, 3, 0, 0]])
>>> from scipy import ndimage
>>> ndimage.minimum_position(a)
(2, 0)
>>> ndimage.minimum_position(b)
(0, 2)
可以使用labels和index指定要处理的特征：
>>> label, pos = ndimage.label(a)
>>> ndimage.minimum_position(a, label, index=np.arange(1, pos+1))
[(2, 0)]
>>> label, pos = ndimage.label(b)
>>> ndimage.minimum_position(b, label, index=np.arange(1, pos+1))
[(0, 0), (0, 3), (3, 1)]
