6. Filter#

Filter sind spezielle Systeme, die in diesem Abschnitt grundsätzlich als LTI-Systeme angenommen werden (es gibt auch nicht LTI-Filter wie z.B. das Median Filter, diese sind aber nicht-linear). Die Aufgabe von Filtern ist typischerweise bestimmte Frequenzanteile aus dem Signal verändern, also zu verstärken, abzuschwächen oder ganz zu entfernen.

Alle nicht-trivialen LTI-Systeme erzeugen eine Filterwirkung, trotzdem werden nicht alle LTI-Systeme als Filter bezeichnet, wenn das Ziel beim Entwurf nicht die Filterwirkung sondern irgendeine andere Eigenschaft ist. Ein Beipiel sei die Berechnung des gleitenden Mittelwertes eines Signals. Eine solches System ist automatisch auch ein Filter, wird aber trotzdem nicht unbedingt als solches bezeichnet. In vielen Fällen ist die Filterwirkung sogar ein unerwünschter Nebeneffekt.

Ziel dieses Abschnittes ist es, die Grundtypen von Filtern kennen zu lernen. Diese können als nicht-rekursive und rekursive Implementierungen vorliegen. Abschließend werden in einer sehr kompakten Form einige bekannte Entwurfsverfahren für die beiden Realisierungsformen vorgestellt.

6.1. Filtertypen#

Bei der Typisierung von Filtern schauen wir uns zunächst die sogenannten Sperrfilter an. Ihr Entwurfsziel ist, möglichst einen bestimmten Frequenzbereich vollständig aus dem Spektrum zu entfernen. Dabei wird zwischen vier Grundtypen unterschieden:

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
import scipy
from scipy import signal
from matplotlib import pyplot

# Script to create an ideal and realistic lowpass

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

Fs = 8000
fg = 1000 # cutoff frequency
order = 6
x = [0.0]*Fs
x[0] = 1.0
b, a = scipy.signal.butter(N=order, Wn=fg, btype='low', output='ba', fs=Fs)
y = scipy.signal.lfilter(b, a, x)
spectrum = numpy.fft.fft(y)

# dB, max amplitude = 0dB
spectrum_abs = 20*numpy.log10(numpy.abs(spectrum)/numpy.abs(spectrum).max()) 
freq_vec = numpy.linspace(0, Fs, len(spectrum_abs)) # freq bins, for plotting

fig, ax_spectrum = pyplot.subplots()

# ideal frequency respose of filter
ax_spectrum.step(y=[0, 0, -100, - 100, 0], x=[0, fg, Fs/2, Fs-fg, Fs], 
        color='r', label="Optimale Entwurfsvorgabe")
# actual realization
ax_spectrum.plot(freq_vec, spectrum_abs, color='b', 
        label="Mögliche Realisierung")

ax_spectrum.set(xlabel='Frequenz in Hz ', ylabel='Dämpfung in dB', 
        xlim=[0, Fs/2], ylim=[-105, 5], title=f'Tiefpass {order}.Odnung')
pyplot.legend()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("DesignTP", fig, display=False)

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
import scipy
from scipy import signal
from matplotlib import pyplot

# Script to create an ideal and realistic highpass

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

Fs = 8000
fg = 1000 # cutoff frequency
order = 6
x = [0.0]*Fs
x[0] = 1.0
b, a = scipy.signal.butter(N=order, Wn=fg, btype='high', output='ba', fs=Fs)
y = scipy.signal.lfilter(b, a, x)
spectrum = numpy.fft.fft(y)

# dB, max amplitude = 0dB
spectrum_abs = 20*numpy.log10(numpy.abs(spectrum)/numpy.abs(spectrum).max()) 
freq_vec = numpy.linspace(0, Fs, len(spectrum_abs)) # freq bins, for plotting

fig, ax_spectrum = pyplot.subplots()

# ideal frequency respose of filter
ax_spectrum.step(y=[-100, -100, 0, 0, -100], x=[0, fg, Fs/2, Fs-fg, Fs], 
        color='r', label="Optimale Entwurfsvorgabe")
