Signalverarbeitung (scipy.signal)

Faltung

convolve(in1, in2[, mode, method])	Faltet zwei N-dimensionale Arrays.
correlate(in1, in2[, mode, method])	Kreuzkorreliert zwei N-dimensionale Arrays.
fftconvolve(in1, in2[, mode, axes])	Faltet zwei N-dimensionale Arrays mittels FFT.
oaconvolve(in1, in2[, mode, axes])	Faltet zwei N-dimensionale Arrays mittels der Overlap-Add-Methode.
convolve2d(in1, in2[, mode, boundary, fillvalue])	Faltet zwei 2-dimensionale Arrays.
correlate2d(in1, in2[, mode, boundary, ...])	Kreuzkorreliert zwei 2-dimensionale Arrays.
sepfir2d(input, hrow, hcol)	Faltung mit einem 2-D separierbaren FIR-Filter.
choose_conv_method(in1, in2[, mode, measure])	Findet die schnellste Faltungs-/Korrelationsmethode.
correlation_lags(in1_len, in2_len[, mode])	Berechnet die Lag-/Verschiebungsindex-Arrays für die 1D-Kreuzkorrelation.

B-Splines

gauss_spline(x, n)	Gaußsche Annäherung an die B-Spline-Basis Funktion der Ordnung n.
cspline1d(signal[, lamb])	Berechnet kubische Spline-Koeffizienten für ein Rang-1-Array.
qspline1d(signal[, lamb])	Berechnet quadratische Spline-Koeffizienten für ein Rang-1-Array.
cspline2d(signal[, lamb, precision])	Koeffizienten für kubische (3. Ordnung) B-Spline in 2D.
qspline2d(signal[, lamb, precision])	Koeffizienten für quadratische (2. Ordnung) B-Spline in 2D.
cspline1d_eval(cj, newx[, dx, x0])	Evaluiert einen kubischen Spline an einem neuen Satz von Punkten.
qspline1d_eval(cj, newx[, dx, x0])	Evaluiert eine quadratische Spline an einem neuen Satz von Punkten.
spline_filter(Iin[, lmbda])	Glättende Spline (kubische) Filterung eines Rang-2-Arrays.

Filterung

order_filter(a, domain, rank)	Führt einen Ordnungsfilter auf ein N-D-Array aus.
medfilt(volume[, kernel_size])	Führt einen Medianfilter auf ein N-dimensionales Array aus.
medfilt2d(input[, kernel_size])	Medianfiltert ein 2-dimensionales Array.
wiener(im[, mysize, noise])	Führt einen Wiener-Filter auf ein N-dimensionales Array aus.
symiirorder1(signal, c0, z1[, precision])	Implementiert einen glättenden IIR-Filter mit spiegelbildlich-symmetrischen Randbedingungen mittels einer Kaskade von Ordnung-1-Abschnitten.
symiirorder2(input, r, omega[, precision])	Implementiert einen glättenden IIR-Filter mit spiegelbildlich-symmetrischen Randbedingungen mittels einer Kaskade von Ordnung-2-Abschnitten.
lfilter(b, a, x[, axis, zi])	Filtert Daten entlang einer Dimension mit einem IIR- oder FIR-Filter.
lfiltic(b, a, y[, x])	Konstruiert Anfangsbedingungen für lfilter anhand von Ein- und Ausgabeevektoren.
lfilter_zi(b, a)	Konstruiert Anfangsbedingungen für lfilter für den stationären Zustand der Sprungantwort.
filtfilt(b, a, x[, axis, padtype, padlen, ...])	Wendet einen digitalen Filter vorwärts und rückwärts auf ein Signal an.
savgol_filter(x, window_length, polyorder[, ...])	Wendet einen Savitzky-Golay-Filter auf ein Array an.
deconvolve(signal, divisor)	Dekonvolviert divisor aus signal mittels Inversfilterung.
sosfilt(sos, x[, axis, zi])	Filtert Daten entlang einer Dimension mittels kaskadierter zweiter Ordnung.
sosfilt_zi(sos)	Konstruiert Anfangsbedingungen für sosfilt für den stationären Zustand der Sprungantwort.
sosfiltfilt(sos, x[, axis, padtype, padlen])	Ein Vorwärts-Rückwärts-Digitalfilter mittels kaskadierter zweiter Ordnung.
hilbert(x[, N, axis])	FFT-basierte Berechnung des analytischen Signals.
hilbert2(x[, N])	Berechnet das '2-D' analytische Signal von x
envelope(z[, bp_in, n_out, squared, ...])	Berechnet die Einhüllende eines reellen oder komplexwertigen Signals.
decimate(x, q[, n, ftype, axis, zero_phase])	Untersampelt das Signal nach Anwendung eines Aliasing-Schutzfilters.
detrend(data[, axis, type, bp, overwrite_data])	Entfernt einen linearen oder konstanten Trend entlang einer Achse aus den Daten.
resample(x, num[, t, axis, window, domain])	Resampelt x auf num Samples mittels der Fourier-Methode entlang der angegebenen axis.
resample_poly(x, up, down[, axis, window, ...])	Resampelt x entlang der angegebenen Achse mittels Polyphasenfilterung.
upfirdn(h, x[, up, down, axis, mode, cval])	Upsampeln, FIR-Filtern und Downsampeln.

