SciPy 1.12 中文文档（二十七）
scipy.optimize.diagbroyden
scipy.optimize.diagbroyden(F, xin, iter=None, alpha=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)
查找函数的根，使用对角布罗伊登雅各比近似法。
雅各比近似法源自先前迭代，仅保留布罗伊登矩阵的对角线。
警告
这种算法可能对特定问题有用，但其是否有效可能严重依赖于问题本身。
参数：
Ffunction(x) -> f
要找其根的函数；应接受并返回类似数组的对象。
xinarray_like
解的初始猜测
alphafloat，可选
雅各比的初始猜测为(-1/alpha)。
iterint，可选
要进行的迭代次数。如果省略（默认），则进行足够多次迭代以满足容差要求。
verbosebool，可选
在每次迭代时将状态打印到标准输出。
maxiterint，可选
要进行的最大迭代次数。如果需要更多次迭代以满足收敛性，将引发NoConvergence。
f_tolfloat，可选
残差的绝对容差（最大范数）。如果省略，默认为 6e-6。
f_rtolfloat，可选
相对残差的相对容差。如果省略，则不使用。
x_tolfloat，可选
绝对最小步长，根据雅各比近似法确定。如果步长小于此值，则优化将成功终止。如果省略，则不使用。
x_rtolfloat，可选
相对最小步长。如果省略，则不使用。
tol_normfunction(vector) -> scalar，可选
用于收敛检查的范数。默认为最大范数。
line_search{None, ‘armijo’（默认），‘wolfe’}，可选
决定由雅各比近似给出的方向上的步长时，使用哪种类型的线搜索。默认为‘armijo’。
callbackfunction，可选
可选回调函数。在每次迭代时调用，参数为callback(x, f)，其中x为当前解，f为对应残差。
返回：
solndarray
包含最终解的数组（与x0具有相似的数组类型）。
引发：
NoConvergence
当未找到解时。
另请参见
root
用于多元函数根查找算法的接口。特别查看method='diagbroyden'。
示例
下面的函数定义了一个非线性方程组的系统。
>>> def fun(x):
... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0,
... 0.5 * (x[1] - x[0])**3 + x[1]]
可以通过以下方式获得解决方案。
>>> from scipy import optimize
>>> sol = optimize.diagbroyden(fun, [0, 0])
>>> sol
array([0.84116403, 0.15883384])
信号处理（scipy.signal）
卷积
convolve(in1, in2[, mode, method]) | 对两个 N 维数组进行卷积。 |
|---|---|
correlate(in1, in2[, mode, method]) | 对两个 N 维数组进行交叉相关。 |
fftconvolve(in1, in2[, mode, axes]) | 使用 FFT 对两个 N 维数组进行卷积。 |
oaconvolve(in1, in2[, mode, axes]) | 使用重叠-加法方法对两个 N 维数组进行卷积。 |
convolve2d(in1, in2[, mode, boundary, fillvalue]) | 对两个二维数组进行卷积。 |
correlate2d(in1, in2[, mode, boundary, ...]) | 对两个二维数组进行交叉相关。 |
sepfir2d(input, hrow, hcol) | 使用二维可分离 FIR 滤波器进行卷积。 |
choose_conv_method(in1, in2[, mode, measure]) | 查找最快的卷积/相关方法。 |
correlation_lags(in1_len, in2_len[, mode]) | 计算 1D 交叉相关的滞后/位移索引数组。 |
B 样条曲线
bspline(x, n) | B 样条基函数。 |
|---|
自版本 1.11.0 起已弃用。
|
cubic(x) | 三次曲线插值。 |
|---|
自版本 1.11.0 起已弃用。
|
quadratic(x) | 二次曲线插值。 |
|---|
自版本 1.11.0 起已弃用。
|
gauss_spline(x, n) | 高斯逼近的 B 样条基函数（n 阶）。 |
|---|---|
cspline1d(signal[, lamb]) | 计算一维秩为 1 的三次样条插值系数。 |
qspline1d(signal[, lamb]) | 计算一维秩为 1 的二次样条插值系数。 |
cspline2d(input[, lambda, precision]) | 二维三次 B 样条的系数。 |
qspline2d(input[, lambda, precision]) | 二维二次 B 样条的系数： |
cspline1d_eval(cj, newx[, dx, x0]) | 在新点集上评估一维三次样条。 |
qspline1d_eval(cj, newx[, dx, x0]) | 在新点集上评估一维二次样条。 |
spline_filter(Iin[, lmbda]) | 对二维数组进行平滑样条（三次）滤波。 |
Filtering
order_filter(a, domain, rank) | 在 N 维数组上执行阶次滤波。 |
|---|---|
medfilt(volume[, kernel_size]) | 对 N 维数组执行中值滤波。 |
medfilt2d(input[, kernel_size]) | 对二维数组进行中值滤波。 |
wiener(im[, mysize, noise]) | 对 N 维数组执行维纳滤波。 |
symiirorder1(input, c0, z1[, precision]) | 使用第一阶段级联实现具有镜像对称边界条件的平滑 IIR 滤波器。第二阶段使用反向序列。 |
symiirorder2(input, r, omega[, precision]) | 使用第二阶段级联实现具有镜像对称边界条件的平滑 IIR 滤波器。第二阶段使用反向序列。 |
lfilter(b, a, x[, axis, zi]) | 使用 IIR 或 FIR 滤波器沿着一维对数据进行滤波。 |
lfiltic(b, a, y[, x]) | 给定输入和输出向量，构造 lfilter 的初始条件。 |
lfilter_zi(b, a) | 构造 lfilter 的初始条件，用于阶跃响应的稳态。 |
filtfilt | 对信号进行前向和后向数字滤波。 |
savgol_filter | 对数组应用 Savitzky-Golay 滤波器。 |
deconvolve | 使用逆滤波器将divisor从signal中去卷积出来。 |
sosfilt | 使用级联的二阶段沿着一个维度对数据进行滤波。 |
sosfilt_zi | 构造 sosfilt 的初始条件，用于步响应稳态。 |
sosfiltfilt | 使用级联的二阶段进行前向-后向数字滤波。 |
hilbert | 使用 Hilbert 变换计算解析信号。 |
hilbert2 | 计算x的二维解析信号。 |
decimate | 在应用抗混叠滤波器后对信号进行下采样。 |
detrend | 从数据中沿着指定轴去除线性趋势。 |
resample | 使用傅里叶方法沿给定轴对x进行num样本的重采样。 |
resample_poly | 使用多相滤波器沿指定轴对x进行重采样。 |
upfirdn | 上采样、FIR 滤波和下采样。 |
Filter design
bilinear | 使用双线性变换从模拟滤波器返回数字 IIR 滤波器。 |
|---|---|
bilinear_zpk | 使用双线性变换从模拟滤波器返回数字 IIR 滤波器。 |
findfreqs(num, den, N[, kind]) | 查找用于计算模拟滤波器响应的频率数组。 |
firls(numtaps, bands, desired, *[, weight, ...]) | 使用最小二乘误差最小化设计 FIR 滤波器。 |
firwin(numtaps, cutoff, *[, width, window, ...]) | 使用窗口方法设计 FIR 滤波器。 |
firwin2(numtaps, freq, gain, *[, nfreqs, ...]) | 使用窗口方法设计 FIR 滤波器。 |
freqs(b, a[, worN, plot]) | 计算模拟滤波器的频率响应。 |
freqs_zpk(z, p, k[, worN]) | 计算模拟滤波器的频率响应。 |
freqz(b[, a, worN, whole, plot, fs, ...]) | 计算数字滤波器的频率响应。 |
freqz_zpk(z, p, k[, worN, whole, fs]) | 计算 ZPK 形式数字滤波器的频率响应。 |
sosfreqz(sos[, worN, whole, fs]) | 计算 SOS 格式数字滤波器的频率响应。 |
gammatone(freq, ftype[, order, numtaps, fs]) | Gammatone 滤波器设计。 |
group_delay(system[, w, whole, fs]) | 计算数字滤波器的群延迟。 |
iirdesign(wp, ws, gpass, gstop[, analog, ...]) | 完成 IIR 数字和模拟滤波器设计。 |
iirfilter(N, Wn[, rp, rs, btype, analog, ...]) | 给定阶数和关键点，设计 IIR 数字和模拟滤波器。 |
kaiser_atten(numtaps, width) | 计算 Kaiser FIR 滤波器的衰减。 |
kaiser_beta(a) | 给定衰减a，计算 Kaiser 参数beta。 |
kaiserord(ripple, width) | 确定 Kaiser 窗口方法的滤波器窗口参数。 |
minimum_phase(h[, method, n_fft]) | 将线性相位 FIR 滤波器转换为最小相位。 |
savgol_coeffs(window_length, polyorder[, ...]) | 计算 1-D Savitzky-Golay FIR 滤波器的系数。 |
remez(numtaps, bands, desired, *[, weight, ...]) | 使用 Remez 交换算法计算最小最大化优化滤波器。 |
unique_roots(p[, tol, rtype]) | 从根列表中确定唯一的根及其重数。 |
residue(b, a[, tol, rtype]) | 计算 b(s) / a(s) 的部分分数展开。 |
residuez(b, a[, tol, rtype]) | 计算 b(z) / a(z) 的部分分数展开。 |
invres(r, p, k[, tol, rtype]) | 从部分分数展开中计算 b(s) 和 a(s)。 |
invresz(r, p, k[, tol, rtype]) | 从部分分数展开中计算 b(z) 和 a(z)。 |
BadCoefficients | 关于条件不佳的滤波器系数的警告。 |
低级滤波器设计函数：
abcd_normalize([A, B, C, D]) | 检查状态空间矩阵并确保其为二维。 |
|---|---|
band_stop_obj(wp, ind, passb, stopb, gpass, ...) | 频带阻止目标函数，用于最小化阶数。 |
besselap(N[, norm]) | 返回 N 阶贝塞尔滤波器的模拟原型 (z, p, k)。 |
buttap(N) | 返回 N 阶巴特沃斯滤波器的模拟原型 (z, p, k)。 |
cheb1ap(N, rp) | 返回 N 阶切比雪夫类型 I 模拟低通滤波器的 (z, p, k)。 |
cheb2ap(N, rs) | 返回 N 阶切比雪夫类型 II 模拟低通滤波器的 (z, p, k)。 |
cmplx_sort(p) | |
ellipap(N, rp, rs) | 返回第 N 阶椭圆模拟低通滤波器的 (z,p,k)。 |
lp2bp(b, a[, wo, bw]) | 将低通滤波器原型转换到带通滤波器。 |
lp2bp_zpk(z, p, k[, wo, bw]) | 将低通滤波器原型转换到带通滤波器。 |
lp2bs(b, a[, wo, bw]) | 将低通滤波器原型转换到带阻滤波器。 |
lp2bs_zpk(z, p, k[, wo, bw]) | 将低通滤波器原型转换到带阻滤波器。 |
lp2hp(b, a[, wo]) | 将低通滤波器原型转换到高通滤波器。 |
lp2hp_zpk(z, p, k[, wo]) | 将低通滤波器原型转换到高通滤波器。 |
lp2lp(b, a[, wo]) | 将低通滤波器原型转换到不同的频率。 |
lp2lp_zpk(z, p, k[, wo]) | 将低通滤波器原型转换到不同的频率。 |
normalize(b, a) | 归一化连续时间传递函数的分子/分母。 |
Matlab 风格 IIR 滤波器设计
butter(N, Wn[, btype, analog, output, fs]) | Butterworth 数字和模拟滤波器设计。 |
|---|---|
buttord(wp, ws, gpass, gstop[, analog, fs]) | Butterworth 滤波器阶数选择。 |
cheby1(N, rp, Wn[, btype, analog, output, fs]) | Chebyshev I 数字和模拟滤波器设计。 |
cheb1ord(wp, ws, gpass, gstop[, analog, fs]) | Chebyshev I 滤波器阶数选择。 |
cheby2(N, rs, Wn[, btype, analog, output, fs]) | Chebyshev II 数字和模拟滤波器设计。 |
cheb2ord(wp, ws, gpass, gstop[, analog, fs]) | Chebyshev II 滤波器阶数选择。 |
ellip(N, rp, rs, Wn[, btype, analog, output, fs]) | 椭圆（考尔）数字和模拟滤波器设计。 |
ellipord(wp, ws, gpass, gstop[, analog, fs]) | 椭圆（考尔）滤波器阶数选择。 |
bessel(N, Wn[, btype, analog, output, norm, fs]) | Bessel/Thomson 数字和模拟滤波器设计。 |
iirnotch(w0, Q[, fs]) | 设计二阶 IIR 陷波数字滤波器。 |
iirpeak(w0, Q[, fs]) | 设计二阶 IIR 峰值（共振）数字滤波器。 |
iircomb(w0, Q[, ftype, fs, pass_zero]) | 设计 IIR 凹凸或峰值数字梳状滤波器。 |
连续时间线性系统
lti(*system) | 连续时间线性时不变系统基类。 |
|---|---|
StateSpace(*system, **kwargs) | 状态空间形式的线性时不变系统。 |
TransferFunction(*system, **kwargs) | 传递函数形式的线性时不变系统类。 |
ZerosPolesGain(*system, **kwargs) | 零极点增益形式的线性时不变系统类。 |
lsim(system, U, T[, X0, interp]) | 模拟连续时间线性系统的输出。 |
lsim2(system[, U, T, X0]) | 使用 ODE 求解器 scipy.integrate.odeint 模拟连续时间线性系统的输出。 |
impulse(system[, X0, T, N]) | 连续时间系统的冲激响应。 |
impulse2(system[, X0, T, N]) | 单输入连续时间线性系统的冲激响应。 |
step(system[, X0, T, N]) | 连续时间系统的阶跃响应。 |
step2(system[, X0, T, N]) | 连续时间系统的阶跃响应。 |
freqresp(system[, w, n]) | 计算连续时间系统的频率响应。 |
bode(system[, w, n]) | 计算连续时间系统的波德幅度和相位数据。 |
离散时间线性系统
dlti(*system, **kwargs) | 离散时间线性时不变系统基类。 |
|---|---|
StateSpace(*system, **kwargs) | 状态空间形式的线性时不变系统。 |
TransferFunction(*system, **kwargs) | 传递函数形式的线性时不变系统类。 |
ZerosPolesGain(*system, **kwargs) | 零点、极点、增益形式的线性时不变系统类。 |
dlsim(system, u[, t, x0]) | 模拟离散时间线性系统的输出。 |
dimpulse(system[, x0, t, n]) | 离散时间系统的冲激响应。 |
dstep(system[, x0, t, n]) | 离散时间系统的阶跃响应。 |
dfreqresp(system[, w, n, whole]) | 计算离散时间系统的频率响应。 |
dbode(system[, w, n]) | 计算离散时间系统的波德幅度和相位数据。 |
LTI 表示
tf2zpk(b, a) | 从分子、分母表示的线性滤波器返回零点、极点、增益（z, p, k）表示。 |
|---|---|
tf2sos(b, a[, pairing, analog]) | 从传递函数表示返回二阶段节。 |
tf2ss(num, den) | 传递函数到状态空间表示。 |
zpk2tf(z, p, k) | 从零点和极点返回多项式传递函数表示。 |
zpk2sos(z, p, k[, pairing, analog]) | 从系统的零点、极点和增益返回二阶段节。 |
zpk2ss(z, p, k) | 零极点增益表示转换为状态空间表示 |
ss2tf(A, B, C, D[, input]) | 状态空间到传递函数的转换。 |
ss2zpk(A, B, C, D[, input]) | 状态空间表示转换为零极点增益表示。 |
sos2zpk(sos) | 返回一系列二阶段的零点、极点和增益 |
sos2tf(sos) | 从一系列二阶段得到单一传递函数 |
cont2discrete(system, dt[, method, alpha]) | 将连续状态空间系统转换为离散系统。 |
place_poles(A, B, poles[, method, rtol, maxiter]) | 计算 K 使得特征值（A - dot(B, K))=poles。 |
波形
chirp(t, f0, t1, f1[, method, phi, vertex_zero]) | 频率扫描余弦波生成器。 |
|---|---|
gausspulse(t[, fc, bw, bwr, tpr, retquad, ...]) | 返回高斯调制正弦波： |
max_len_seq(nbits[, state, length, taps]) | 最大长度序列（MLS）生成器。 |
sawtooth(t[, width]) | 返回周期锯齿波形或三角波形。 |
square(t[, duty]) | 返回周期方波波形。 |
sweep_poly(t, poly[, phi]) | 频率扫描余弦波生成器，具有时间相关的频率。 |
unit_impulse(shape[, idx, dtype]) | 单位冲激信号（离散δ函数）或单位基向量。 |
窗口函数
对于窗口函数，请参见scipy.signal.windows命名空间。
在scipy.signal命名空间中，有一个方便的函数可通过名称获取这些窗口：
get_window(window, Nx[, fftbins]) | 返回指定长度和类型的窗口。 |
|---|
小波
cascade(hk[, J]) | 从滤波器系数返回 dyadic 点K/2**J处的(x, phi, psi)。 |
|---|---|
daub(p) | 产生 Daubechies 小波的 FIR 低通滤波器系数。 |
morlet(M[, w, s, complete]) | 复杂 Morlet 小波。 |
qmf(hk) | 从低通滤波器返回高通 qmf 滤波器。 |
ricker(points, a) | 返回一个 Ricker 小波，也称为“墨西哥帽小波”。 |
morlet2(M, s[, w]) | 复杂 Morlet 小波，专为与cwt一起使用而设计。 |
cwt(data, wavelet, widths[, dtype]) | 连续小波变换。 |
峰值检测
argrelmin(data[, axis, order, mode]) | 计算data的相对最小值。 |
|---|---|
argrelmax(data[, axis, order, mode]) | 计算data的相对最大值。 |
argrelextrema(data, comparator[, axis, ...]) | 计算data的相对极值。 |
find_peaks(x[, height, threshold, distance, ...]) | 基于峰值特性在信号内部找到峰值。 |
find_peaks_cwt(vector, widths[, wavelet, ...]) | 使用小波变换在 1-D 数组中找到峰值。 |
peak_prominences(x, peaks[, wlen]) | 计算信号中每个峰值的显著性。 |
peak_widths(x, peaks[, rel_height, ...]) | 计算信号中每个峰值的宽度。 |
谱分析
periodogram(x[, fs, window, nfft, detrend, ...]) | 使用周期图估算功率谱密度。 |
|---|---|
welch(x[, fs, window, nperseg, noverlap, ...]) | 使用 Welch 方法估算功率谱密度。 |
csd(x, y[, fs, window, nperseg, noverlap, ...]) | 使用 Welch 方法估计交叉功率谱密度 Pxy。 |
coherence(x, y[, fs, window, nperseg, ...]) | 使用 Welch 方法估计离散时间信号 X 和 Y 的幅度平方相干估计 Cxy。 |
spectrogram(x[, fs, window, nperseg, ...]) | 使用连续傅里叶变换计算谱图。 |
lombscargle(x, y, freqs) | 计算朗伯-斯卡戈尔周期图。 |
vectorstrength(events, period) | 确定与给定周期对应的事件的向量强度。 |
ShortTimeFFT(win, hop, fs, *[, fft_mode, ...]) | 提供参数化的离散短时傅里叶变换（STFT）及其逆变换（ISTFT）。 |
stft(x[, fs, window, nperseg, noverlap, ...]) | 计算短时傅里叶变换（STFT）。 |
istft(Zxx[, fs, window, nperseg, noverlap, ...]) | 执行逆短时傅里叶变换（iSTFT）。 |
check_COLA(window, nperseg, noverlap[, tol]) | 检查是否满足恒定重叠添加（COLA）约束。 |
check_NOLA(window, nperseg, noverlap[, tol]) | 检查非零重叠添加（NOLA）约束是否满足。 |
Chirp Z-transform and Zoom FFT
czt(x[, m, w, a, axis]) | 计算 Z 平面上螺旋周围的频率响应。 |
|---|---|
zoom_fft(x, fn[, m, fs, endpoint, axis]) | 仅计算范围内频率 fn 的 x 的离散傅里叶变换（DFT）。 |
CZT(n[, m, w, a]) | 创建可调用的啁啾 Z 变换函数。 |
ZoomFFT(n, fn[, m, fs, endpoint]) | 创建可调用的缩放 FFT 变换函数。 |
czt_points(m[, w, a]) | 返回进行啁啾 Z 变换的点。 |
函数比类更易于使用，但在对许多长度相同的数组执行相同变换时效率较低，因为它们在每次调用时都会重复生成相同的啁啾信号。在这些情况下，使用类来创建可重复使用的函数更为合适。
scipy.signal.convolve
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.convolve.html#scipy.signal.convolve
scipy.signal.convolve(in1, in2, mode='full', method='auto')
对两个 N 维数组进行卷积。
使用mode参数确定输出大小，对in1和in2进行卷积。
参数：
in1array_like
第一个输入。
in2array_like
第二输入。应与in1具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}，可选
一个表示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含那些不依赖于零填充的元素。在‘valid’模式下，in1或in2必须至少在每个维度上与另一个一样大。
same
输出与in1相同大小，并相对于‘full’输出中心化。
methodstr {‘auto’, ‘direct’, ‘fft’}，可选
一个表示计算卷积使用的方法的字符串。
direct
卷积直接来自求和，即卷积的定义。
fft
通过调用fftconvolve使用傅立叶变换执行卷积。
auto
根据估计选择直接方法或傅立叶方法（默认）以提高速度。更多详细信息请参见注释。
新版本 0.19.0 中引入。
返回：
convolvearray
包含in1与in2的离散线性卷积子集的 N 维数组。
警告：
RuntimeWarning
在包含 NAN 或 INF 的输入上使用 FFT 卷积将导致整个输出为 NAN 或 INF。当输入包含 NAN 或 INF 值时，请使用 method=’direct’。
另请参见
执行多项式乘法（相同操作，但还接受 poly1d 对象）
choose_conv_method
选择最快适当的卷积方法
fftconvolve
始终使用 FFT 方法。
oaconvolve
使用重叠-添加方法进行卷积，当输入数组大且大小显著不同时通常更快。
注释
默认情况下，convolve 和 correlate 使用 method='auto'，这会调用 choose_conv_method 来选择最快的方法，使用预先计算的值（choose_conv_method 还可以通过关键字参数测量真实世界的时间）。因为 fftconvolve 依赖于浮点数，所以存在某些约束可能会强制使用 method=direct（详细信息请参见 choose_conv_method 文档字符串）。
示例
使用汉宁窗口平滑方波脉冲：
>>> import numpy as np
>>> from scipy import signal
>>> sig = np.repeat([0., 1., 0.], 100)
>>> win = signal.windows.hann(50)
>>> filtered = signal.convolve(sig, win, mode='same') / sum(win)
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_win, ax_filt) = plt.subplots(3, 1, sharex=True)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('Original pulse')
>>> ax_orig.margins(0, 0.1)
>>> ax_win.plot(win)
>>> ax_win.set_title('Filter impulse response')
>>> ax_win.margins(0, 0.1)
>>> ax_filt.plot(filtered)
>>> ax_filt.set_title('Filtered signal')
>>> ax_filt.margins(0, 0.1)
>>> fig.tight_layout()
>>> fig.show()
scipy.signal.correlate
scipy.signal.correlate(in1, in2, mode='full', method='auto')
交叉相关两个 N 维数组。
对 in1 和 in2 进行交叉相关，输出大小由 mode 参数确定。
参数：
in1array_like
第一个输入。
in2array_like
第二个输入。应与 in1 具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}, 可选
一个指示输出大小的字符串：
full
输出是输入的完整离散线性交叉相关。（默认）
valid
输出仅包含不依赖于零填充的元素。在“有效”模式下，in1 或 in2 在每个维度上至少与另一个一样大。
same
输出与 in1 相同大小，相对于“full”输出居中。
methodstr {‘auto’, ‘direct’, ‘fft’}, 可选
表示计算相关性的方法的字符串。
direct
相关性直接根据总和确定。
fft
使用快速傅里叶变换来更快地执行相关性计算（仅适用于数值数组）。
auto
基于估计的速度更快的直接或傅里叶方法（默认）自动选择。详细信息请参阅 convolve 说明。
从版本 0.19.0 开始新添加。
返回：
correlatearray
包含 in1 与 in2 的离散线性交叉相关的子集的 N 维数组。
另请参阅
choose_conv_method
包含更多关于 method 的文档。
correlation_lags
计算 1D 交叉相关的滞后/位移索引数组。
注意
两个 d 维数组 x 和 y 的相关性 z 定义为：
z[...,k,...] = sum[..., i_l, ...] x[..., i_l,...] * conj(y[..., i_l - k,...])
因此，如果 x 和 y 是 1-D 数组，并且 z = correlate(x, y, 'full')，则
[z[k] = (x * y)(k - N + 1) = \sum_{l=0}^{||x||-1}x_l y_{l-k+N-1}^{*}]
对于 (k = 0, 1, ..., ||x|| + ||y|| - 2)
其中 (||x||) 是 x 的长度，(N = \max(||x||,||y||))，当 m 超出 y 的范围时，(y_m) 为 0。
method='fft' 仅适用于数值数组，因为它依赖于 fftconvolve。在某些情况下（例如，对象数组或者当四舍五入整数可能会丢失精度时），始终使用 method='direct'。
在使用偶数长度输入的“same”模式时，correlate 和 correlate2d 的输出不同：它们之间有一个 1 索引偏移。
示例
使用互相关实现匹配滤波器，以恢复通过噪声通道传输的信号。
>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 1., 0., 1., 0., 0., 1.], 128)
>>> sig_noise = sig + rng.standard_normal(len(sig))
>>> corr = signal.correlate(sig_noise, np.ones(128), mode='same') / 128
>>> clock = np.arange(64, len(sig), 128)
>>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, sharex=True)
>>> ax_orig.plot(sig)
>>> ax_orig.plot(clock, sig[clock], 'ro')
>>> ax_orig.set_title('Original signal')
>>> ax_noise.plot(sig_noise)
>>> ax_noise.set_title('Signal with noise')
>>> ax_corr.plot(corr)
>>> ax_corr.plot(clock, corr[clock], 'ro')
>>> ax_corr.axhline(0.5, ls=':')
>>> ax_corr.set_title('Cross-correlated with rectangular pulse')
>>> ax_orig.margins(0, 0.1)
>>> fig.tight_layout()
>>> plt.show()
计算带噪声信号与原始信号的互相关。
>>> x = np.arange(128) / 128
>>> sig = np.sin(2 * np.pi * x)
>>> sig_noise = sig + rng.standard_normal(len(sig))
>>> corr = signal.correlate(sig_noise, sig)
>>> lags = signal.correlation_lags(len(sig), len(sig_noise))
>>> corr /= np.max(corr)
>>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, figsize=(4.8, 4.8))
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('Original signal')
>>> ax_orig.set_xlabel('Sample Number')
>>> ax_noise.plot(sig_noise)
>>> ax_noise.set_title('Signal with noise')
>>> ax_noise.set_xlabel('Sample Number')
>>> ax_corr.plot(lags, corr)
>>> ax_corr.set_title('Cross-correlated signal')
>>> ax_corr.set_xlabel('Lag')
>>> ax_orig.margins(0, 0.1)
>>> ax_noise.margins(0, 0.1)
>>> ax_corr.margins(0, 0.1)
>>> fig.tight_layout()
>>> plt.show()
scipy.signal.fftconvolve
scipy.signal.fftconvolve(in1, in2, mode='full', axes=None)
使用 FFT 对两个 N 维数组进行卷积。
使用快速 Fourier 变换方法对 in1 和 in2 进行卷积，输出大小由 mode 参数确定。
对于大数组（n > ~500），这通常比 convolve 快得多，但是当仅需要少数输出值时可能较慢，并且只能输出浮点数数组（整数或对象数组输入将转换为浮点数）。
自 v0.19 起，convolve 根据哪种方法更快的估计自动选择。
参数:
in1array_like
第一个输入。
in2array_like
第二个输入。应与 in1 具有相同数量的维度。
modestr {'full', 'valid', 'same'}，可选
指示输出大小的字符串:
full
输出是输入的完整离散线性卷积。(默认)
valid
输出仅包含不依赖于零填充的元素。在 'valid' 模式下，in1 或 in2 在每个维度上必须至少与另一个一样大。
same
输出与 in1 大小相同，相对于 'full' 输出居中。
axesint 或 array_like 的整数或 None，可选
计算卷积的轴。默认为所有轴。
返回:
outarray
包含 in1 与 in2 的离散线性卷积的子集的 N 维数组。
另请参阅
convolve
根据速度选择直接卷积或 FFT 卷积算法。
oaconvolve
当输入数组大且尺寸显著不同时，使用重叠-添加方法进行卷积通常更快。
示例
白噪声的自相关是一个脉冲。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> sig = rng.standard_normal(1000)
>>> autocorr = signal.fftconvolve(sig, sig[::-1], mode='full')
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('White noise')
>>> ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr)
>>> ax_mag.set_title('Autocorrelation')
>>> fig.tight_layout()
>>> fig.show()
使用 FFT 卷积实现高斯模糊。请注意图像周围的黑暗边界，这是由于超出其边界的零填充所致。convolve2d 函数允许其他类型的图像边界，但速度较慢。
>>> from scipy import datasets
>>> face = datasets.face(gray=True)
>>> kernel = np.outer(signal.windows.gaussian(70, 8),
... signal.windows.gaussian(70, 8))
>>> blurred = signal.fftconvolve(face, kernel, mode='same')
>>> fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(3, 1,
... figsize=(6, 15))
>>> ax_orig.imshow(face, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_kernel.imshow(kernel, cmap='gray')
>>> ax_kernel.set_title('Gaussian kernel')
>>> ax_kernel.set_axis_off()
>>> ax_blurred.imshow(blurred, cmap='gray')
>>> ax_blurred.set_title('Blurred')
>>> ax_blurred.set_axis_off()
>>> fig.show()
scipy.signal.oaconvolve
scipy.signal.oaconvolve(in1, in2, mode='full', axes=None)
使用重叠添加方法对两个 N 维数组进行卷积。
使用重叠添加方法对in1和in2进行卷积，输出大小由mode参数确定。
对于大数组（n > ~500），这通常比convolve快得多，并且通常比fftconvolve快得多，当一个数组远大于另一个数组时，但当仅需要少量输出值或数组在形状上非常相似时，可能会更慢，并且只能输出浮点数组（int 或 object 数组输入将被转换为 float）。
参数：
in1array_like
第一个输入。
in2array_like
第二输入。应该与in1具有相同的维数。
modestr {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅由不依赖于零填充的元素组成。在“valid”模式下，in1或in2必须在每个维度上至少与另一个一样大。
same
输出与in1大小相同，相对于“full”输出居中。
axesint 或 int 数组或 None，可选
要计算卷积的轴。默认在所有轴上。
返回：
outarray
包含in1与in2离散线性卷积子集的 N 维数组。
另请参阅
convolve
根据哪个更快，使用直接卷积或 FFT 卷积算法。
fftconvolve
使用 FFT 实现的卷积。
注意事项
新版本 1.4.0 中引入。
参考文献
[1]
Wikipedia，“重叠添加方法”。en.wikipedia.org/wiki/Overlap-add_method
[2]
Richard G. Lyons. 《理解数字信号处理》，第三版，2011。第 13.10 章。ISBN 13: 978-0137-02741-5
示例
用 512 个样本的滤波器卷积一个 100,000 个样本的信号。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> sig = rng.standard_normal(100000)
>>> filt = signal.firwin(512, 0.01)
>>> fsig = signal.oaconvolve(sig, filt)
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
>>> ax_orig.plot(sig)
>>> ax_orig.set_title('White noise')
>>> ax_mag.plot(fsig)
>>> ax_mag.set_title('Filtered noise')
>>> fig.tight_layout()
>>> fig.show()
scipy.signal.convolve2d
scipy.signal.convolve2d(in1, in2, mode='full', boundary='fill', fillvalue=0)
对两个二维数组进行卷积。
用于计算输出大小的模式以及由 boundary 和 fillvalue 决定的边界条件对 in1 和 in2 进行卷积。
参数：
in1 类似数组
First input.
in2 类似数组
第二个输入。应该与 in1 具有相同数量的维度。
mode 字符串 {‘full’, ‘valid’, ‘same’}，可选
表示输出大小的字符串：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含不依赖于零填充的元素。在“valid”模式下，in1 或 in2 在每个维度上至少必须与另一个一样大。
same
输出与 in1 相同大小，并相对于“full”输出居中。
boundary 字符串 {‘fill’, ‘wrap’, ‘symm’}，可选
一个指示如何处理边界的标志：
fill
用 fillvalue 填充输入数组。（默认）
wrap
循环边界条件。
symm
对称边界条件。
fillvalue 标量，可选
用于填充输入数组的值。默认为 0。
返回：
out ndarray
包含 in1 与 in2 离散线性卷积子集的二维数组。
示例
使用复杂的 Scharr 算子通过 2D 卷积计算图像的梯度。（水平操作符是实部，垂直是虚部。）使用对称边界条件避免在图像边界创建边缘。
>>> import numpy as np
>>> from scipy import signal
>>> from scipy import datasets
>>> ascent = datasets.ascent()
>>> scharr = np.array([[ -3-3j, 0-10j, +3 -3j],
... [-10+0j, 0+ 0j, +10 +0j],
... [ -3+3j, 0+10j, +3 +3j]]) # Gx + j*Gy
>>> grad = signal.convolve2d(ascent, scharr, boundary='symm', mode='same')
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_mag, ax_ang) = plt.subplots(3, 1, figsize=(6, 15))
>>> ax_orig.imshow(ascent, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_mag.imshow(np.absolute(grad), cmap='gray')
>>> ax_mag.set_title('Gradient magnitude')
>>> ax_mag.set_axis_off()
>>> ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles
>>> ax_ang.set_title('Gradient orientation')
>>> ax_ang.set_axis_off()
>>> fig.show()
scipy.signal.correlate2d
scipy.signal.correlate2d(in1, in2, mode='full', boundary='fill', fillvalue=0)
交叉相关两个二维数组。
用mode确定输出大小，boundary和fillvalue确定边界条件交叉相关in1和in2。
参数：
in1array_like
第一个输入。
in2array_like
第二个输入。应与in1具有相同数量的维度。
modestr {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串：
full
输出是输入的完整离散线性交叉相关。（默认）
valid
输出仅包含那些不依赖于零填充的元素。在“valid”模式下，in1或in2必须至少在每个维度上与另一个一样大。
same
输出与in1相同大小，相对于“full”输出居中。
boundarystr {‘fill’, ‘wrap’, ‘symm’}，可选
指示如何处理边界的标志：
fill
用 fillvalue 填充输入数组。（默认）
wrap
循环边界条件。
symm
对称边界条件。
fillvaluescalar，可选
用于填充填充输入数组的值。默认为 0。
返回：
correlate2dndarray
包含in1与in2的离散线性交叉相关子集的二维数组。
注意事项
使用偶数长度输入的“same”模式时，correlate和correlate2d的输出不同：它们之间存在 1 索引偏移。
示例
使用 2D 交叉相关在嘈杂图像中找到模板的位置：
>>> import numpy as np
>>> from scipy import signal
>>> from scipy import datasets
>>> rng = np.random.default_rng()
>>> face = datasets.face(gray=True) - datasets.face(gray=True).mean()
>>> template = np.copy(face[300:365, 670:750]) # right eye
>>> template -= template.mean()
>>> face = face + rng.standard_normal(face.shape) * 50 # add noise
>>> corr = signal.correlate2d(face, template, boundary='symm', mode='same')
>>> y, x = np.unravel_index(np.argmax(corr), corr.shape) # find the match
>>> import matplotlib.pyplot as plt
>>> fig, (ax_orig, ax_template, ax_corr) = plt.subplots(3, 1,
... figsize=(6, 15))
>>> ax_orig.imshow(face, cmap='gray')
>>> ax_orig.set_title('Original')
>>> ax_orig.set_axis_off()
>>> ax_template.imshow(template, cmap='gray')
>>> ax_template.set_title('Template')
>>> ax_template.set_axis_off()
>>> ax_corr.imshow(corr, cmap='gray')
>>> ax_corr.set_title('Cross-correlation')
>>> ax_corr.set_axis_off()
>>> ax_orig.plot(x, y, 'ro')
>>> fig.show()
scipy.signal.sepfir2d
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.sepfir2d.html#scipy.signal.sepfir2d
scipy.signal.sepfir2d(input, hrow, hcol)
用二维可分离 FIR 滤波器进行卷积。
将二阶排列输入数组与由一阶数组 hrow 和 hcol 定义的可分离滤波器卷积。假设使用镜像对称边界条件。此函数可用于根据其 B-样条表示找到图像。
参数：
inputndarray
输入信号。必须是二阶数组。
hrowndarray
定义滤波器行方向的一阶数组。必须是奇数长度。
hcolndarray
定义滤波器列方向的一阶数组。必须是奇数长度。
返回：
outputndarray
过滤后的信号。
示例
示例显示在教程中。
scipy.signal.choose_conv_method
scipy.signal.choose_conv_method(in1, in2, mode='full', measure=False)
找到最快的卷积/相关方法。
主要用于在卷积和相关的method='auto'选项期间调用。它还可用于确定许多相同 dtype/shape 的卷积的method的值。此外，它支持根据特定输入和/或硬件的时间来调整method的值。
参数：
in1类数组
传递给卷积函数的第一个参数。
in2类数组
传递给卷积函数的第二个参数。
模式字符串 {‘full’, ‘valid’, ‘same’}，可选
输出大小的字符串指示：
full
输出是输入的完整离散线性卷积。（默认）
valid
输出仅包含不依赖于零填充的元素。
same
输出与in1相同大小，相对于‘full’输出居中。
测量布尔值，可选
如果为 True，则使用两种方法运行和计时in1和in2的卷积，并返回最快的方法。如果为 False（默认），则使用预计算的值预测最快方法。
返回：
方法字符串
指示哪种卷积方法最快的字符串，可以是‘direct’或‘fft’
times字典，可选
包含每种方法所需时间（以秒为单位）的字典。仅当measure=True时才返回此值。
另见
卷积
相关
注意
一般来说，对于随机选择的输入尺寸，此方法在 2D 信号中的准确率为 99%，在 1D 信号中为 85%。为了精度，使用measure=True来找到计算卷积所需的最快方法。这可以用来避免稍后找到最快method的最小开销，或者根据特定输入集合调整method的值。
实验在 Amazon EC2 r5a.2xlarge 机器上运行，以测试此函数。这些实验测量了使用method='auto'时所需的时间与最快方法（即ratio = time_auto / min(time_fft, time_direct)）之间的比率。在这些实验中，我们发现：
-
对于 1D 信号，这个比率小于 1.5 的可能性为 95%，对于 2D 信号，这个比率小于 2.5 的可能性为 99%。
-
对于 1D/2D 信号，这个比率始终小于 2.5/5。
-
此函数在处理
method='direct'的 1D 卷积时最不准确，耗时介于 1 到 10 毫秒之间。在我们的实验中，这个值的一个良好代理是1e6 <= in1.size * in2.size <= 1e7。
2D 结果几乎可以肯定地推广到 3D/4D 等，因为实现是相同的（1D 实现是不同的）。
上述所有数字都特定于 EC2 机器。然而，我们确实发现该函数在不同硬件上表现相当良好。速度测试的质量与调整此函数数字的机器相似（一台 2014 年中期的 15 英寸 MacBook Pro，配备 16GB RAM 和 2.5GHz 的 Intel i7 处理器）。
存在一些情况，fftconvolve支持输入，但此函数返回direct（例如，为了防止浮点整数精度问题）。
从 0.19 版本开始新增。
示例
估算给定输入的最快方法：
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> img = rng.random((32, 32))
>>> filter = rng.random((8, 8))
>>> method = signal.choose_conv_method(img, filter, mode='same')
>>> method
'fft'
然后可以应用于相同数据类型和形状的其他数组：
>>> img2 = rng.random((32, 32))
>>> filter2 = rng.random((8, 8))
>>> corr2 = signal.correlate(img2, filter2, mode='same', method=method)
>>> conv2 = signal.convolve(img2, filter2, mode='same', method=method)
此函数的输出(method)与correlate和convolve一起使用。
scipy.signal.correlation_lags
scipy.signal.correlation_lags(in1_len, in2_len, mode='full')
计算一维交叉相关的滞后/位移索引数组。
参数：
in1_len整数
第一个输入大小。
in2_len整数
第二个输入大小。
模式str {‘full’, ‘valid’, ‘same’}，可选
指示输出大小的字符串。有关更多信息，请参阅文档correlate。
返回：
lags数组
返回一个包含交叉相关滞后/位移索引的数组。可以使用相关性的 np.argmax 来索引 lag/displacement。
另请参阅
计算 N 维交叉相关。
注意事项
连续函数(f)和(g)的交叉相关定义为：
[\left ( f\star g \right )\left ( \tau \right ) \triangleq \int_{t_0}^{t_0 +T} \overline{f\left ( t \right )}g\left ( t+\tau \right )dt]
其中(\tau)定义为位移，也称为滞后。
离散函数(f)和(g)的交叉相关定义为：
[\left ( f\star g \right )\left [ n \right ] \triangleq \sum_{-\infty}^{\infty} \overline{f\left [ m \right ]}g\left [ m+n \right ]]
其中(n)为滞后。
示例
信号与其自身延迟的交叉相关。
>>> import numpy as np
>>> from scipy import signal
>>> rng = np.random.default_rng()
>>> x = rng.standard_normal(1000)
>>> y = np.concatenate([rng.standard_normal(100), x])
>>> correlation = signal.correlate(x, y, mode="full")
>>> lags = signal.correlation_lags(x.size, y.size, mode="full")
>>> lag = lags[np.argmax(correlation)]
scipy.signal.bspline
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.bspline.html#scipy.signal.bspline
scipy.signal.bspline(x, n)
自版本 1.11.0 起已弃用：scipy.signal.bspline 在 SciPy 1.11 中已弃用，并将在 SciPy 1.13 中移除。
对于浮点数组 x 的精确等价物是：
>>> import numpy as np
>>> from scipy.interpolate import BSpline
>>> knots = np.arange(-(n+1)/2, (n+3)/2)
>>> out = BSpline.basis_element(knots)(x)
>>> out[(x < knots[0]) | (x > knots[-1])] = 0.0
阶数为 n 的 B 样条基函数。
参数：
xarray_like
一个结点向量
nint
样条的阶数。必须是非负的，即 n >= 0
返回：
resndarray
B 样条基函数值
另请参见
cubic
一个立方 B 样条。
quadratic
一个二次 B 样条。
注意事项
使用 numpy.piecewise 和自动函数生成器。
示例
我们可以计算几个阶数的 B 样条基函数：
>>> import numpy as np
>>> from scipy.signal import bspline, cubic, quadratic
>>> bspline(0.0, 1)
1
>>> knots = [-1.0, 0.0, -1.0]
>>> bspline(knots, 2)
array([0.125, 0.75, 0.125])
>>> np.array_equal(bspline(knots, 2), quadratic(knots))
True
>>> np.array_equal(bspline(knots, 3), cubic(knots))
True
scipy.signal.cubic
原文：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cubic.html#scipy.signal.cubic
scipy.signal.cubic(x)
自 SciPy 1.11.0 版本起不推荐使用：scipy.signal.cubic在 SciPy 1.11 中已弃用，并将在 SciPy 1.13 中移除。
具体的等价（对于浮点数组x）是：
>>> from scipy.interpolate import BSpline
>>> out = BSpline.basis_element([-2, -1, 0, 1, 2])(x)
>>> out[(x < -2 | (x > 2)] = 0.0
三次 B 样条。
这是bspline的一个特例，相当于bspline(x, 3)。
参数：
xarray_like
一个结点向量
返回：
resndarray
三次 B 样条基函数值
另请参阅
bspline
B 样条阶数为 n 的基函数
quadratic
二次 B 样条。
示例
我们可以计算几个阶数的 B 样条基函数：
>>> import numpy as np
>>> from scipy.signal import bspline, cubic, quadratic
>>> bspline(0.0, 1)
1
>>> knots = [-1.0, 0.0, -1.0]
>>> bspline(knots, 2)
array([0.125, 0.75, 0.125])
>>> np.array_equal(bspline(knots, 2), quadratic(knots))
True
>>> np.array_equal(bspline(knots, 3), cubic(knots))
True
scipy.signal.quadratic
scipy.signal.quadratic(x)
自 1.11.0 版本起弃用：scipy.signal.quadratic
对于浮点数数组x的确切等效是：
>>> from scipy.interpolate import BSpline
>>> out = BSpline.basis_element([-1.5, -0.5, 0.5, 1.5])(x)
>>> out[(x < -1.5 | (x > 1.5)] = 0.0
一个二次 B 样条。
这是bspline的特殊情况，等同于bspline(x, 2)。
参数：
xarray_like
结点向量
返回：
resndarray
二次 B 样条基函数值
另请参阅
阶数为 n 的 B 样条基函数
一个三次 B 样条。
示例
我们可以计算多个阶次的 B 样条基函数：
>>> import numpy as np
>>> from scipy.signal import bspline, cubic, quadratic
>>> bspline(0.0, 1)
1
>>> knots = [-1.0, 0.0, -1.0]
>>> bspline(knots, 2)
array([0.125, 0.75, 0.125])
>>> np.array_equal(bspline(knots, 2), quadratic(knots))
True
>>> np.array_equal(bspline(knots, 3), cubic(knots))
True
scipy.signal.gauss_spline
scipy.signal.gauss_spline(x, n)
n 阶 B 样条基函数的高斯近似。
参数：
x array_like
结节向量
n整型
样条的阶数。必须为非负数，即 n >= 0
返回值：
res ndarray
B 样条基函数值由均值为零的高斯函数近似。
注意事项：
B 样条基函数可以用均值为零、标准差等于(\sigma=(n+1)/12)的高斯函数很好地近似：
[\frac{1}{\sqrt {2\pi\sigma²}}exp(-\frac{x²}{2\sigma})]
参考文献：
[1]
Bouma H., Vilanova A., Bescos J.O., ter Haar Romeny B.M., Gerritsen F.A. (2007) 基于 B 样条的快速精确高斯导数。在：Sgallari F., Murli A., Paragios N. (eds) 计算机视觉中的尺度空间与变分方法。SSVM 2007. 计算机科学讲座笔记，4485. Springer, Berlin, Heidelberg
[2]
folk.uio.no/inf3330/scripting/doc/python/SciPy/tutorial/old/node24.html
示例
我们可以计算由高斯分布近似的 B 样条基函数：
>>> import numpy as np
>>> from scipy.signal import gauss_spline, bspline
>>> knots = np.array([-1.0, 0.0, -1.0])
>>> gauss_spline(knots, 3)
array([0.15418033, 0.6909883, 0.15418033]) # may vary
>>> bspline(knots, 3)
array([0.16666667, 0.66666667, 0.16666667]) # may vary
scipy.signal.cspline1d
scipy.signal.cspline1d(signal, lamb=0.0)
计算秩-1 数组的三次样条系数。
假设镜像对称边界条件，找到一维信号的三次样条系数。为了从样条表示中恢复信号，使用长度为 3 的 FIR 窗口 [1.0, 4.0, 1.0]/ 6.0 镜像对称卷积这些系数。
参数：
signal ndarray
一个表示信号样本的秩-1 数组。
lamb float, optional
平滑系数，默认为 0.0。
返回值：
c ndarray
三次样条系数。
参见
cspline1d_eval
在新点集上评估三次样条。
示例
我们可以使用三次样条来滤波信号，以减少并平滑高频噪声：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.signal import cspline1d, cspline1d_eval
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 0.], 100)
>>> sig += rng.standard_normal(len(sig))*0.05 # add noise
>>> time = np.linspace(0, len(sig))
>>> filtered = cspline1d_eval(cspline1d(sig), time)
>>> plt.plot(sig, label="signal")
>>> plt.plot(time, filtered, label="filtered")
>>> plt.legend()
>>> plt.show()
scipy.signal.qspline1d
scipy.signal.qspline1d(signal, lamb=0.0)
计算秩为 1 的数组的二次样条系数。
参数：
signalndarray
代表信号样本的秩为 1 的数组。
lambfloat, optional
平滑系数（现在必须为零）。
返回：
cndarray
二次样条系数。
另请参见
qspline1d_eval
在新的点集上评估二次样条。
注意事项
假设镜像对称边界条件，为 1-D 信号找到二次样条系数。为了从样条表示中恢复信号，使用长度为 3 的 FIR 窗口[1.0, 6.0, 1.0] / 8.0 镜像对称卷积这些系数。
示例
通过二次样条可以滤波信号，以减少和平滑高频噪声：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.signal import qspline1d, qspline1d_eval
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 0.], 100)
>>> sig += rng.standard_normal(len(sig))*0.05 # add noise
>>> time = np.linspace(0, len(sig))
>>> filtered = qspline1d_eval(qspline1d(sig), time)
>>> plt.plot(sig, label="signal")
>>> plt.plot(time, filtered, label="filtered")
>>> plt.legend()
>>> plt.show()
scipy.signal.cspline2d
scipy.signal.cspline2d(input, lambda=0.0, precision=-1.0)
二维立方（3 阶）B 样条的系数。
返回二维输入图像的规则间隔输入网格上的三阶 B 样条系数。
参数：
输入ndarray
输入信号。
λfloat
指定传递函数中平滑的程度。
精度float
指定计算无限和以应用镜像对称边界条件所需的精度。
返回：
输出ndarray
过滤后的信号。
示例
示例可以在 tutorial 中找到。
scipy.signal.qspline2d
scipy.signal.qspline2d(input, lambda=0.0, precision=-1.0)
2-D 二次（2 阶）B 样条的系数：
返回二维输入图像在规则间隔的输入网格上的二阶 B 样条系数。
参数：
inputndarray
输入信号。
lambdafloat
指定传递函数中的平滑量。
precisionfloat
指定计算应用镜像对称边界条件所需的无限和的精度。
返回：
outputndarray
过滤后的信号。
示例
示例参见教程。
scipy.signal.cspline1d_eval
scipy.signal.cspline1d_eval(cj, newx, dx=1.0, x0=0)
在新一组点上评估三次样条曲线。
dx 是旧的采样间距，而 x0 是旧的原点。换句话说，cj 表示样条系数的旧样本点（结点）是等间距点：
oldx = x0 + j*dx j=0…N-1，其中 N=len(cj)
边界使用镜像对称边界条件处理。
参数：
cjndarray
三次样条曲线系数
newxndarray
新一组点。
dxfloat，可选
旧的采样间距，默认值为 1.0。
x0int，可选
旧的原点，默认值为 0。
返回：
resndarray
评估了三次样条曲线点。
另请参见
cspline1d
计算一维数组的三次样条系数。
示例
我们可以使用三次样条滤波器来过滤信号，以减少和平滑高频噪声：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.signal import cspline1d, cspline1d_eval
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 0.], 100)
>>> sig += rng.standard_normal(len(sig))*0.05 # add noise
>>> time = np.linspace(0, len(sig))
>>> filtered = cspline1d_eval(cspline1d(sig), time)
>>> plt.plot(sig, label="signal")
>>> plt.plot(time, filtered, label="filtered")
>>> plt.legend()
>>> plt.show()
scipy.signal.qspline1d_eval
scipy.signal.qspline1d_eval(cj, newx, dx=1.0, x0=0)
在新的一组点上评估二次样条。
参数：
cjndarray
二次样条系数
newxndarray
新的一组点。
dxfloat，可选
旧的样本间距，默认值为 1.0。
x0int，可选
旧原点，默认值为 0。
返回：
resndarray
评估了二次样条点。
参见
qspline1d
为 rank-1 数组计算二次样条系数。
注意
dx是旧的样本间距，而x0是旧的原点。换句话说，旧样本点（结点点）为均匀间隔的点：
oldx = x0 + j*dx j=0...N-1, with N=len(cj)
边界使用镜像对称边界条件处理。
示例
我们可以使用二次样条对信号进行滤波，以减少和平滑高频噪声：
>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from scipy.signal import qspline1d, qspline1d_eval
>>> rng = np.random.default_rng()
>>> sig = np.repeat([0., 1., 0.], 100)
>>> sig += rng.standard_normal(len(sig))*0.05 # add noise
>>> time = np.linspace(0, len(sig))
>>> filtered = qspline1d_eval(qspline1d(sig), time)
>>> plt.plot(sig, label="signal")
>>> plt.plot(time, filtered, label="filtered")
>>> plt.legend()
>>> plt.show()
scipy.signal.spline_filter
scipy.signal.spline_filter(Iin, lmbda=5.0)
对一个排名为 2 的数组进行三次样条（立方）平滑滤波。
使用（立方）平滑样条滤波器对输入数据集Iin进行滤波。
参数：
Iinarray_like
输入数据集
lmbdafloat，可选
样条平滑的衰减值，默认为5.0。
返回：
resndarray
过滤后的输入数据
示例
我们可以使用三次 B 样条滤波器来过滤多维信号（例如：2D 图像）：
>>> import numpy as np
>>> from scipy.signal import spline_filter
>>> import matplotlib.pyplot as plt
>>> orig_img = np.eye(20) # create an image
>>> orig_img[10, :] = 1.0
>>> sp_filter = spline_filter(orig_img, lmbda=0.1)
>>> 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.signal.order_filter
scipy.signal.order_filter(a, domain, rank)
在一个 N 维数组上执行顺序滤波。
在输入数组上执行顺序滤波。domain 参数充当以每个像素为中心的蒙版。domain 的非零元素用于选择围绕每个输入像素的元素，并放置在一个列表中。列表被排序，该像素的输出是在排序列表中对应于 rank 的元素。
参数：
andarray
N 维输入数组。
domainarray_like
与a具有相同维数的蒙版数组。每个维度应该有奇数个元素。
rankint
一个非负整数，用于从排序列表中选择元素（0 对应最小元素，1 是下一个最小元素，依此类推）。
返回：
outndarray
与a相同形状的数组中的有序滤波结果。
示例
>>> import numpy as np
>>> from scipy import signal
>>> x = np.arange(25).reshape(5, 5)
>>> domain = np.identity(3)
>>> x
array([[ 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]])
>>> signal.order_filter(x, domain, 0)
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 1., 2., 0.],
[ 0., 5., 6., 7., 0.],
[ 0., 10., 11., 12., 0.],
[ 0., 0., 0., 0., 0.]])
>>> signal.order_filter(x, domain, 2)
array([[ 6., 7., 8., 9., 4.],
[ 11., 12., 13., 14., 9.],
[ 16., 17., 18., 19., 14.],
[ 21., 22., 23., 24., 19.],
[ 20., 21., 22., 23., 24.]])
scipy.signal.medfilt
原文链接：
docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.medfilt.html#scipy.signal.medfilt
scipy.signal.medfilt(volume, kernel_size=None)
对 N 维数组执行中值滤波。
使用由kernel_size 给定的局部窗口大小对输入数组应用中值滤波。数组将自动填充零。
参数：
volume 数组形式
一个 N 维输入数组。
kernel_size 数组形式，可选
标量或长度为 N 的列表，指定每个维度中中值滤波窗口的大小。kernel_size 的元素应为奇数。如果kernel_size 是标量，则在每个维度上使用此标量作为大小。每个维度的默认大小为 3。
返回：
out ndarray
一个与输入大小相同的数组，包含中值滤波后的结果。
警告：
用户警告
如果数组大小在任何维度上小于内核大小
另请参阅
注意事项
更通用的函数scipy.ndimage.median_filter 具有更有效的中值滤波实现，因此运行速度更快。
对于具有uint8、float32或float64数据类型的二维图像，专用函数scipy.signal.medfilt2d 可能更快。