# actual realization
ax_spectrum.plot(freq_vec, spectrum_abs, 
        color='b', label="Mögliche Realisierung")

ax_spectrum.set(xlabel='Frequenz in Hz ', ylabel='Dämpfung in dB', 
        xlim=[0, Fs/2], ylim=[-105, 5], title=f'Hochpass {order}.Odnung')
pyplot.legend()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("DesignHP", fig, display=False)

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
import scipy
from scipy import signal
from matplotlib import pyplot

# Script to create an ideal and realistic bandpass

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

Fs = 8000
fg = [1000, 3000]# cutoff frequency
order = 6
x = [0.0]*Fs
x[0] = 1.0
b,a = scipy.signal.butter(N=order, Wn=fg, btype='bandpass', output='ba', fs=Fs)
y = scipy.signal.lfilter(b, a, x)
spectrum = numpy.fft.fft(y)
# dB, max amplitude = 0dB
spectrum_abs = 20*numpy.log10(numpy.abs(spectrum)/numpy.abs(spectrum).max()) 
freq_vec = numpy.linspace(0, Fs, len(spectrum_abs)) # freq bins, for plotting

fig, ax_spectrum = pyplot.subplots()

# ideal frequency respose of filter
ax_spectrum.step(y=[-100, -100, 0, -100, -100, 0, -100], 
        x=[0, fg[0], fg[1], Fs/2, Fs-fg[1], Fs-fg[0], Fs], 
        color='r', label="Optimale Entwurfsvorgabe")
# actual realization
ax_spectrum.plot(freq_vec, spectrum_abs, 
        color='b', label="Mögliche Realisierung")
ax_spectrum.set(xlabel='Frequenz in Hz ', ylabel='Dämpfung in dB', 
        xlim=[0, Fs/2], ylim=[-105, 5], title=f'Bandpass {order}.Odnung')
pyplot.legend()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("DesignBP", fig, display=False)

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
import scipy
from scipy import signal
from matplotlib import pyplot

# Script to create an ideal and realistic bandstop

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

Fs = 8000
fg = [1000, 3000]# cutoff frequency
order = 6
x = [0.0]*Fs
x[0] = 1.0
b,a = scipy.signal.butter(N=order, Wn=fg, btype='bandstop', output='ba', fs=Fs)
y = scipy.signal.lfilter(b, a, x)
spectrum = numpy.fft.fft(y)
# dB, max amplitude = 0dB
spectrum_abs = 20*numpy.log10(numpy.abs(spectrum)/numpy.abs(spectrum).max()) 
freq_vec = numpy.linspace(0, Fs, len(spectrum_abs)) # freq bins, for plotting


fig, ax_spectrum = pyplot.subplots()

# ideal frequency respose of filter
ax_spectrum.step(y=[0, 0, -100, 0, 0, -100, 0], 
        x=[0, fg[0], fg[1], Fs/2, Fs-fg[1], Fs-fg[0], Fs], 
        color='r', label="Optimale Entwurfsvorgabe")
# actual realization
ax_spectrum.plot(freq_vec, spectrum_abs, 
        color='b', label="Mögliche Realisierung")

ax_spectrum.set(xlabel='Frequenz in Hz ', ylabel='Dämpfung in dB', 
        xlim=[0, Fs/2], ylim=[-105, 5], title=f'Bandsperre {order}.Odnung')
pyplot.legend()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("DesignBS", fig, display=False)

Tiefpass

Tiefpass: Ziel des Tiefpasses ist es alle hohen Frequenzen ab einer zu definierenden Grenzfrequenz \(f_\text{g}\) aus dem Spektrum zu entfernen. In der technischen Umsetzung ist es aber nicht möglich, einen abrupten Übergang zwischen dem sog. Durchlassbereich (tiefe Frequenzen beim Tiefpass) und dem Sperrbereich zu realisieren. Eine praktische Realisierung hat deshalb immer bestimmte Grenz- und Übergangsbereiche.

_images/filter_1_1.png — Fig. 6.1 Optimaler Entwurf eines Tiefpasses (\(f_\text{s}\) = 8 kHz und Grenzfrequenz = \(f_\text{g}\) = 1 kHz) und Realisierung durch Butterworth-Filter 6. Ordnung (siehe Abschnitt 6.2.5.1)#

