scipy.signal.

upfirdn#

scipy.signal.upfirdn(h, x, up=1, down=1, axis=-1, mode='constant', cval=0)[Quelle]#

Hochtasten, FIR-filtern und runtertasten.

Parameter:

harray_like: 1-D FIR (Finite Impulse Response) Filterkoeffizienten.
xarray_like: Eingangssignal-Array.
upint, optional: Hochtastrate. Standardwert ist 1.
downint, optional: Runtertastrate. Standardwert ist 1.
axisint, optional: Die Achse des Eingabedatenarrays, entlang der der lineare Filter angewendet werden soll. Der Filter wird auf jeden Unterarray entlang dieser Achse angewendet. Standard ist -1.
modestr, optional: Der zu verwendende Modus für die Signalerweiterung. Die Mengen {"constant", "symmetric", "reflect", "edge", "wrap"} entsprechen den von numpy.pad bereitgestellten Modi. "smooth" implementiert eine glatte Erweiterung, indem sie basierend auf der Steigung der letzten 2 Punkte an jedem Ende des Arrays erweitert wird. "antireflect" und "antisymmetric" sind antisymmetrische Versionen von "reflect" und "symmetric". Der Modus „line“ erweitert das Signal basierend auf einem linearen Trend, der durch den ersten und letzten Punkt entlang der axis definiert ist.

Hinzugefügt in Version 1.4.0.
cvalfloat, optional: Der konstante Wert, der verwendet wird, wenn mode == "constant".

Hinzugefügt in Version 1.4.0.

Rückgabe:

yndarray: Das Ausgangssignal-Array. Die Dimensionen sind dieselben wie bei x, außer entlang der axis, deren Größe gemäß den Parametern h, up und down geändert wird.

Hinweise

Der Algorithmus ist eine Implementierung des Blockdiagramms auf Seite 129 des Vaidyanathan-Lehrbuchs [1] (Abbildung 4.3-8d).

Der direkte Ansatz des Hochtastens um den Faktor P mit Nulleinfügung, FIR-Filtern der Länge N und Runtertasten um den Faktor Q kostet O(N*Q) pro Ausgangssample. Die hier verwendete Polyphasenimplementierung kostet O(N/P).

Hinzugefügt in Version 0.18.

Referenzen

[1]

P. P. Vaidyanathan, Multirate Systems and Filter Banks, Prentice Hall, 1993.

Beispiele

Einfache Operationen

>>> import numpy as np
>>> from scipy.signal import upfirdn
>>> upfirdn([1, 1, 1], [1, 1, 1])   # FIR filter
array([ 1.,  2.,  3.,  2.,  1.])
>>> upfirdn([1], [1, 2, 3], 3)  # upsampling with zeros insertion
array([ 1.,  0.,  0.,  2.,  0.,  0.,  3.])
>>> upfirdn([1, 1, 1], [1, 2, 3], 3)  # upsampling with sample-and-hold
array([ 1.,  1.,  1.,  2.,  2.,  2.,  3.,  3.,  3.])
>>> upfirdn([.5, 1, .5], [1, 1, 1], 2)  # linear interpolation
array([ 0.5,  1. ,  1. ,  1. ,  1. ,  1. ,  0.5])
>>> upfirdn([1], np.arange(10), 1, 3)  # decimation by 3
array([ 0.,  3.,  6.,  9.])
>>> upfirdn([.5, 1, .5], np.arange(10), 2, 3)  # linear interp, rate 2/3
array([ 0. ,  1. ,  2.5,  4. ,  5.5,  7. ,  8.5])

Einen einzelnen Filter auf mehrere Signale anwenden

>>> x = np.reshape(np.arange(8), (4, 2))
>>> x
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7]])

Entlang der letzten Dimension von x anwenden

>>> h = [1, 1]
>>> upfirdn(h, x, 2)
array([[ 0.,  0.,  1.,  1.],
       [ 2.,  2.,  3.,  3.],
       [ 4.,  4.,  5.,  5.],
       [ 6.,  6.,  7.,  7.]])

Entlang der 0-Dimension von x anwenden

>>> upfirdn(h, x, 2, axis=0)
array([[ 0.,  1.],
       [ 0.,  1.],
       [ 2.,  3.],
       [ 2.,  3.],
       [ 4.,  5.],
       [ 4.,  5.],
       [ 6.,  7.],
       [ 6.,  7.]])