Filterentwurf

bilinear(b, a[, fs])	Berechnet einen digitalen IIR-Filter aus einer analogen Übertragungsfunktion unter Verwendung der bilinearen Transformation.
bilinear_zpk(z, p, k, fs)	Gibt einen digitalen IIR-Filter aus einem analogen mittels bilinearer Transformation zurück.
findfreqs(num, den, N[, kind])	Findet ein Array von Frequenzen zur Berechnung der Antwort eines analogen Filters.
firls(numtaps, bands, desired, *[, weight, fs])	FIR-Filterentwurf mittels Minimierung des kleinsten quadratischen Fehlers.
firwin(numtaps, cutoff, *[, width, window, ...])	FIR-Filterentwurf mittels der Fenster-Methode.
firwin2(numtaps, freq, gain, *[, nfreqs, ...])	FIR-Filterentwurf mittels der Fenster-Methode.
firwin_2d(hsize, window, *[, fc, fs, ...])	2D-FIR-Filterentwurf mittels der Fenster-Methode.
freqs(b, a[, worN, plot])	Frequenzgang eines analogen Filters berechnen.
freqs_zpk(z, p, k[, worN])	Frequenzgang eines analogen Filters berechnen.
freqz(b[, a, worN, whole, plot, fs, ...])	Berechnet die Frequenzantwort eines digitalen Filters.
sosfreqz(*args, **kwargs)	Berechnet die Frequenzantwort eines digitalen Filters im SOS-Format (veraltet).
freqz_sos(sos[, worN, whole, fs])	Berechnet die Frequenzantwort eines digitalen Filters im SOS-Format.
freqz_zpk(z, p, k[, worN, whole, fs])	Berechnet die Frequenzantwort eines digitalen Filters im ZPK-Format.
gammatone(freq, ftype[, order, numtaps, fs])	Gammatone-Filterentwurf.
group_delay(system[, w, whole, fs])	Berechnet die Gruppenlaufzeit eines digitalen Filters.
iirdesign(wp, ws, gpass, gstop[, analog, ...])	Vollständiger IIR-Filterentwurf (digital und analog).
iirfilter(N, Wn[, rp, rs, btype, analog, ...])	IIR-Filterentwurf (digital und analog) unter Angabe von Ordnung und kritischen Punkten.
kaiser_atten(numtaps, width)	Berechnet die Dämpfung eines Kaiser-FIR-Filters.
kaiser_beta(a)	Berechnet den Kaiser-Parameter beta, gegeben die Dämpfung a.
kaiserord(ripple, width)	Bestimmt die Filterfensterparameter für die Kaiser-Fenster-Methode.
minimum_phase(h[, method, n_fft, half])	Konvertiert einen FIR-Filter mit linearer Phase in einen mit minimaler Phase.
savgol_coeffs(window_length, polyorder[, ...])	Berechnet die Koeffizienten für einen 1D-Savitzky-Golay-FIR-Filter.
remez(numtaps, bands, desired, *[, weight, ...])	Berechnet den optimalen Filter im Minimax-Sinn mittels des Remez-Austauschalgorithmus.
unique_roots(p[, tol, rtype])	Bestimmt eindeutige Wurzeln und ihre Vielfachheiten aus einer Liste von Wurzeln.
residue(b, a[, tol, rtype])	Berechnet die Partialbruchzerlegung von b(s) / a(s).
residuez(b, a[, tol, rtype])	Berechnet die Partialbruchzerlegung von b(z) / a(z).
invres(r, p, k[, tol, rtype])	Berechnet b(s) und a(s) aus der Partialbruchzerlegung.
invresz(r, p, k[, tol, rtype])	Berechnet b(z) und a(z) aus der Partialbruchzerlegung.
BadCoefficients	Warnung bezüglich schlecht konditionierter Filterkoeffizienten