Hochpass

Hochpass: Das inverse Designziel zum Tiefpass liegt dem Hochpassentwurf zu Grunde. Es sollen möglichst alle tiefen Frequenzen aus dem Spektrum entfernt werden. Auch hier gelten die beim Tiefpass erwähnten Einschränkungen.

_images/filter_2_1.png — Fig. 6.2 Optimaler Entwurf eines Hochpasses (\(f_\text{s}\) = 8 kHz und Grenzfrequenz = \(f_\text{g}\) = 1 kHz) und Realisierung durch Butterworth-Filter 6. Ordnung (siehe Abschnitt 6.2.5.1)#

Bandpass

Bandpass: Im Gegensatz zu den vorher erwähnten Typen hat das Bandpassfilter zwei Grenzfrequenzen \(f_1\) und \(f_2\). Das Designziel ist, nur die Frequenzen zwischen \(f_1\) und \(f_2\) durchzulassen und alle Frequenzen unterhalb von \(f_1\) bzw. oberhalb von \(f_2\) zu entfernen. Die Differenz zwischen \(f1\) und \(f_2\) wird Bandbreite \(B = f_2 - f_1\) genannt.

_images/filter_3_1.png — Fig. 6.3 Optimaler Entwurf eines Bandpasses (\(f_\text{s}\) = 8 kHz und Grenzfrequenz \(f_1\) = 1 kHz und \(f_2 =\) 3 kHz) und Realisierung durch Butterworth-Filter 6. Ordnung (siehe Abschnitt 6.2.5.1)#

Bandsperre

Bandsperre: Die Bandsperre stellt die inverse Funktion zum Bandpass dar. Bei diesem Entwurf sollen möglichst alle Frequenzen im Bereich zwischen \(f_1\) und \(f_2\) aus dem Spektrum entfernt werden.

_images/filter_4_1.png — Fig. 6.4 Optimaler Entwurf einer Bandsperre (\(f_\text{s}\) = 8 kHz und Grenzfrequenz \(f_1\) = 1 kHz und \(f_2 =\) 3 kHz) und Realisierung durch Butterworth-Filter 6. Ordnung (siehe Abschnitt 6.2.5.1)#

Eine weitere Gruppe von Filtern hat das Ziel, Signale die durch eine Übertragung verändert wurden, wieder in ihre ursprüngliche Form zurück zu bringen. Das Ziel ist also, ein verändertes Spektrum zu begradigen, bzw. auszugleichen. Aus dieser Aufgabe folgt auch die verwendete englische Typbezeichnung Equalizer. In der Tonstudiotechnik werden diese Filter zwar nicht nur zu diesem Zweck verwendet, aber auch dort werden die Klangformungsfilter als Equalizer bezeichnet. Equalizer ist ein sehr allgemeiner Begriff und kann Filter beinhalten, die eine vollständige Vorgabe der Übertragungsfunktion versuchen zu realisieren. Zum Beispiel bei der Hörgeräteanpassung, die eine vollständige Beschreibung des Hörverlustes als Ausgangsbasis verwendet. Oder aber es werden nur bestimmte Bereiche verändert. Zu dieser letzten Gruppe gehören die Equalizer, wie sie in der Tonstudiotechnik verwendet werden. Hierbei wird zwischen den parametrischen Equalizern und den sogenannten Terzband-Equalizern (eine (große) Terz beschreibt eine drittel Oktave, die wiederum eine Frequenzverdoppelung beschreibt) unterschieden.

Bei den parametrischen Equalizern können durch die drei Parameter

Frequenz,
Verstärkung bzw. Abschwächung und
Güte (\(Q\)-Faktor)

sehr genaue Eingriffe in das Klangspektrum vorgenommen werden. Dabei ist die Güte \(Q = \frac{f_\text{m}}{B}\) als Verhältnis von Mittenfrequenz \(f_\text{m}\) und Bandbreite \(B\) definiert.

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
from scipy import signal
from matplotlib import pyplot
from matplotlib.widgets import Slider

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

