Episode 1: Standard Filtering

Learn how to clean and shape your EEG data with standard filtering nodes. This episode demonstrates the use of high-, low-, band-, and notch filters to remove drifts, noise, and power-line interference or to isolate specific frequency bands.

Read

g.Pype offers four standard filters commonly used in EEG processing pipelines: Highpass, Lowpass, Bandstop (notch), and Bandpass. Below, we demonstrate how to use each of them in to serve typical use cases. These filters are implemented as second-order Butterworth IIR filters.

Highpass

The Highpass filter attenuates frequencies below a chosen cutoff, allowing higher-frequency activity to pass while removing slow drifts and trends. In EEG processing, highpass filtering is used to suppress slow baseline shifts and focus on faster brain activity. Start with the script below, where the Generator illustrates this behavior by producing a slow pseudo-drift at 0.05 Hz overlaid with white noise simulating EEG activity.

import gpype as gp

if __name__ == "__main__":

    app = gp.MainApp()
    p = gp.Pipeline()

    source = gp.Generator(signal_frequency=0.05,
                          signal_amplitude=75,
                          noise_amplitude=15)

    scope = gp.TimeSeriesScope()

    p.connect(source, scope)

    app.add_widget(scope)

    p.start()
    app.run()  # blocking until window is closed
    p.stop()

Run the script and observe the slow drift in the signal.

Figure 13: Slow drift example.

To remove the drift while preserving higher-frequency EEG, add a Highpass filter highpass with cutoff frequency f_c=1 Hz between the Generator and TimeSeriesScope:

    source = gp.Generator(signal_frequency=0.05,
                          signal_amplitude=75,
                          noise_amplitude=15)

    highpass = gp.Highpass(f_c=1)

    scope = gp.TimeSeriesScope()

    p.connect(source, highpass)
    p.connect(highpass, scope)

    app.add_widget(scope)

Run the script again and confirm the slow drift is gone, while the higher frequencies remain.

Figure 14: Slow drift removed via highpass filtering.

Lowpass

The Lowpass filter attenuates frequencies above a chosen cutoff, allowing lower-frequency components to pass while attenuating higher-frequency components. In EEG processing, lowpass filters are commonly applied to suppress high-frequency measurement noise and focus on slower brain rhythms. Use the script below to demonstrate this scenario. Here, the Generator produces a 4 Hz sinusoid mimicking Theta activity, embedded in white measurement noise.

import gpype as gp

if __name__ == "__main__":

    app = gp.MainApp()
    p = gp.Pipeline()

    source = gp.Generator(signal_frequency=4,
                          signal_amplitude=25,
                          noise_amplitude=25)

    scope = gp.TimeSeriesScope()

    p.connect(source, scope)

    app.add_widget(scope)

    p.start()
    app.run()  # blocking until window is closed
    p.stop()

Run the script and observe the noisy signal.

Figure 15: Slow waves embedded in measurement noise.

To suppress the noise while preserving the low-frequency sinusoid, add a Lowpass filter lowpass with cutoff frequency f_c=6 Hz between the Generator and TimeSeriesScope:

    source = gp.Generator(signal_frequency=4,
                          signal_amplitude=25,
                          noise_amplitude=25)

    lowpass = gp.Lowpass(f_c=6)

    scope = gp.TimeSeriesScope()

    p.connect(source, lowpass)
    p.connect(lowpass, scope)

    app.add_widget(scope)

Run the script again and confirm the noise is substantially reduced, with the low-frequency component intact.

Figure 16: Measurement noise eliminated via lowpass filtering.

Bandpass

The Bandpass filter attenuates frequencies outside a selected range, allowing only signals within that band to pass. In EEG processing, bandpass filters are commonly used remove both slow drifts and high-frequency noise from EEG data simultaneously, saving the need for separate highpass and lowpass filters. As well, bandpass filters are typically employed to to isolate specific brain rhythms, such as the alpha band (8-12 Hz), for focused analysis. The script below demonstrates such a typical use case, where the Generator produces a composite signal resembling 10 Hz alpha activity embedded in measurement noise.

import gpype as gp

if __name__ == "__main__":

    app = gp.MainApp()
    p = gp.Pipeline()

    source = gp.Generator(signal_frequency=10,
                          signal_amplitude=25,
                          noise_amplitude=25)

    scope = gp.TimeSeriesScope()

    p.connect(source, scope)

    app.add_widget(scope)

    p.start()
    app.run()  # blocking until window is closed
    p.stop()

Run the script and observe the noisy signal.

Figure 17: Alpha wave embedded in measurementnoise.

To isolate the alpha component, insert a Bandpass filter bandpass with lower cutoff frequency f_lo=8 Hz and upper cutoff frequency f_hi=12 Hz between the Generator and TimeSeriesScope:

    source = gp.Generator(signal_frequency=10,
                          signal_amplitude=25,
                          noise_amplitude=25)

    bandpass = gp.Bandpass(f_lo=8, f_hi=12)

    scope = gp.TimeSeriesScope()

    p.connect(source, bandpass)
    p.connect(bandpass, scope)

    app.add_widget(scope)

Run the script and observe that only the alpha band remains visible in the output.

Figure 18: Alpha wave isolated via bandpass filtering.

Bandstop (Notch)

The Bandstop (notch) filter attenuates a specific frequency band while leaving other frequencies unaffected. In EEG processing, bandstop filtering is essential for eliminating power-line interference from recordings. In the script below, the Generator illustrated this condition, producing a 50 Hz sinusoid combined with white noise to simulate EEG data contaminated by power-line interference.