Niedrigere Filterentwurfsfunktionen

abcd_normalize([A, B, C, D])	Überprüft Zustandsraummatrizen und stellt sicher, dass sie 2-dimensional sind.
band_stop_obj(wp, ind, passb, stopb, gpass, ...)	Band-Stop-Zielfunktion zur Ordnungminimierung.
besselap(N[, norm])	Gibt (z,p,k) für den analogen Prototyp eines Bessel-Filters der Ordnung N zurück.
buttap(N)	Gibt (z,p,k) für den analogen Prototyp eines Butterworth-Filters der Ordnung N zurück.
cheb1ap(N, rp)	Gibt (z,p,k) für einen analogen Tiefpassfilter vom Chebyshev-Typ I der Ordnung N zurück.
cheb2ap(N, rs)	Gibt (z,p,k) für einen analogen Tiefpassfilter vom Chebyshev-Typ II der Ordnung N zurück.
ellipap(N, rp, rs)	Gibt (z,p,k) für einen analogen Tiefpassfilter vom elliptischen (Cauer) Typ der Ordnung N zurück.
lp2bp(b, a[, wo, bw])	Wandelt einen Tiefpassfilter-Prototyp in einen Bandpassfilter um.
lp2bp_zpk(z, p, k[, wo, bw])	Wandelt einen Tiefpassfilter-Prototyp in einen Bandpassfilter um.
lp2bs(b, a[, wo, bw])	Transformiert einen Tiefpass-Filterprototyp in einen Bandstoppfilter.
lp2bs_zpk(z, p, k[, wo, bw])	Transformiert einen Tiefpass-Filterprototyp in einen Bandstoppfilter.
lp2hp(b, a[, wo])	Wandelt einen Tiefpass-Filterprototyp in einen Hochpass-Filter um.
lp2hp_zpk(z, p, k[, wo])	Wandelt einen Tiefpass-Filterprototyp in einen Hochpass-Filter um.
lp2lp(b, a[, wo])	Transformiert einen Tiefpass-Filterprototyp in eine andere Frequenz.
lp2lp_zpk(z, p, k[, wo])	Transformiert einen Tiefpass-Filterprototyp in eine andere Frequenz.
normalize(b, a)	Normalisiert Zähler/Nenner einer kontinuierlichen Zeitübertragungsfunktion.

Matlab-artige IIR-Filterentwürfe

butter(N, Wn[, btype, analog, output, fs])	Butterworth-Filterentwurf (digital und analog).
buttord(wp, ws, gpass, gstop[, analog, fs])	Auswahl der Ordnung für Butterworth-Filter.
cheby1(N, rp, Wn[, btype, analog, output, fs])	Chebyshev Typ I-Filterentwurf (digital und analog).
cheb1ord(wp, ws, gpass, gstop[, analog, fs])	Auswahl der Ordnung für Chebyshev Typ I-Filter.
cheby2(N, rs, Wn[, btype, analog, output, fs])	Chebyshev Typ II-Filterentwurf (digital und analog).
cheb2ord(wp, ws, gpass, gstop[, analog, fs])	Auswahl der Ordnung für Chebyshev Typ II-Filter.
ellip(N, rp, rs, Wn[, btype, analog, output, fs])	Elliptischer (Cauer) Filterentwurf (digital und analog).
ellipord(wp, ws, gpass, gstop[, analog, fs])	Auswahl der Ordnung für elliptische (Cauer) Filter.
bessel(N, Wn[, btype, analog, output, norm, fs])	Bessel/Thomson Filterentwurf (digital und analog).
iirnotch(w0, Q[, fs])	Entwurf eines digitalen IIR-Notch-Filters zweiter Ordnung.
iirpeak(w0, Q[, fs])	Entwurf eines digitalen IIR-Peak-Filters (Resonanz) zweiter Ordnung.
iircomb(w0, Q[, ftype, fs, pass_zero])	Entwurf eines digitalen IIR-Kammfilters (Notching oder Peaking).

Lineare Systeme mit kontinuierlicher Zeit