def get_peak_EQ(f_0, gain_dB, Q, f_s):
    '''
    calculates filter coefficients of a peak equalizer
    with the given parameters
    
    Parameters:
    -----------
    f_0 : int
        peak frequency in Hz
    gain_dB : int
        dB gain at peak
    Q : float
        Quality of filter
    f_s : int
        sampling frequency
    '''
    K = numpy.tan(2*numpy.pi*f_0/(f_s*2))
    a = [0]*3
    b = [0]*3
    den = 1
    if (gain_dB > 0):
        V0 = 10**(gain_dB/20)
        den = (1 + K/Q + K*K)
        b[0] = (1 + V0*K/Q + K*K)
        b[1] = 2 * (K*K - 1)
        b[2] = (1 - V0*K/Q + K*K)
        a[0] = 1
        a[1] = 2 * (K*K - 1)
        a[2] = (1 - K/Q + K*K)
    else:
        V0 = 10**(-gain_dB/20)
        den = (1 + V0*K/Q + K*K)
        b[0] = (1 + K/Q + K*K)
        b[1] = 2 * (K*K - 1)
        b[2] = (1 - K/Q + K*K)
        a[0] = 1
        a[1] = 2 * (K*K - 1)
        a[2] = (1 - V0*K/Q + K*K)
    
    b /= den
    a[1:] /= den
    
    return b, a
    

gains = [12, 6, 0, -6, -12]
fs = 48000
freq= 8000
Q = 3

fig, (ax_gain, ax_freq, ax_Q) = pyplot.subplots(3, 1)

for gain in gains:
    b, a = get_peak_EQ(freq, gain, Q, fs) # get filter coeefficients        
    w, h = signal.freqz(b, a, fs) # calculate impulse response
    h_db = 20*numpy.log10(numpy.abs(h)) # dB
    ax_gain.plot(w, h_db)

ax_gain.set(ylim=[-13, 13], xlabel='Frequenz in Hz', ylabel='Verstärkung in dB',     
        title=f'Peak-EQ mit variablem Gain \n\
        bei Frequenz f = {freq} Hz mit Güte Q = {Q:.1f}')

freqs = [0, fs/10, fs/5, fs/3]
gain = 12
for freq in freqs:
    b, a = get_peak_EQ(freq, gain, Q, fs) # get filter coeefficients
    w, h = signal.freqz(b, a, fs) # calculate impulse response
    h_db = 20*numpy.log10(numpy.abs(h)) # dB
    ax_freq.plot(w, h_db)
ax_freq.set(ylim=[-13, 13], xlabel='Frequenz in Hz', ylabel='Verstärkung in dB', 
        title=f'Peak-EQ mit variabler Frequenz \n\
        bei Gain = {gain} dB und Güte Q = {Q:.1f}')
Qs = [0, 1, 3, 10]
freq = 8000

for Q in Qs:
    b, a = get_peak_EQ(freq, gain, Q, fs) # get filter coeefficients
    w, h = signal.freqz(b, a, fs) # calculate impulse response
    h_db = 20*numpy.log10(numpy.abs(h)) # dB
    ax_Q.plot(w, h_db)
ax_Q.set(ylim=[-13, 13], xlabel='Frequenz in Hz', ylabel='Verstärkung in dB', 
         title=f'Peak-EQ mit variabler Güte \n\
         bei Frequenz f = {freq} Hz und Gain = {gain} dB')

pyplot.tight_layout()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("EQ_GainParam", fig, display=False)

Buchabbildung

_images/filter_7_2.png — Fig. 6.5 Equalizerübertragungskurve bei Veränderung der Güte#

Interaktiv arbeiten

Starten des interaktiven Programms - Filter_Peak_EQ.py in jupyterbook/code/interactive_programs/
Mit Slidern Parameter einstellen

Es gibt auch noch spezielle Filter für den Hoch- und Tiefpassbereich, die als Kuhschwanzfilter (Shelving-Filter) bezeichnet werden. Hierbei stehen nur die zwei Parameter Frequenz und Verstärkung bzw. Abschwächung zur Verfügung.