import gpype as gp

if __name__ == "__main__":

    app = gp.MainApp()
    p = gp.Pipeline()

    source = gp.Generator(signal_frequency=50,
                          signal_amplitude=75,
                          noise_amplitude=15)

    scope = gp.TimeSeriesScope()

    p.connect(source, scope)

    app.add_widget(scope)

    p.start()
    app.run()  # blocking until window is closed
    p.stop()

Run the script and observe the power-line interference in the signal.

Figure 19: Example signal with power-line interference.

To suppress power-line interference, insert a Bandstop filter with f_low = 48 Hz and f_high = 52 Hz between the Generator and TimeSeriesScope:

    source = gp.Generator(signal_frequency=50,
                          signal_amplitude=75,
                          noise_amplitude=15)

    bandstop = gp.Bandstop(f_lo=48, f_hi=52)

    scope = gp.TimeSeriesScope()

    p.connect(source, bandstop)
    p.connect(bandstop, scope)

    app.add_widget(scope)

Run the script and confirm that the power-line frequency is removed from the signal.

Figure 20: Power-line interference removed via bandstop filtering.

Completed! You can now employ typical filters to serve standard purposes in EEG processing in g.Pype.

Summary

In this episode, you learned how to employ standard filters, such as

• Highpass to remove slow drifts

• Lowpass to attenuate high-frequency noise

• Bandpass to isolate specific frequency bands

• Bandstop (notch) to eliminate power line interference

Note that there is also a MovingAverage filter available, which we will cover specifically in an upcoming episode.

You are now ready to proceed to episode 2, where we will begin with signal routing in g.Pype.

Code

File s2e1_highpass.py – View file on GitHub

# --------------------------------------------------------------
# Example file s2e1_a_highpass.py
# For details and usage, see g.Pype Training Season 2, Episode 1
# --------------------------------------------------------------

import gpype as gp

if __name__ == "__main__":

    # Create main app and pipeline
    app = gp.MainApp()
    p = gp.Pipeline()

    # Create signal source
    source = gp.Generator(signal_frequency=0.05,
                          signal_amplitude=75,
                          noise_amplitude=15)

    # Create highpass filter
    highpass = gp.Highpass(f_c=1)

    # Create scope
    scope = gp.TimeSeriesScope()

    # Connect nodes
    p.connect(source, highpass)
    p.connect(highpass, scope)

    # Add widget to main app
    app.add_widget(scope)

    # Start pipeline and run application
    p.start()
    app.run()  # blocking until window is closed
    p.stop()

File s2e1_lowpass.py – View file on GitHub

# --------------------------------------------------------------
# Example file s2e1_b_lowpass.py
# For details and usage, see g.Pype Training Season 2, Episode 1
# --------------------------------------------------------------

import gpype as gp

if __name__ == "__main__":

    # Create main app and pipeline
    app = gp.MainApp()
    p = gp.Pipeline()

    # Create signal source
    source = gp.Generator(signal_frequency=4,
                          signal_amplitude=25,
                          noise_amplitude=25)

    # Create lowpass filter
    lowpass = gp.Lowpass(f_c=6)

    # Create scope
    scope = gp.TimeSeriesScope()

    # Connect nodes
    p.connect(source, lowpass)
    p.connect(lowpass, scope)

    # Add widget to main app
    app.add_widget(scope)

    # Start pipeline and run application
    p.start()
    app.run()  # blocking until window is closed
    p.stop()

File s2e1_bandpass.py – View file on GitHub

# --------------------------------------------------------------
# Example file s2e1_c_bandpass.py
# For details and usage, see g.Pype Training Season 2, Episode 1
# --------------------------------------------------------------

import gpype as gp

if __name__ == "__main__":

    # Create main app and pipeline
    app = gp.MainApp()
    p = gp.Pipeline()

    # Create signal source
    source = gp.Generator(signal_frequency=10,
                          signal_amplitude=25,
                          noise_amplitude=25)

    # Create bandpass filter
    bandpass = gp.Bandpass(f_lo=8, f_hi=12)

    # Create scope
    scope = gp.TimeSeriesScope()

    # Connect nodes
    p.connect(source, bandpass)
    p.connect(bandpass, scope)

    # Add widget to main app
    app.add_widget(scope)

    # Start pipeline and run application
    p.start()
    app.run()  # blocking until window is closed
    p.stop()

File s2e1_bandstop.py – View file on GitHub

# --------------------------------------------------------------
# Example file s2e1_d_bandstop.py
# For details and usage, see g.Pype Training Season 2, Episode 1
# --------------------------------------------------------------

import gpype as gp

if __name__ == "__main__":

    # Create main app and pipeline
    app = gp.MainApp()
    p = gp.Pipeline()

    # Create signal source
    source = gp.Generator(signal_frequency=50,
                          signal_amplitude=75,
                          noise_amplitude=15)

    # Create bandstop filter
    bandstop = gp.Bandstop(f_lo=48, f_hi=52)

    # Create scope
    scope = gp.TimeSeriesScope()

    # Connect nodes
    p.connect(source, bandstop)
    p.connect(bandstop, scope)

    # Add widget to main app
    app.add_widget(scope)

    # Start pipeline and run application
    p.start()
    app.run()  # blocking until window is closed
    p.stop()