lti(*system)	Basisklasse für lineare zeitinvariante Systeme mit kontinuierlicher Zeit.
StateSpace(*system, **kwargs)	Lineares zeitinvariantes System in Zustandsraumform.
TransferFunction(*system, **kwargs)	Klasse für lineare zeitinvariante Systeme in Übertragungsfunktionsform.
ZerosPolesGain(*system, **kwargs)	Klasse für lineare zeitinvariante Systeme in Nullstellen-, Pol- und Verstärkungsform.
lsim(system, U, T[, X0, interp])	Simuliert die Ausgabe eines linearen Systems mit kontinuierlicher Zeit.
impulse(system[, X0, T, N])	Impulsantwort eines Systems mit kontinuierlicher Zeit.
step(system[, X0, T, N])	Sprungantwort eines Systems mit kontinuierlicher Zeit.
freqresp(system[, w, n])	Berechnet die Frequenzantwort eines Systems mit kontinuierlicher Zeit.
bode(system[, w, n])	Berechnet Bode-Größen- und Phasen-Daten eines Systems mit kontinuierlicher Zeit.

Lineare Systeme mit diskreter Zeit

dlti(*system, **kwargs)	Basisklasse für lineare zeitinvariante Systeme mit diskreter Zeit.
StateSpace(*system, **kwargs)	Lineares zeitinvariantes System in Zustandsraumform.
TransferFunction(*system, **kwargs)	Klasse für lineare zeitinvariante Systeme in Übertragungsfunktionsform.
ZerosPolesGain(*system, **kwargs)	Klasse für lineare zeitinvariante Systeme in Nullstellen-, Pol- und Verstärkungsform.
dlsim(system, u[, t, x0])	Simuliert die Ausgabe eines linearen Systems mit diskreter Zeit.
dimpulse(system[, x0, t, n])	Impulsantwort eines Systems mit diskreter Zeit.
dstep(system[, x0, t, n])	Sprungantwort eines Systems mit diskreter Zeit.
dfreqresp(system[, w, n, whole])	Berechnet die Frequenzantwort eines zeitdiskreten Systems.
dbode(system[, w, n])	Berechnet Bode-Betrags- und Phasendaten eines zeitdiskreten Systems.

LTI-Darstellungen

tf2zpk(b, a)	Gibt die Null-, Pol-, Verstärkungs-(z-, p-, k-)Darstellung aus einer Zähler-Nenner-Darstellung eines linearen Filters zurück.
tf2sos(b, a[, pairing, analog])	Gibt Sekundärordnungs-Abschnitte aus einer Übertragungsfunktionsdarstellung zurück
tf2ss(num, den)	Übertragungsfunktion in Zustandsraumdarstellung.
zpk2tf(z, p, k)	Gibt die Polynom-Übertragungsfunktionsdarstellung aus Nullen und Polen zurück
zpk2sos(z, p, k[, pairing, analog])	Gibt Sekundärordnungs-Abschnitte aus Nullen, Polen und Verstärkung eines Systems zurück
zpk2ss(z, p, k)	Null-Pol-Verstärkungs-Darstellung in Zustandsraumdarstellung
ss2tf(A, B, C, D[, input])	Zustandsraum- in Übertragungsfunktion.
ss2zpk(A, B, C, D[, input])	Zustandsraumdarstellung in Null-Pol-Verstärkungs-Darstellung.
sos2zpk(sos)	Gibt Nullen, Pole und Verstärkung einer Reihe von Sekundärordnungs-Abschnitten zurück
sos2tf(sos)	Gibt eine einzelne Übertragungsfunktion aus einer Reihe von Sekundärordnungs-Abschnitten zurück
cont2discrete(system, dt[, method, alpha])	Transformiert ein kontinuierliches in ein diskretes Zustandsraum-System.
place_poles(A, B, poles[, method, rtol, maxiter])	Berechnet K, so dass die Eigenwerte von (A - dot(B, K)) gleich poles sind.

Wellenformen

chirp(t, f0, t1, f1[, method, phi, ...])	Frequenz-Swept-Kosinus-Generator.
gausspulse(t[, fc, bw, bwr, tpr, retquad, ...])	Gibt eine Gauß-modulierte Sinusoide zurück
max_len_seq(nbits[, state, length, taps])	Generator für maximale Längen-Sequenz (MLS).
sawtooth(t[, width])	Gibt eine periodische Sägezahn- oder Dreieckswellenform zurück.
square(t[, duty])	Gibt eine periodische Rechteckwellenform zurück.
sweep_poly(t, poly[, phi])	Frequenz-Swept-Kosinus-Generator mit zeitabhängiger Frequenz.
unit_impulse(shape[, idx, dtype])	Einheitliche Impulssignale (diskrete Deltafunktion) oder Einheitsbasisvektoren.

