SciPy-1-12-中文文档-八-
SciPy 1.12 中文文档(八)
scipy.linalg.circulant
scipy.linalg.circulant(c)
构造一个循环矩阵。
参数:
c(N,) array_like
1-D 数组,矩阵的第一列。
Returns:
A(N, N) ndarray
一个首列为 c 的循环矩阵。
参见
Toeplitz 矩阵
Hankel 矩阵
解决循环系统。
注解
自版本 0.8.0 新增
示例
>>> from scipy.linalg import circulant
>>> circulant([1, 2, 3])
array([[1, 3, 2],
[2, 1, 3],
[3, 2, 1]])
scipy.linalg.companion
scipy.linalg.companion(a)
创建一个伴随矩阵。
创建与系数在 a 中给出的多项式相关联的伴随矩阵 [1]。
Parameters:
a(N,) 数组类似
1-D 数组的多项式系数。a 的长度至少为两个,并且 a[0]
不能为零。
Returns:
c(N-1, N-1) 的 ndarray
c 的第一行是 -a[1:]/a[0]
,第一个次对角线全为 1。数组的数据类型与 1.0*a[0]
的数据类型相同。
Raises:
ValueError
如果以下任一条件为真:a) a.ndim != 1
; b) a.size < 2
; c) a[0] == 0
。
Notes
新版本 0.8.0 中引入。
References
[1]
R. A. Horn & C. R. Johnson,《矩阵分析》。英国剑桥:剑桥大学出版社,1999 年,第 146-7 页。
示例
>>> from scipy.linalg import companion
>>> companion([1, -10, 31, -30])
array([[ 10., -31., 30.],
[ 1., 0., 0.],
[ 0., 1., 0.]])
scipy.linalg.convolution_matrix
scipy.linalg.convolution_matrix(a, n, mode='full')
构造一个卷积矩阵。
构造表示一维卷积的 Toeplitz 矩阵[1]。详细信息请参见下面的注释。
参数:
a(m,) array_like
要卷积的一维数组。
nint
结果矩阵中的列数。它给出要与 a 进行卷积的输入长度。这类似于 numpy.convolve(a, v)
中 v 的长度。
modestr
这类似于 numpy.convolve(v, a, mode)
中的 mode。它必须是 (‘full’, ‘valid’, ‘same’) 之一。有关 mode 如何确定结果形状,请参见下文。
返回:
A(k, n) ndarray
卷积矩阵的行数 k 取决于 mode:
======= =========================
mode k
======= =========================
'full' m + n -1
'same' max(m, n)
'valid' max(m, n) - min(m, n) + 1
======= =========================
另见
toeplitz
Toeplitz 矩阵
注释
代码:
A = convolution_matrix(a, n, mode)
创建一个 Toeplitz 矩阵 A,使得 A @ v
等同于使用 convolve(a, v, mode)
。返回的数组始终有 n 列。行数取决于上述指定的 mode。
在默认的 ‘full’ 模式下,A 的条目如下:
A[i, j] == (a[i-j] if (0 <= (i-j) < m) else 0)
其中 m = len(a)
。例如,输入数组为 [x, y, z]
。卷积矩阵的形式如下:
[x, 0, 0, ..., 0, 0]
[y, x, 0, ..., 0, 0]
[z, y, x, ..., 0, 0]
...
[0, 0, 0, ..., x, 0]
[0, 0, 0, ..., y, x]
[0, 0, 0, ..., z, y]
[0, 0, 0, ..., 0, z]
在 ‘valid’ 模式下,A 的条目如下:
A[i, j] == (a[i-j+m-1] if (0 <= (i-j+m-1) < m) else 0)
这对应于一个矩阵,其行是从 ‘full’ 情况中子集的行,其中 a 中的所有系数都包含在行中。对于输入 [x, y, z]
,此数组如下所示:
[z, y, x, 0, 0, ..., 0, 0, 0]
[0, z, y, x, 0, ..., 0, 0, 0]
[0, 0, z, y, x, ..., 0, 0, 0]
...
[0, 0, 0, 0, 0, ..., x, 0, 0]
[0, 0, 0, 0, 0, ..., y, x, 0]
[0, 0, 0, 0, 0, ..., z, y, x]
在 ‘same’ 模式下,A 的条目如下:
d = (m - 1) // 2
A[i, j] == (a[i-j+d] if (0 <= (i-j+d) < m) else 0)
“same” 模式的典型应用是当信号的长度为 n(其中 n 大于 len(a)
)时,所得输出为仍然长度为 n 的滤波信号。
对于输入 [x, y, z]
,此数组如下所示:
[y, x, 0, 0, ..., 0, 0, 0]
[z, y, x, 0, ..., 0, 0, 0]
[0, z, y, x, ..., 0, 0, 0]
[0, 0, z, y, ..., 0, 0, 0]
...
[0, 0, 0, 0, ..., y, x, 0]
[0, 0, 0, 0, ..., z, y, x]
[0, 0, 0, 0, ..., 0, z, y]
新增于版本 1.5.0。
参考文献
[1]
“卷积”,en.wikipedia.org/wiki/Convolution
示例
>>> import numpy as np
>>> from scipy.linalg import convolution_matrix
>>> A = convolution_matrix([-1, 4, -2], 5, mode='same')
>>> A
array([[ 4, -1, 0, 0, 0],
[-2, 4, -1, 0, 0],
[ 0, -2, 4, -1, 0],
[ 0, 0, -2, 4, -1],
[ 0, 0, 0, -2, 4]])
与使用 numpy.convolve
进行乘法比较。
>>> x = np.array([1, 2, 0, -3, 0.5])
>>> A @ x
array([ 2\. , 6\. , -1\. , -12.5, 8\. ])
验证 A @ x
是否产生与应用卷积函数相同的结果。
>>> np.convolve([-1, 4, -2], x, mode='same')
array([ 2\. , 6\. , -1\. , -12.5, 8\. ])
作为 mode='same'
情况的比较,这里显示了相同系数和大小的 mode='full'
和 mode='valid'
产生的矩阵。
>>> convolution_matrix([-1, 4, -2], 5, mode='full')
array([[-1, 0, 0, 0, 0],
[ 4, -1, 0, 0, 0],
[-2, 4, -1, 0, 0],
[ 0, -2, 4, -1, 0],
[ 0, 0, -2, 4, -1],
[ 0, 0, 0, -2, 4],
[ 0, 0, 0, 0, -2]])
>>> convolution_matrix([-1, 4, -2], 5, mode='valid')
array([[-2, 4, -1, 0, 0],
[ 0, -2, 4, -1, 0],
[ 0, 0, -2, 4, -1]])
scipy.linalg.dft
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.dft.html#scipy.linalg.dft
scipy.linalg.dft(n, scale=None)
离散傅里叶变换矩阵。
创建用于计算序列的离散傅里叶变换矩阵[1]。生成矩阵的第 n 个原根为 exp(-2pii/n),其中 i = sqrt(-1)。
参数:
nint
矩阵大小。
scalestr,可选
必须为 None、“sqrtn”或“n”。如果scale为“sqrtn”,则矩阵除以sqrt(n)。如果scale为“n”,则矩阵除以n。如果scale为 None(默认值),则矩阵不归一化,返回值仅为单位根的范德蒙德矩阵。
返回:
m(n, n) ndarray
DFT 矩阵。
注意事项
当scale为 None 时,用dft
返回的矩阵乘以向量,在数学上等同于(但效率远低于)scipy.fft.fft
执行的计算。
从版本 0.14.0 开始。
参考资料
[1]
“DFT 矩阵”,en.wikipedia.org/wiki/DFT_matrix
示例
>>> import numpy as np
>>> from scipy.linalg import dft
>>> np.set_printoptions(precision=2, suppress=True) # for compact output
>>> m = dft(5)
>>> m
array([[ 1\. +0.j , 1\. +0.j , 1\. +0.j , 1\. +0.j , 1\. +0.j ],
[ 1\. +0.j , 0.31-0.95j, -0.81-0.59j, -0.81+0.59j, 0.31+0.95j],
[ 1\. +0.j , -0.81-0.59j, 0.31+0.95j, 0.31-0.95j, -0.81+0.59j],
[ 1\. +0.j , -0.81+0.59j, 0.31-0.95j, 0.31+0.95j, -0.81-0.59j],
[ 1\. +0.j , 0.31+0.95j, -0.81+0.59j, -0.81-0.59j, 0.31-0.95j]])
>>> x = np.array([1, 2, 3, 0, 3])
>>> m @ x # Compute the DFT of x
array([ 9\. +0.j , 0.12-0.81j, -2.12+3.44j, -2.12-3.44j, 0.12+0.81j])
验证m @ x
等同于fft(x)
。
>>> from scipy.fft import fft
>>> fft(x) # Same result as m @ x
array([ 9\. +0.j , 0.12-0.81j, -2.12+3.44j, -2.12-3.44j, 0.12+0.81j])
scipy.linalg.fiedler
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.fiedler.html#scipy.linalg.fiedler
scipy.linalg.fiedler(a)
返回对称的 Fiedler 矩阵
给定一组数字 a,Fiedler 矩阵具有结构 F[i, j] = np.abs(a[i] - a[j])
,因此对角线为零且条目非负。Fiedler 矩阵具有主要的正特征值和其他负特征值。尽管不一般有效,对于特定输入,可以像 [1] 中给出的那样显式计算逆和行列式。
参数:
a(n,) array_like
系数数组
返回:
F(n, n) ndarray
请参见
circulant
, toeplitz
注意事项
1.3.0 版本新增。
参考文献
[1]
J. Todd, “基础数值数学:第 2 卷:数值代数”, 1977 年, Birkhauser, DOI:10.1007/978-3-0348-7286-7
示例
>>> import numpy as np
>>> from scipy.linalg import det, inv, fiedler
>>> a = [1, 4, 12, 45, 77]
>>> n = len(a)
>>> A = fiedler(a)
>>> A
array([[ 0, 3, 11, 44, 76],
[ 3, 0, 8, 41, 73],
[11, 8, 0, 33, 65],
[44, 41, 33, 0, 32],
[76, 73, 65, 32, 0]])
明确的行列式和逆矩阵公式似乎仅适用于单调递增/递减的数组。注意三对角结构和角落。
>>> Ai = inv(A)
>>> Ai[np.abs(Ai) < 1e-12] = 0. # cleanup the numerical noise for display
>>> Ai
array([[-0.16008772, 0.16666667, 0\. , 0\. , 0.00657895],
[ 0.16666667, -0.22916667, 0.0625 , 0\. , 0\. ],
[ 0\. , 0.0625 , -0.07765152, 0.01515152, 0\. ],
[ 0\. , 0\. , 0.01515152, -0.03077652, 0.015625 ],
[ 0.00657895, 0\. , 0\. , 0.015625 , -0.00904605]])
>>> det(A)
15409151.999999998
>>> (-1)**(n-1) * 2**(n-2) * np.diff(a).prod() * (a[-1] - a[0])
15409152
scipy.linalg.fiedler_companion
scipy.linalg.fiedler_companion(a)
返回一个菲德勒伴随矩阵
给定多项式系数数组a
,此函数形成一个具有特殊结构的五对角矩阵,其特征值与a
的根一致。
参数:
a(N,) array_like
降序排列的多项式系数的一维数组,其中首个系数非零。若N < 2
,则返回一个空数组。
返回:
c(N-1, N-1) ndarray
生成的伴随矩阵
参见
companion
注意事项
类似于companion
,主导系数应为非零值。若主导系数不为 1,则在生成数组之前会重新缩放其他系数。为避免数值问题,最好提供一个首一多项式。
新版本 1.3.0 中新增。
参考文献
[1]
M. 菲德勒,“关于伴随矩阵的一个注记”,《线性代数及其应用》,2003 年,DOI:10.1016/S0024-3795(03)00548-2
示例
>>> import numpy as np
>>> from scipy.linalg import fiedler_companion, eigvals
>>> p = np.poly(np.arange(1, 9, 2)) # [1., -16., 86., -176., 105.]
>>> fc = fiedler_companion(p)
>>> fc
array([[ 16., -86., 1., 0.],
[ 1., 0., 0., 0.],
[ 0., 176., 0., -105.],
[ 0., 1., 0., 0.]])
>>> eigvals(fc)
array([7.+0.j, 5.+0.j, 3.+0.j, 1.+0.j])
scipy.linalg.hadamard
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.hadamard.html#scipy.linalg.hadamard
scipy.linalg.hadamard(n, dtype=<class 'int'>)
构造一个哈达玛矩阵。
使用 Sylvester 的构造方法构造一个 n×n 的哈达玛矩阵。n 必须是 2 的幂。
参数:
nint
矩阵的阶数。n 必须是 2 的幂。
dtypedtype,可选
要构造的数组的数据类型。
返回值:
H(n, n) ndarray
哈达玛矩阵。
注意
自版本 0.8.0 新增。
示例
>>> from scipy.linalg import hadamard
>>> hadamard(2, dtype=complex)
array([[ 1.+0.j, 1.+0.j],
[ 1.+0.j, -1.-0.j]])
>>> hadamard(4)
array([[ 1, 1, 1, 1],
[ 1, -1, 1, -1],
[ 1, 1, -1, -1],
[ 1, -1, -1, 1]])
scipy.linalg.hankel
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.hankel.html#scipy.linalg.hankel
scipy.linalg.hankel(c, r=None)
构建一个 Hankel 矩阵。
Hankel 矩阵具有恒定的反对角线,以 c 作为其第一列,r 作为其最后一行。如果未提供 r,则假定 r = zeros_like(c)。
参数:
carray_like
矩阵的第一列。无论 c 的实际形状如何,都会转换为一维数组。
rarray_like,可选
矩阵的最后一行。如果为 None,则假定 r = zeros_like(c)
。忽略 r[0];返回矩阵的最后一行为 [c[-1], r[1:]]
。无论 r 的实际形状如何,都会转换为一维数组。
返回:
A(len(c), len(r)) 数组
Hankel 矩阵。其数据类型与 (c[0] + r[0]).dtype
相同。
参见
Toeplitz 矩阵
循环矩阵
示例
>>> from scipy.linalg import hankel
>>> hankel([1, 17, 99])
array([[ 1, 17, 99],
[17, 99, 0],
[99, 0, 0]])
>>> hankel([1,2,3,4], [4,7,7,8,9])
array([[1, 2, 3, 4, 7],
[2, 3, 4, 7, 7],
[3, 4, 7, 7, 8],
[4, 7, 7, 8, 9]])
scipy.linalg.helmert
原始文档:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.helmert.html#scipy.linalg.helmert
scipy.linalg.helmert(n, full=False)
创建一个阶数为n的 Helmert 矩阵。
在统计学、组合分析或 Aitchison 几何学中有应用。
参数:
nint
要创建的数组大小。
fullbool,可选
如果为 True,则返回形状为(n, n)的 ndarray。否则返回不包括第一行的子矩阵。默认值为 False。
返回:
Mndarray
Helmert 矩阵。形状为(n, n)或(n-1, n),具体取决于full参数。
示例
>>> from scipy.linalg import helmert
>>> helmert(5, full=True)
array([[ 0.4472136 , 0.4472136 , 0.4472136 , 0.4472136 , 0.4472136 ],
[ 0.70710678, -0.70710678, 0\. , 0\. , 0\. ],
[ 0.40824829, 0.40824829, -0.81649658, 0\. , 0\. ],
[ 0.28867513, 0.28867513, 0.28867513, -0.8660254 , 0\. ],
[ 0.2236068 , 0.2236068 , 0.2236068 , 0.2236068 , -0.89442719]])
scipy.linalg.hilbert
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.hilbert.html#scipy.linalg.hilbert
scipy.linalg.hilbert(n)
创建阶数为 n 的希尔伯特矩阵。
返回 n 行 n 列的数组,其中 h[i,j] = 1 / (i + j + 1)。
参数:
nint
创建数组的大小。
返回:
h(n, n) ndarray
希尔伯特矩阵。
另请参阅
计算希尔伯特矩阵的逆。
注意事项
新版本 0.10.0 中新增。
示例
>>> from scipy.linalg import hilbert
>>> hilbert(3)
array([[ 1\. , 0.5 , 0.33333333],
[ 0.5 , 0.33333333, 0.25 ],
[ 0.33333333, 0.25 , 0.2 ]])
scipy.linalg.invhilbert
scipy.linalg.invhilbert(n, exact=False)
计算阶数为 n 的 Hilbert 矩阵的逆。
Hilbert 矩阵的逆中的条目是整数。当 n 大于 14 时,逆中的某些条目超过了 64 位整数的上限。exact 参数提供两种处理这些大整数的选项。
参数:
nint
Hilbert 矩阵的阶数。
exactbool,可选
如果为 False,则返回的数组数据类型为 np.float64,并且数组是逆的近似。如果为 True,则返回的数组是精确的整数逆数组。在 n > 14 时表示精确逆的对象数组是长整数。对于 n <= 14,精确的逆作为数据类型为 np.int64 的数组返回。
返回:
invh(n, n) ndarray
如果 exact 为 False,则数组的数据类型为 np.float64。如果 exact 为 True,则数据类型为 np.int64(当 n <= 14 时)或 object(当 n > 14 时)。在后一种情况下,数组中的对象将是长整数。
另请参阅
hilbert
创建 Hilbert 矩阵。
注意事项
自 0.10.0 版本起新增。
示例
>>> from scipy.linalg import invhilbert
>>> invhilbert(4)
array([[ 16., -120., 240., -140.],
[ -120., 1200., -2700., 1680.],
[ 240., -2700., 6480., -4200.],
[ -140., 1680., -4200., 2800.]])
>>> invhilbert(4, exact=True)
array([[ 16, -120, 240, -140],
[ -120, 1200, -2700, 1680],
[ 240, -2700, 6480, -4200],
[ -140, 1680, -4200, 2800]], dtype=int64)
>>> invhilbert(16)[7,7]
4.2475099528537506e+19
>>> invhilbert(16, exact=True)[7,7]
42475099528537378560
scipy.linalg.leslie
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.leslie.html#scipy.linalg.leslie
scipy.linalg.leslie(f, s)
创建一个 Leslie 矩阵。
给定长度为 n 的繁殖系数数组 f 和长度为 n-1 的存活系数数组 s,返回相关的 Leslie 矩阵。
参数:
f(N,) 数组型
“繁殖”系数。
s(N-1,) 数组型
“存活”系数必须是 1 维的。s 的长度必须比 f 的长度少 1,且至少为 1。
返回:
L(N, N) 二维数组
该数组除了第一行为 f,第一个次对角线为 s 外,其他均为零。数组的数据类型将与 f[0]+s[0]
的数据类型相同。
注意
从版本 0.8.0 开始新加入。
Leslie 矩阵用于建模离散时间的年龄结构人口增长 [1] [2]。在具有 n 个年龄类别的人口中,两组参数定义了 Leslie 矩阵:n 个“繁殖系数”,指每个年龄类别每人口产生的后代数,以及 n - 1 个“存活系数”,指每个年龄类别的每人口存活率。
参考资料
[1]
P. H. Leslie, 关于在某些人口数学中使用矩阵的论文, 生物统计学, Vol. 33, No. 3, 183–212 (Nov. 1945)
[2]
P. H. Leslie, 有关在人口数学中使用矩阵的进一步说明, 生物统计学, Vol. 35, No. 3/4, 213–245 (Dec. 1948)
示例
>>> from scipy.linalg import leslie
>>> leslie([0.1, 2.0, 1.0, 0.1], [0.2, 0.8, 0.7])
array([[ 0.1, 2\. , 1\. , 0.1],
[ 0.2, 0\. , 0\. , 0\. ],
[ 0\. , 0.8, 0\. , 0\. ],
[ 0\. , 0\. , 0.7, 0\. ]])
scipy.linalg.pascal
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.pascal.html#scipy.linalg.pascal
scipy.linalg.pascal(n, kind='symmetric', exact=True)
返回 n x n Pascal 矩阵。
Pascal 矩阵是一个包含其元素为二项式系数的矩阵。
Parameters:
nint
The size of the matrix to create; that is, the result is an n x n matrix.
kindstr, optional
Must be one of ‘symmetric’, ‘lower’, or ‘upper’. Default is ‘symmetric’.
exactbool, optional
If exact is True, the result is either an array of type numpy.uint64 (if n < 35) or an object array of Python long integers. If exact is False, the coefficients in the matrix are computed using scipy.special.comb
with exact=False. The result will be a floating point array, and the values in the array will not be the exact coefficients, but this version is much faster than exact=True.
Returns:
p(n, n) ndarray
Pascal 矩阵。
See also
invpascal
Notes
See en.wikipedia.org/wiki/Pascal_matrix
for more information about Pascal matrices.
New in version 0.11.0.
Examples
>>> from scipy.linalg import pascal
>>> pascal(4)
array([[ 1, 1, 1, 1],
[ 1, 2, 3, 4],
[ 1, 3, 6, 10],
[ 1, 4, 10, 20]], dtype=uint64)
>>> pascal(4, kind='lower')
array([[1, 0, 0, 0],
[1, 1, 0, 0],
[1, 2, 1, 0],
[1, 3, 3, 1]], dtype=uint64)
>>> pascal(50)[-1, -1]
25477612258980856902730428600
>>> from scipy.special import comb
>>> comb(98, 49, exact=True)
25477612258980856902730428600
scipy.linalg.invpascal
scipy.linalg.invpascal(n, kind='symmetric', exact=True)
返回 n x n 帕斯卡矩阵的逆。
帕斯卡矩阵是一个以二项式系数作为其元素的矩阵。
参数:
nint
要创建的矩阵的大小;即结果是一个 n x n 的矩阵。
kindstr, 可选
必须是 'symmetric'、'lower' 或 'upper' 中的一个。默认为 'symmetric'。
exactbool, 可选
如果 exact 为 True,则结果为 numpy.int64
类型的数组(若 n <= 35),或者 Python 整数的对象数组。如果 exact 为 False,则矩阵中的系数通过 scipy.special.comb
计算,其中 exact=False。结果将是一个浮点数数组,并且对于大的 n,数组中的值不会是精确的系数。
返回:
invp(n, n) ndarray
帕斯卡矩阵的逆。
另见
注释
新增于版本 0.16.0。
参考
[1]
“帕斯卡矩阵”, en.wikipedia.org/wiki/Pascal_matrix
[2]
Cohen, A. M., “帕斯卡矩阵的逆”, 数学杂志, 59(408), pp. 111-112, 1975.
示例
>>> from scipy.linalg import invpascal, pascal
>>> invp = invpascal(5)
>>> invp
array([[ 5, -10, 10, -5, 1],
[-10, 30, -35, 19, -4],
[ 10, -35, 46, -27, 6],
[ -5, 19, -27, 17, -4],
[ 1, -4, 6, -4, 1]])
>>> p = pascal(5)
>>> p.dot(invp)
array([[ 1., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0.],
[ 0., 0., 1., 0., 0.],
[ 0., 0., 0., 1., 0.],
[ 0., 0., 0., 0., 1.]])
kind 和 exact 的使用示例:
>>> invpascal(5, kind='lower', exact=False)
array([[ 1., -0., 0., -0., 0.],
[-1., 1., -0., 0., -0.],
[ 1., -2., 1., -0., 0.],
[-1., 3., -3., 1., -0.],
[ 1., -4., 6., -4., 1.]])
scipy.linalg.toeplitz
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.toeplitz.html#scipy.linalg.toeplitz
scipy.linalg.toeplitz(c, r=None)
构造一个 Toeplitz 矩阵。
Toeplitz 矩阵具有恒定的对角线,其第一列是c,第一行是r。如果没有给出r,则假定r == conjugate(c)。
参数:
carray_like
矩阵的第一列。无论c的实际形状如何,它都将被转换为一个一维数组。
rarray_like,可选
矩阵的第一行。如果为 None,则假定r = conjugate(c);在这种情况下,如果c[0]是实数,则结果是一个 Hermitian 矩阵。忽略r[0];返回矩阵的第一行为[c[0], r[1:]]。无论r的实际形状如何,它都将被转换为一个一维数组。
返回:
A(len(c), len(r)) ndarray
Toeplitz 矩阵。dtype 与(c[0] + r[0])的类型相同。
另请参见
circulant
循环矩阵
hankel
Hankel 矩阵
solve_toeplitz
解决一个 Toeplitz 系统。
注意
当c或r为标量,或者c为复数且r为 None 时,在版本 0.8.0 中的行为发生了变化。以前版本中的行为没有记录,并且不再支持。
示例
>>> from scipy.linalg import toeplitz
>>> toeplitz([1,2,3], [1,4,5,6])
array([[1, 4, 5, 6],
[2, 1, 4, 5],
[3, 2, 1, 4]])
>>> toeplitz([1.0, 2+3j, 4-1j])
array([[ 1.+0.j, 2.-3.j, 4.+1.j],
[ 2.+3.j, 1.+0.j, 2.-3.j],
[ 4.-1.j, 2.+3.j, 1.+0.j]])
scipy.linalg.tri
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.linalg.tri.html#scipy.linalg.tri
scipy.linalg.tri(N, M=None, k=0, dtype=None)
从版本 1.11.0 开始废弃:tri
被 numpy.tri
取代,将在 SciPy 1.13.0 中移除。
构造 (N, M) 矩阵,其主对角线及其以下到第 k 条对角线的元素为 1。
矩阵满足 A[i,j] == 1 当 j <= i + k。
参数:
Nint
矩阵第一维的大小。
Mint 或 None,可选
矩阵的第二维大小。如果 M 是 None,则假设 M = N。
kint,可选
矩阵填充 1 的次对角线的数量。k = 0 是主对角线,k < 0 是次对角线,k > 0 是超对角线。
dtypedtype,可选
矩阵的数据类型。
返回:
tri(N, M) 数组
三角矩阵。
示例
>>> from scipy.linalg import tri
>>> tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> tri(3, 5, -1, dtype=int)
array([[0, 0, 0, 0, 0],
[1, 0, 0, 0, 0],
[1, 1, 0, 0, 0]])
scipy.linalg.get_blas_funcs
scipy.linalg.get_blas_funcs(names, arrays=(), dtype=None, ilp64=False)
返回名称对应的可用 BLAS 函数对象。
使用数组确定 BLAS 例程的最佳前缀。
参数:
namesstr 或 str 序列
BLAS 函数的名称,不包括类型前缀。
arraysndarray 序列,可选
可以提供数组以确定 BLAS 例程的最佳前缀。如果未提供,则使用双精度例程,否则使用数组中最通用的类型。
dtypestr 或 dtype,可选
数据类型说明符。如果arrays非空,则不使用。
ilp64,可选
是否返回 ILP64 例程变体。选择'preferred'将返回 ILP64 例程(如果可用),否则返回 32 位例程。默认为 False。
返回:
funcs列表
包含找到的函数的列表。
注意事项
这个例程会自动选择 Fortran/C 接口之间的优先顺序。尽可能使用 Fortran 代码处理列主序数组。在其他情况下,则优先选择 C 代码。
在 BLAS 中,命名约定是所有函数都以类型前缀开头,这取决于主矩阵的类型。这些可以是 NumPy 类型{float32, float64, complex64, complex128}对应的{'s', 'd', 'c', 'z'}。代码和 dtype 存储在返回函数的typecode和dtype属性中。
示例
>>> import numpy as np
>>> import scipy.linalg as LA
>>> rng = np.random.default_rng()
>>> a = rng.random((3,2))
>>> x_gemv = LA.get_blas_funcs('gemv', (a,))
>>> x_gemv.typecode
'd'
>>> x_gemv = LA.get_blas_funcs('gemv',(a*1j,))
>>> x_gemv.typecode
'z'
scipy.linalg.get_lapack_funcs
scipy.linalg.get_lapack_funcs(names, arrays=(), dtype=None, ilp64=False)
返回名称中可用的 LAPACK 函数对象。
数组用于确定 LAPACK 程序包的最佳前缀。
参数:
namesstr 或字符串序列
没有类型前缀的 LAPACK 函数的名称。
arraysndarrays 序列,可选
可以提供数组以确定 LAPACK 程序包的最佳前缀。如果未提供,则将使用双精度例程,否则将使用数组中最通用的类型。
dtypestr 或 dtype,可选
数据类型说明符。如果 arrays 非空,则不使用。
ilp64,可选
是否返回 ILP64 例程变体。选择 ‘preferred’ 如果可用,则返回 ILP64 例程,否则返回 32 位例程。默认为 False
返回:
funcs列表
包含找到的函数的列表。
注意事项
该例程会自动在 Fortran/C 接口之间进行选择。在列主序数组中尽可能使用 Fortran 代码。在所有其他情况下,优选 C 代码。
在 LAPACK 中,命名约定是所有函数以一个类型前缀开头,这取决于主矩阵的类型。这些可以是 NumPy 类型 {float32, float64, complex64, complex128} 中的 {‘s’, ‘d’, ‘c’, ‘z’} 之一,分别存储在返回函数的 typecode
属性中。
示例
假设我们想使用 ‘?lange’ 例程来计算数组的选定范数。我们传递我们的数组以获得正确的 ‘lange’ 版本。
>>> import numpy as np
>>> import scipy.linalg as LA
>>> rng = np.random.default_rng()
>>> a = rng.random((3,2))
>>> x_lange = LA.get_lapack_funcs('lange', (a,))
>>> x_lange.typecode
'd'
>>> x_lange = LA.get_lapack_funcs('lange',(a*1j,))
>>> x_lange.typecode
'z'
几个 LAPACK 例程在其内部 WORK 数组具有最佳大小时效果最佳(足够大以进行快速计算,但又小到不浪费内存)。这个大小也通过专用查询函数确定,通常作为独立函数包装并通常表示为 ###_lwork
。下面是 ?sysv
的示例。
>>> a = rng.random((1000, 1000))
>>> b = rng.random((1000, 1)) * 1j
>>> # We pick up zsysv and zsysv_lwork due to b array
... xsysv, xlwork = LA.get_lapack_funcs(('sysv', 'sysv_lwork'), (a, b))
>>> opt_lwork, _ = xlwork(a.shape[0]) # returns a complex for 'z' prefix
>>> udut, ipiv, x, info = xsysv(a, b, lwork=int(opt_lwork.real))
scipy.linalg.find_best_blas_type
scipy.linalg.find_best_blas_type(arrays=(), dtype=None)
寻找最佳匹配的 BLAS/LAPACK 类型。
数组用于确定 BLAS 例程的最佳前缀。
参数:
arraysndarrays 的序列,可选
可以提供数组来确定 BLAS 例程的最佳前缀。如果未提供,则使用双精度例程,否则使用数组中最通用的类型。
dtypestr 或 dtype,可选
数据类型指定符。如果arrays非空则不使用。
返回值:
prefixstr
BLAS/LAPACK 前缀字符。
dtypedtype
推断的 Numpy 数据类型。
prefer_fortranbool
是否优先使用 Fortran 顺序的例程而不是 C 顺序。
示例
>>> import numpy as np
>>> import scipy.linalg.blas as bla
>>> rng = np.random.default_rng()
>>> a = rng.random((10,15))
>>> b = np.asfortranarray(a) # Change the memory layout order
>>> bla.find_best_blas_type((a,))
('d', dtype('float64'), False)
>>> bla.find_best_blas_type((a*1j,))
('z', dtype('complex128'), False)
>>> bla.find_best_blas_type((b,))
('d', dtype('float64'), True)
杂项工具(scipy.misc
)
自 1.10.0 版本起已弃用:此模块已弃用,并将在 SciPy v2.0.0 中完全移除。
各种无法归类的实用程序。
ascent () |
获取一张 8 位灰度深度、512 x 512 的衍生图像,便于演示使用。 |
---|---|
central_diff_weights (Np[, ndiv]) |
返回一个 Np 点中心导数的权重。 |
derivative (func, x0[, dx, n, args, order]) |
在某一点找到函数的第 n 阶导数。 |
face ([gray]) |
获取一张 1024 x 768 的彩色浣熊脸部图像。 |
electrocardiogram () |
加载一个心电图作为 1-D 信号的示例。 |
scipy.misc.ascent
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.misc.ascent.html#scipy.misc.ascent
scipy.misc.ascent()
获取一个便于演示的 8 位灰度深度,512 x 512 像素的图像
该图像来源于www.public-domain-image.com/people-public-domain-images-pictures/
自 1.10.0 版本起已弃用:ascent
在 SciPy 1.10.0 中已从scipy.misc.ascent
中弃用,并将在 SciPy 1.12.0 中完全移除。数据集方法已移至scipy.datasets
模块。请改用scipy.datasets.ascent
。
参数:
None
返回:
ascentndarray
用于测试和演示的便利图像
示例
>>> import scipy.misc
>>> ascent = scipy.misc.ascent()
>>> ascent.shape
(512, 512)
>>> ascent.max()
255
>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(ascent)
>>> plt.show()
scipy.misc.central_diff_weights
scipy.misc.central_diff_weights(Np, ndiv=1)
返回 Np 点中心导数的权重。
假设等间距函数点。
如果权重在向量 w 中,则导数为 w[0] * f(x-h0dx) + … + w[-1] * f(x+h0dx)
自 1.10.0 版本起弃用:central_diff_weights
已从 SciPy 1.10.0 中的scipy.misc.central_diff_weights
中弃用,并将在 SciPy 1.12.0 中完全移除。您可以考虑使用 findiff:github.com/maroba/findiff
或 numdifftools:github.com/pbrod/numdifftools
参数:
Np:int
中心导数的点数。
ndiv:int,可选
分割数。默认为 1。
返回:
w:ndarray
Np 点中心导数的权重。其大小为Np。
注意事项
对大量点可能不精确。
引用
[1]
en.wikipedia.org/wiki/Finite_difference
示例
我们可以计算函数的导数值。
>>> from scipy.misc import central_diff_weights
>>> def f(x):
... return 2 * x**2 + 3
>>> x = 3.0 # derivative point
>>> h = 0.1 # differential step
>>> Np = 3 # point number for central derivative
>>> weights = central_diff_weights(Np) # weights for first derivative
>>> vals = [f(x + (i - Np/2) * h) for i in range(Np)]
>>> sum(w * v for (w, v) in zip(weights, vals))/h
11.79999999999998
该值接近解析解:f’(x) = 4x,所以 f’(3) = 12
scipy.misc.derivative
原文链接:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.misc.derivative.html#scipy.misc.derivative
scipy.misc.derivative(func, x0, dx=1.0, n=1, args=(), order=3)
在点处找到函数的第 n 阶导数。
给定一个函数,在点x0处使用间距dx的中心差分公式计算第 n 阶导数。
自 1.10.0 版本起弃用:derivative
自 SciPy 1.10.0 中的scipy.misc.derivative
已被弃用,将在 SciPy 1.12.0 中完全移除。您可以考虑使用 findiff:github.com/maroba/findiff
或 numdifftools:github.com/pbrod/numdifftools
参数:
func函数
输入函数。
x0浮点数
找到第 n 阶导数的点。
dx浮点数,可选
Spacing.
n整数,可选
导数的阶数。默认为 1。
args元组,可选
参数
order整数,可选
要使用的点数,必须为奇数。
注意
减小步长过小可能导致舍入误差。
示例
>>> from scipy.misc import derivative
>>> def f(x):
... return x**3 + x**2
>>> derivative(f, 1.0, dx=1e-6)
4.9999999999217337
scipy.misc.face
原文:
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.misc.face.html#scipy.misc.face
scipy.misc.face(gray=False)
获得一张大小为 1024 x 768 的浣熊脸的彩色图像。
在 www.public-domain-image.com
上的 raccoon-procyon-lotor.jpg
自版本 1.10.0 起弃用:face
已从 SciPy 1.10.0 的 scipy.misc.face
中弃用,并将在 SciPy 1.12.0 中完全移除。数据集方法已迁移到 scipy.datasets
模块。请使用 scipy.datasets.face
替代。
参数:
graybool,可选
如果为 True,则返回 8 位灰度图像,否则返回彩色图像
返回:
facendarray
浣熊脸的图像
示例
>>> import scipy.misc
>>> face = scipy.misc.face()
>>> face.shape
(768, 1024, 3)
>>> face.max()
255
>>> face.dtype
dtype('uint8')
>>> import matplotlib.pyplot as plt
>>> plt.gray()
>>> plt.imshow(face)
>>> plt.show()
scipy.misc.electrocardiogram
scipy.misc.electrocardiogram()
作为一维信号的示例加载心电图。
返回的信号是一个 5 分钟长的心电图(ECG),记录了心脏电活动,以 360 Hz 采样。
自 1.10.0 版本起不推荐使用:electrocardiogram
从 SciPy 1.10.0 版起已经从scipy.misc.electrocardiogram
中删除,并且将在 SciPy 1.12.0 版中完全移除。数据集方法已经迁移到scipy.datasets
模块。请使用scipy.datasets.electrocardiogram
。
返回:
ecg ndarray
心电图以毫伏(mV)为单位,在 360 Hz 采样。
注释
所提供的信号是来自录音 208(MLII 导联)的摘录(19:35 至 24:35),该信号由 MIT-BIH 心律失常数据库在 PhysioNet 上提供[1]。摘录包括噪声诱导的伪迹、典型的心跳以及病理性变化。
新功能在 1.1.0 版本中添加。
参考文献
[1]
Moody GB, Mark RG. MIT-BIH 心律失常数据库的影响。IEEE 工程与医学生物学杂志,20(3):45-50(2001 年 5-6 月)。(PMID: 11446209);DOI:10.13026/C2F305
[2]
Goldberger AL, Amaral LAN, Glass L, Hausdorff JM, Ivanov PCh, Mark RG, Mietus JE, Moody GB, Peng C-K, Stanley HE. PhysioBank,PhysioToolkit 和 PhysioNet:复杂生理信号的新研究资源的组成部分。循环 101(23):e215-e220;DOI:10.1161/01.CIR.101.23.e215
示例
>>> from scipy.misc import electrocardiogram
>>> ecg = electrocardiogram()
>>> ecg
array([-0.245, -0.215, -0.185, ..., -0.405, -0.395, -0.385])
>>> ecg.shape, ecg.mean(), ecg.std()
((108000,), -0.16510875, 0.5992473991177294)
如所述,该信号显示了几个具有不同形态的区域。例如,最初几秒显示了正常窦性节律心脏的电活动,如下图所示。
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> fs = 360
>>> time = np.arange(ecg.size) / fs
>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(9, 10.2)
>>> plt.ylim(-1, 1.5)
>>> plt.show()
然而,在第 16 秒之后,出现了第一次早期室性收缩,也称为早搏。这些与典型的心跳在形态上有所不同。这种差异可以在下图中清楚地观察到。
>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(46.5, 50)
>>> plt.ylim(-2, 1.5)
>>> plt.show()
在几个点上大的伪迹干扰了记录,例如:
>>> plt.plot(time, ecg)
>>> plt.xlabel("time in s")
>>> plt.ylabel("ECG in mV")
>>> plt.xlim(207, 215)
>>> plt.ylim(-2, 3.5)
>>> plt.show()
最后,检查功率谱显示,大部分生物信号由较低频率组成。在 60 Hz 时,可以清楚地观察到由电网引起的噪音。
>>> from scipy.signal import welch
>>> f, Pxx = welch(ecg, fs=fs, nperseg=2048, scaling="spectrum")
>>> plt.semilogy(f, Pxx)
>>> plt.xlabel("Frequency in Hz")
>>> plt.ylabel("Power spectrum of the ECG in mV**2")
>>> plt.xlim(f[[0, -1]])
>>> plt.show()
多维图像处理(scipy.ndimage
)
此包含各种多维图像处理函数。
滤波器
convolve (input, weights[, output, mode, ...]) |
多维卷积运算。 |
---|---|
convolve1d (input, weights[, axis, output, ...]) |
沿指定轴计算一维卷积。 |
correlate (input, weights[, output, mode, ...]) |
多维相关运算。 |
correlate1d (input, weights[, axis, output, ...]) |
沿指定轴计算一维相关运算。 |
gaussian_filter (input, sigma[, order, ...]) |
多维高斯滤波器。 |
gaussian_filter1d (input, sigma[, axis, ...]) |
一维高斯滤波器。 |
gaussian_gradient_magnitude (input, sigma[, ...]) |
使用高斯导数计算多维梯度幅值。 |
gaussian_laplace (input, sigma[, output, ...]) |
使用高斯二阶导数的多维拉普拉斯滤波器。 |
generic_filter (input, function[, size, ...]) |
使用给定函数计算多维滤波器。 |
generic_filter1d (input, function, filter_size) |
沿指定轴计算一维滤波器。 |
generic_gradient_magnitude (input, derivative) |
使用提供的梯度函数计算梯度幅值。 |
generic_laplace (input, derivative2[, ...]) |
使用提供的二阶导数函数进行 N 维拉普拉斯滤波器。 |
laplace (input[, output, mode, cval]) |
基于近似二阶导数的 N 维拉普拉斯滤波器。 |
maximum_filter (input[, size, footprint, ...]) |
计算多维最大值滤波器。 |
maximum_filter1d (input, size[, axis, ...]) |
沿指定轴计算 1-D 最大值滤波器。 |
median_filter (input[, size, footprint, ...]) |
计算多维中值滤波器。 |
minimum_filter (input[, size, footprint, ...]) |
计算多维最小值滤波器。 |
minimum_filter1d (input, size[, axis, ...]) |
沿指定轴计算 1-D 最小值滤波器。 |
percentile_filter (input, percentile[, size, ...]) |
计算多维百分位数滤波器。 |
prewitt (input[, axis, output, mode, cval]) |
计算普雷维特滤波器。 |
rank_filter (input, rank[, size, footprint, ...]) |
计算多维秩滤波器。 |
sobel (input[, axis, output, mode, cval]) |
计算 Sobel 滤波器。 |
uniform_filter (input[, size, output, mode, ...]) |
多维均匀过滤器。 |
uniform_filter1d (input, size[, axis, ...]) |
沿指定轴计算 1-D 均匀滤波器。 |
Fourier filters
fourier_ellipsoid (input, size[, n, axis, output]) |
多维椭球傅里叶滤波器。 |
---|---|
fourier_gaussian (input, sigma[, n, axis, output]) |
多维高斯傅里叶滤波器。 |
fourier_shift (input, shift[, n, axis, output]) |
多维傅立叶移位滤波器。 |
fourier_uniform (input, size[, n, axis, output]) |
多维均匀傅立叶滤波器。 |
插值
affine_transform (input, matrix[, offset, ...]) |
应用仿射变换。 |
---|---|
geometric_transform (input, mapping[, ...]) |
应用任意几何变换。 |
map_coordinates (input, coordinates[, ...]) |
通过插值将输入数组映射到新坐标。 |
rotate (input, angle[, axes, reshape, ...]) |
旋转数组。 |
shift (input, shift[, output, order, mode, ...]) |
移动数组。 |
spline_filter (input[, order, output, mode]) |
多维样条滤波器。 |
spline_filter1d (input[, order, axis, ...]) |
沿给定轴计算一维样条滤波器。 |
zoom (input, zoom[, output, order, mode, ...]) |
缩放数组。 |
测量
center_of_mass (input[, labels, index]) |
计算数组中标签值的质心。 |
---|---|
extrema (input[, labels, index]) |
计算数组中标签处的最小值和最大值及其位置。 |
find_objects (input[, max_label]) |
在标记数组中查找对象。 |
histogram (input, min, max, bins[, labels, index]) |
计算数组值的直方图,可选地在标签处计算。 |
label (input[, structure, output]) |
对数组中的特征进行标记。 |
labeled_comprehension (input, labels, index, ...) |
大致相当于 [func(input[labels == i]) for i in index]。 |
maximum (input[, labels, index]) |
计算带标签区域数组值的最大值。 |
maximum_position (input[, labels, index]) |
查找数组标签处数值最大值的位置。 |
mean (input[, labels, index]) |
计算带标签数组值的平均值。 |
median (input[, labels, index]) |
计算带标签区域数组值的中位数。 |
minimum (input[, labels, index]) |
计算带标签区域数组值的最小值。 |
minimum_position (input[, labels, index]) |
查找数组标签处数值最小值的位置。 |
standard_deviation (input[, labels, index]) |
计算 N 维图像数组值的标准差,可选择指定的子区域。 |
sum_labels (input[, labels, index]) |
计算数组值的总和。 |
value_indices (arr, *[, ignore_value]) |
查找给定数组中每个不同值的索引。 |
variance (input[, labels, index]) |
计算 N 维图像数组值的方差,可选择指定的子区域。 |
watershed_ift (input, markers[, structure, ...]) |
使用图像森林变换算法从标记应用分水岭。 |
形态学
binary_closing (input[, structure, ...]) |
使用给定的结构元素进行多维二值闭运算。 |
---|---|
binary_dilation (input[, structure, ...]) |
使用给定的结构元素进行多维二进制膨胀。 |
binary_erosion (input[, structure, ...]) |
使用给定的结构元素进行多维二进制腐蚀。 |
binary_fill_holes (input[, structure, ...]) |
填补二进制对象中的空洞。 |
binary_hit_or_miss (input[, structure1, ...]) |
多维二进制击中或错过变换。 |
binary_opening (input[, structure, ...]) |
使用给定的结构元素进行多维二进制开运算。 |
binary_propagation (input[, structure, mask, ...]) |
使用给定的结构元素进行多维二进制传播。 |
black_tophat (input[, size, footprint, ...]) |
多维黑顶帽滤波器。 |
distance_transform_bf (input[, metric, ...]) |
通过蛮力算法进行的距离变换函数。 |
distance_transform_cdt (input[, metric, ...]) |
针对 chamfer 类型变换的距离变换。 |
distance_transform_edt (input[, sampling, ...]) |
精确的欧几里得距离变换。 |
generate_binary_structure (rank, connectivity) |
为二进制形态学操作生成二进制结构。 |
grey_closing (input[, size, footprint, ...]) |
多维灰度闭运算。 |
grey_dilation (input[, size, footprint, ...]) |
计算灰度膨胀,使用结构元素或对应于平坦结构元素的足迹。 |
grey_erosion (input[, size, footprint, ...]) |
计算灰度侵蚀,可以使用结构元素或与平面结构元素对应的足印。 |
grey_opening (input[, size, footprint, ...]) |
多维灰度开运算。 |
iterate_structure (structure, iterations[, ...]) |
通过自身的膨胀迭代结构。 |
morphological_gradient (input[, size, ...]) |
多维形态梯度。 |
morphological_laplace (input[, size, ...]) |
多维形态拉普拉斯。 |
white_tophat (input[, size, footprint, ...]) |
多维白顶帽滤波器。 |
scipy.ndimage.convolve
scipy.ndimage.convolve(input, weights, output=None, mode='reflect', cval=0.0, origin=0)
多维卷积。
数组与给定内核进行卷积。
参数:
inputarray_like
输入数组。
weightsarray_like
权重数组,与输入具有相同数量的维度
outputarray or dtype, optional
放置输出的数组,或者返回数组的 dtype。默认情况下,将创建与输入相同 dtype 的数组。
mode, optional
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’的同义词。
cvalscalar, optional
如果mode为‘constant’,则用来填充输入边缘之外的值。默认为 0.0。
originint, optional
控制输入信号的原点,即滤波器产生输出的第一个元素的中心。正值将滤波器向右移动,负值将滤波器向左移动。默认为 0。
返回:
resultndarray
input与weights的卷积结果。
参见
correlate
将图像与内核相关联。
注意
结果中的每个值为(C_i = \sum_j{I_{i+k-j} W_j}),其中 W 是weights内核,j 是在(W)上的 N-D 空间索引,I 是input,k 是由输入参数中的origin指定的 W 中心的坐标。
示例
可能最简单的情况是理解mode='constant', cval=0.0
,因为在这种情况下,边界(即在input的任一值上,weights内核延伸超出input的边缘)被视为零。
>>> import numpy as np
>>> 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]])
设置cval=1.0
等效于在input的外边缘填充 1.0(然后仅提取结果的原始区域)。
>>> 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]])
使用mode='reflect'
(默认情况下),外部值会在input边缘处反射,以填补缺失的值。
>>> 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]])
在角落处,包括对角线方向。
>>> 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]])
使用mode='nearest'
时,会将最接近边缘的单个值在input中重复,以匹配重叠的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]])
scipy.ndimage.convolve1d
scipy.ndimage.convolve1d(input, weights, axis=-1, output=None, mode='reflect', cval=0.0, origin=0)
沿给定轴计算一维卷积。
沿给定轴对数组的行进行卷积。
参数:
input类似数组
输入数组。
weights数组
1-D 数字序列。
axis整数,可选
input的轴,沿其计算。默认为 -1。
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-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cval标量,可选
如果 mode 为 'constant',则用来填充输入之外边缘的值。默认值为 0.0。
origin整数,可选
控制滤波器在输入数组像素上的放置。值为 0(默认)将滤波器居中于像素上,正值将滤波器向左移动,负值向右移动。
返回:
convolve1d数组
与输入相同形状的卷积数组
示例
>>> 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])
scipy.ndimage.correlate
scipy.ndimage.correlate(input, weights, output=None, mode='reflect', cval=0.0, origin=0)
多维相关性。
数组与给定核心相关。
参数:
input类数组
输入数组。
weightsndarray
与输入相同维数的权重数组。
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-mirror’
这是‘reflect’的同义词。
‘grid-constant’
这是‘constant’的同义词。
‘grid-wrap’
这是‘wrap’的同义词。
cval标量,可选
如果mode为‘constant’,则填充输入超出边缘的值。默认为 0.0。
origin整数或序列,可选
控制过滤器在输入数组像素上的放置位置。值为 0(默认)将过滤器居中于像素上,正值将过滤器向左移动,负值将其向右移动。通过传递与输入数组维数相同长度的起始序列,可以在每个轴上指定不同的偏移量。
返回:
resultndarray
输入与权重的相关性结果。
另请参阅
convolve
用核心对图像进行卷积。
示例
相关性是将常称为核心的滤波器掩模移动到图像上并计算每个位置的乘积之和的过程。
>>> from scipy.ndimage import correlate
>>> import numpy as np
>>> input_img = np.arange(25).reshape(5,5)
>>> print(input_img)
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
定义一个核心(权重),用于相关性。在本例中,是为了中心和上、下、左、右相邻元素的和。
>>> weights = [[0, 1, 0],
... [1, 1, 1],
... [0, 1, 0]]
我们可以计算相关性结果:例如,元素[2,2]
为7 + 11 + 12 + 13 + 17 = 60
。
>>> correlate(input_img, weights)
array([[ 6, 10, 15, 20, 24],
[ 26, 30, 35, 40, 44],
[ 51, 55, 60, 65, 69],
[ 76, 80, 85, 90, 94],
[ 96, 100, 105, 110, 114]])
scipy.ndimage.correlate1d
scipy.ndimage.correlate1d(input, weights, axis=-1, output=None, mode='reflect', cval=0.0, origin=0)
沿给定轴计算一维相关。
沿给定轴与给定权重相关的数组行。
参数:
inputarray_like
输入数组。
weightsarray
一维数字序列。
axisint, 可选
计算的input轴。默认为-1。
outputarray 或 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-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cvalscalar, 可选
如果mode为‘constant’,则用于填充输入边界之外的值的值。默认为 0.0。
originint, 可选
控制滤波器在输入数组像素上的放置。默认值为 0,将滤波器居中于像素,正值将滤波器向左移动,负值向右移动。
返回:
resultndarray
相关结果。具有与input相同的形状。
示例
>>> 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])
scipy.ndimage.gaussian_filter
scipy.ndimage.gaussian_filter(input, sigma, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0, *, radius=None, axes=None)
多维高斯滤波器。
参数:
输入array_like
输入数组。
sigma标量或标量序列
高斯核的标准偏差。高斯滤波器的标准偏差作为序列给出,或作为单个数字,此时对于所有轴都是相等的。
顺序整数或整数序列,可选
每个轴上的滤波器顺序以整数序列或单个数字给出。顺序为 0 对应于使用高斯核的卷积。正数顺序对应于与高斯导数的卷积。
输出数组或 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。
截断浮点数,可选
在此标准偏差截断滤波器。默认为 4.0。
半径None 或整数或整数序列,可选
高斯核的半径。半径作为序列给出,或作为单个数字,此时对于所有轴都是相等的。如果指定,则沿每个轴的核大小将为2*radius + 1
,truncate将被忽略。默认为 None。
轴整数元组或 None,可选
如果为 None,则 input 沿所有轴进行滤波。否则,将沿指定轴进行滤波。当指定 axes 时,用于 sigma、order、mode 和/或 radius 的任何元组必须与 axes 的长度相匹配。这些元组中的第 i 个条目对应于 axes 中的第 i 个条目。
返回:
gaussian_filterndarray
返回形状与 input 相同的数组。
注释
多维滤波器实现为一系列 1-D 卷积滤波器。中间数组以与输出相同的数据类型存储。因此,对于具有有限精度的输出类型,由于中间结果可能存储不足的精度,结果可能不精确。
高斯核在每个轴向上的大小为2*radius + 1
。如果 radius 为 None,则默认使用 radius = round(truncate * sigma)
。
示例
>>> from scipy.ndimage import gaussian_filter
>>> import numpy as np
>>> 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 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 = gaussian_filter(ascent, sigma=5)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()
scipy.ndimage.gaussian_filter1d
scipy.ndimage.gaussian_filter1d(input, sigma, axis=-1, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0, *, radius=None)
1-D 高斯滤波器。
参数:
inputarray_like
输入数组。
sigmascalar
高斯核的标准差。
axisint,可选
input沿其计算的轴。默认值为-1。
orderint,可选
顺序为 0 对应于与高斯核卷积。正序对应于高斯的那个导数的卷积。
outputarray 或 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-mirror’
这是“reflect”的同义词。
‘grid-constant’
这是“constant”的同义词。
‘grid-wrap’
这是“wrap”的同义词。
cvalscalar,可选
如果mode为‘constant’,则填充输入边缘之外的值。默认值为 0.0。
truncatefloat,可选
在此标准差处截断滤波器。默认值为 4.0。
radiusNone 或 int,可选
高斯核的半径。如果指定,核的大小将为2*radius + 1
,truncate将被忽略。默认值为 None。
返回:
gaussian_filter1dndarray
注意事项
高斯核沿每个轴的大小将为2*radius + 1
。如果radius为 None,则使用默认值radius = round(truncate * sigma)
。
示例
>>> from scipy.ndimage import gaussian_filter1d
>>> import numpy as np
>>> 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
>>> rng = np.random.default_rng()
>>> x = rng.standard_normal(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()
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
在每个元素上应用的函数。
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参数决定如何扩展输入数组超出其边界的方式。默认为‘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
在给定轴上应用的函数。
filter_size标量
滤波器的长度。
axis整数,可选
input的轴沿其计算的轴。默认为-1。
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-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 的数组。
模式,可选
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,可选
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。
输出数组或数据类型,可选
要放置输出的数组或返回数组的数据类型。默认情况下,将创建与输入相同数据类型的数组。
模式,可选
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,可选
参数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将被忽略。
输出数组或数据类型,可选
用于放置输出的数组,或返回数组的数据类型。默认情况下,将创建与输入相同数据类型的数组。
模式,可选
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,可选
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()
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,可选
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
一个可调用对象,接受与输出数组秩相等长度的元组,并返回相应的输入坐标作为与输入数组秩相等长度的元组。
output_shape整数元组,可选
形状元组。
output数组或 dtype,可选
用于放置输出的数组,或者返回数组的 dtype。默认情况下将创建与输入相同 dtype 的数组。
order整数,可选
样条插值的顺序,默认为 3。顺序必须在 0-5 范围内。
mode,可选
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, 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,可选
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,可选
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()