# -*- coding: utf-8 -*-
#-------------------------------------------------------------------------------
# Demoscript for "Signalverarbeitung 1"
#
# Version: 1.0   18.02.2022
# 
# This software is released as public domain under CC0 1.0
# https://creativecommons.org/publicdomain/zero/1.0/
#-------------------------------------------------------------------------------

import matplotlib
import numpy
from scipy import signal
from matplotlib import pyplot
from matplotlib.widgets import RadioButtons
from matplotlib.widgets import Slider

# determine where we're running from and set paths accordingly
try: 
    if get_ipython().__class__.__name__ == 'ZMQInteractiveShell':
        prefix = ''
except:
    prefix = '../../'

matplotlib.style.use(f'{prefix}sv.mplstyle')

def getShelvingEQ(f_0, Gain_dB, shelf_type, fs):
    '''
    calculates filter coefficients of a shelving equalizer
    with the given parameters
    
    Parameters:
    -----------
    f_0 : int
        peak frequency in Hz
    gain_dB : int
        dB gain at peak
    shelf_type : str
        "high" for high-shelf, anything else for low shelf
    fs : int
        sampling frequency
    '''

    K = numpy.tan(2*numpy.pi*f_0/(fs*2))
    a = [0]*3
    b = [0]*3
    den = 1
    
    if (shelf_type == "high"): # High-Shelf
        if (Gain_dB > 0):
            V0 = 10**(Gain_dB/20)
            den = 1 + numpy.sqrt(2)*K + K*K
            b[0] = V0 + numpy.sqrt(2*V0)*K+K*K 
            b[1] = 2 * (K*K - V0) 
            b[2] = V0 - numpy.sqrt(2*V0)*K + K*K  
            a[0] = 1
            a[1] = 2 * (K*K - 1)            
            a[2] = 1 - numpy.sqrt(2)*K + K*K  
            b /= den
            a[1:] /= den
        else:
            V0 = 10**(-Gain_dB/20)
            den = V0 + numpy.sqrt(V0*2)*K + K*K
            b[0] = 1 + numpy.sqrt(2)*K + K*K 
            b[1] = 2 * (K*K - 1) 
            b[2] = 1 - numpy.sqrt(2)*K + K*K  
            b /= den
            den = 1 + numpy.sqrt(2/V0)*K + K*K/V0
            a[0] = 1
            a[1] = 2 * (K*K/V0 - 1) 
            a[2] = (1 - numpy.sqrt(2/V0)*K + K*K/V0)  
            a[1:] /= den
    else: #Low-Shelf 0 or default for != 1
        if (Gain_dB > 0):
            V0 = 10**(Gain_dB/20)
            den = 1 + numpy.sqrt(2)*K + K*K
            b[0] = 1 + numpy.sqrt(2*V0)*K + V0*K*K 
            b[1] = 2 * (V0*K*K - 1) 
            b[2] = 1 - numpy.sqrt(2*V0)*K + V0*K*K  
            a[0] = 1
            a[1] = 2 * (K*K - 1) 
            a[2] = 1 - numpy.sqrt(2)*K + K*K  
        else:
            V0 = 10**(-Gain_dB/20)
            den = 1 + numpy.sqrt(V0*2)*K + V0*K*K
            b[0] = 1 + numpy.sqrt(2)*K + K*K 
            b[1] = 2 * (K*K - 1) 
            b[2] = 1 - numpy.sqrt(2)*K + K*K  
            a[0] = 1
            a[1] = 2 * (V0*K*K - 1)
            a[2] = 1 - numpy.sqrt(V0*2)*K + V0*K*K
            
        b /= den
        a[1:] /= den

    return b, a

#parameters
gains = [12, 6, 0, -6, -12]
fs = 48000
f_c = 8000
shelf_types = ["low", "high"]

fig, (ax_gain, ax_freq) = pyplot.subplots(2, 1)

for gain in gains:
    for ftype in shelf_types:
        b, a = getShelvingEQ(f_c, gain, ftype, fs) # get filter coefficients
        print(b, a)
        w, h = signal.freqz(b, a, fs=fs) # calculate impulse response
        #with numpy.errstate(divide='ignore'):
        h_db = 20*numpy.log10(numpy.abs(h)) # dB
        ax_gain.plot(w, h_db)