Fensterfunktionen

Fensterfunktionen finden Sie im Namensraum scipy.signal.windows.

Im Namensraum scipy.signal gibt es eine praktische Funktion, um diese Fenster nach Namen zu erhalten.

get_window(window, Nx[, fftbins, xp, device])

Gibt ein Fenster einer gegebenen Länge und eines gegebenen Typs zurück.

Gipfelfindung

argrelmin(data[, axis, order, mode])	Berechnet die relativen Minima von data.
argrelmax(data[, axis, order, mode])	Berechnet die relativen Maxima von data.
argrelextrema(data, comparator[, axis, ...])	Berechnet die relativen Extrema von data.
find_peaks(x[, height, threshold, distance, ...])	Findet Spitzen in einem Signal basierend auf Gipfeleigenschaften.
find_peaks_cwt(vector, widths[, wavelet, ...])	Findet Spitzen in einem 1D-Array mit Wellentransformation.
peak_prominences(x, peaks[, wlen])	Berechnet die Prominenz jedes Gipfels in einem Signal.
peak_widths(x, peaks[, rel_height, ...])	Berechnet die Breite jedes Gipfels in einem Signal.

Spektralanalyse

periodogram(x[, fs, window, nfft, detrend, ...])	Schätzt die Leistungsdichtespektrum mittels eines Periodogramms.
welch(x[, fs, window, nperseg, noverlap, ...])	Schätzt die Leistungsdichtespektrum nach der Welch-Methode.
csd(x, y[, fs, window, nperseg, noverlap, ...])	Schätzt das Kreuzleistungsdichtespektrum, Pxy, mittels der Welch-Methode.
coherence(x, y[, fs, window, nperseg, ...])	Schätzt das Betragsquadrat des Kohärenzschätzers, Cxy, von diskreten Zeitsignalen X und Y mittels der Welch-Methode.
spectrogram(x[, fs, window, nperseg, ...])	Berechnet ein Spektrogramm mit aufeinanderfolgenden Fourier-Transformationen (veraltete Funktion).
lombscargle(x, y, freqs[, precenter, ...])	Berechnet das verallgemeinerte Lomb-Scargle-Periodogramm.
vectorstrength(events, period)	Bestimmt die Vektusstärke der Ereignisse für den gegebenen Zeitraum.
ShortTimeFFT(win, hop, fs, *[, fft_mode, ...])	Bietet eine parametrisierte diskrete Kurzzeit-Fourier-Transformation (stft) und ihre Umkehrung (istft).
closest_STFT_dual_window(win, hop[, ...])	Berechnet das STFT-Dualfenster eines gegebenen Fensters, das einem gewünschten Dualfenster am nächsten kommt.
stft(x[, fs, window, nperseg, noverlap, ...])	Berechnet die Kurzzeit-Fourier-Transformation (veraltete Funktion).
istft(Zxx[, fs, window, nperseg, noverlap, ...])	Führt die inverse Kurzzeit-Fourier-Transformation durch (veraltete Funktion).
check_COLA(window, nperseg, noverlap[, tol])	Prüft, ob die Bedingung Constant OverLap Add (COLA) erfüllt ist (veraltete Funktion).
check_NOLA(window, nperseg, noverlap[, tol])	Prüft, ob die Bedingung Nonzero Overlap Add (NOLA) erfüllt ist.

Chirp Z-Transformation und Zoom-FFT

czt(x[, m, w, a, axis])	Berechnet die Frequenzantwort um eine Spirale in der Z-Ebene.
zoom_fft(x, fn[, m, fs, endpoint, axis])	Berechnet die DFT von x nur für Frequenzen im Bereich fn.
CZT(n[, m, w, a])	Erstellt eine aufrufbare Chirp-Z-Transformationsfunktion.
ZoomFFT(n, fn[, m, fs, endpoint])	Erstellt eine aufrufbare Zoom-FFT-Transformationsfunktion.
czt_points(m[, w, a])	Gibt die Punkte zurück, an denen die Chirp-Z-Transformation berechnet wird.

Die Funktionen sind einfacher zu verwenden als die Klassen, aber weniger effizient, wenn dieselbe Transformation auf viele Arrays gleicher Länge angewendet wird, da sie bei jedem Aufruf wiederholt dasselbe Chirp-Signal erzeugen. Verwenden Sie in diesen Fällen die Klassen, um eine wiederverwendbare Funktion zu erstellen.