ax_gain.set(ylim=[-13, 13], xlabel='Frequenz in Hz',ylabel='Verstärkung in dB', 
        title=f'Shelf-EQs variablem Gain \n bei Grenzfrequenz f = {f_c} Hz')

        

freqs = [0, fs/10, fs/5, fs/3]
gain = 12
for f_c in freqs:
    for ftype in shelf_types:
        b, a = getShelvingEQ(f_c, gain, ftype, fs) # get filter coefficients
        print(b, a)
        w, h = signal.freqz(b, a, fs = fs) # calculate impulse response
        with numpy.errstate(divide='ignore'):
            h_db = 20*numpy.log10(numpy.abs(h)) # dB
        ax_freq.plot(w, h_db)
ax_freq.set(ylim=[-13, 13], xlabel='Frequenz in Hz',ylabel='Verstärkung in dB', 
        title=f'Shelf-EQs mit variabler Grenzfrequenz \n bei Gain = {gain} dB')

pyplot.tight_layout()

pyplot.show()

# glue this figure to paste it later (no effect outside of MyST NB)
from myst_nb import glue
glue("EQ_ShelvParam", fig, display=False)

Buchabbildung

_images/filter_10_3.png — Fig. 6.6 Equalizerübertragungskurven eines Hoch bzw. Tiefpasskuhschwanzfilters bei Veränderung der Verstärkung und Frequenz#

Interaktiv arbeiten

Starten des interaktiven Programms - Filter_Shelving_EQ.py in jupyterbook/code/interactive_programs/
Mit Slidern Parameter einstellen

Im Gegensatz zu den vollparametrischen EQs sind bei einem Terzband-Equalizer die Frequenzen und Güten festgelegt. Der Nutzer hat nur einen Einfluss auf die Verstärkung oder Absenkung. Der Vorteil dieser Equalizer ist ihre einfache Bedienung und die Möglichkeit sofort zu sehen, welche Frequenzveränderungen vorgenommen werden. Die Mittenfrequenzen der Filter sind standardisiert:

import pandas

df_oktav = pandas.DataFrame(data = {
    'index':[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4], 
    'Frequenz (Hz)':[31.5, 63, 125, 250, 500, 1000, 2000, 4000, 8000, 16000]})
df_terz = pandas.DataFrame(data = {
    'index': [-16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, 
     -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13] ,
    'Frequenz (Hz)': [25,31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 
     315, 400, 500, 630, 800,1000,1250,1600,2000,2500,
     3150,4000,5000,6300,8000,10000,12500,16000,20000]})
df_oktav = df_oktav.set_index('index')
df_terz = df_terz.set_index('index')

glue("df_oktav", df_oktav, display=False)
glue("df_terz", df_terz, display=False)

Oktav-EQ

	Frequenz (Hz)
index
-5	31.5
-4	63.0
-3	125.0
-2	250.0
-1	500.0
0	1000.0
1	2000.0
2	4000.0
3	8000.0
4	16000.0

Terz-EQ

	Frequenz (Hz)
index
-16	25.0
-15	31.5
-14	40.0
-13	50.0
-12	63.0
-11	80.0
-10	100.0
-9	125.0
-8	160.0
-7	200.0
-6	250.0
-5	315.0
-4	400.0
-3	500.0
-2	630.0
-1	800.0
0	1000.0
1	1250.0
2	1600.0
3	2000.0
4	2500.0
5	3150.0
6	4000.0
7	5000.0
8	6300.0
9	8000.0
10	10000.0
11	12500.0
12	16000.0
13	20000.0

Für bestimmte Anwendungen (z.B. Synthesizer) werden auch manchmal Filter verwendet, die in ihrer Grundcharakteristik den Sperrfiltern entsprechen, aber zusätzlich in der Nähe der Grenzfrequenz eine Verstärkung einbringen. Diese Verstärkungsfrequenzen kommen bei natürlichen Musikinstrumenten ebenfalls häufig vor. Man spricht in diesem Fall von Resonanzfrequenzen, da bestimmte Signalanteile im Filter eine starke Resonanz finden.