Natuurlijk! Hier is een overzicht en voorbeeldcode om een banddoorlaatfilter en ruisonderdrukking toe te passen op een ECG-signaal met behulp van NumPy en SciPy. Deze implementaties zijn gericht op efficiëntie en numerieke stabiliteit. Voorbereiding: - Zorg dat je gegevens hebt als een NumPy-array van 10.000 datapunten. - Installeer indien nodig SciPy voor filterfuncties (`pip install scipy`). 1. Banddoorlaatfilter Gebruik een Butterworth-filter via `scipy.signal.butter` en `scipy.signal.filtfilt` voor zero-phase filtering. ```python import numpy as np from scipy.signal import butter, filtfilt def banddoorlaatfilter(data, fs, laag_freq, hoog_freq, orde=4): """ Pas een banddoorlaatfilter toe op een signaal. Parameters: - data: numpy array, het ECG-signaal - fs: samplingfrequentie in Hz - laag_freq: ondergrens van de band in Hz - hoog_freq: bovengrens van de band in Hz - orde: orde van de Butterworth-filter Returns: - gefilterd_signaal: numpy array, het gefilterde signaal """ nyq = 0.5 * fs laag = laag_freq / nyq hoog = hoog_freq / nyq b, a = butter(orde, [laag, hoog], btype='band') gefilterd_signaal = filtfilt(b, a, data) return gefilterd_signaal ``` 2. Ruisonderdrukking via median filtering Een eenvoudige methode voor ruisonderdrukking is median filtering, die impulsruis vermindert zonder veel details te verliezen. ```python from scipy.signal import medfilt def ruisonderdrukking_median(data, kernel_size=5): """ Voert median filtering uit voor ruisonderdrukking. Parameters: - data: numpy array, het ECG-signaal - kernel_size: grootte van de kernel (bij voorkeur oneven) Returns: - ruisvrij_signaal: numpy array """ return medfilt(data, kernel_size=kernel_size) ``` Alternatief: gebruik een low-pass filter (bijvoorbeeld een tweede-orde Butterworth) voor het gladstrijken. ```python def lowpass_filter(data, fs, cutoff_freq, orde=4): nyq = 0.5 * fs cutoff = cutoff_freq / nyq b, a = butter(orde, cutoff, btype='low') return filtfilt(b, a, data) ``` 3. Voorbeeldgebruik: Stel dat je ECG-data in een array `ecg_data` hebt en de samplingfrequentie `fs=1000 Hz`. ```python # Parameters fs = 1000 # Hz laag_freq = 0.5 # Hz, ondergrens ECG (bijv. baseline drift) hoog_freq = 40 # Hz, bovengrens ECG voor hartslag en ruis kernel_size = 5 # Banddoorlaatfilter ecg_band_filtered = banddoorlaatfilter(ecg_data, fs, laag_freq, hoog_freq) # Ruisonderdrukking ecg_door_median = ruisonderdrukking_median(ecg_band_filtered, kernel_size) # Alternatief: low-pass filter ecg_lowpassed = lowpass_filter(ecg_band_filtered, fs, 40) ``` Deze methoden zorgen voor een efficiënte en stabiele signaalverwerking. Pas de parameters aan op basis van je specifieke dataset en filterbehoeften.

Absoluut. Hieronder vindt u efficiënte en numeriek stabiele implementaties voor een banddoorlaatfilter en een ruisonderdrukkingsalgoritme voor uw ECG-signaal, geschreven in het Nederlands met behulp van NumPy en SciPy. ### 1. Banddoorlaatfilter (Butterworth-filter) Een banddoorlaatfilter is essentieel voor ECG-verwerking om de basislijndrift (lage frequentie) en hoogfrequente ruis (bv. spierartefacten) te verwijderen. Een typische band voor ECG is **0.5 Hz tot 40 Hz**. ```python import numpy as np from scipy.signal import butter, filtfilt def ontwerp_banddoorlaatfilter(laag, hoog, sample_freq, orde=4): """ Ontwerpt een Butterworth banddoorlaatfilter. Parameters: laag (float): Onderste kantelfrequentie (Hz). hoog (float): Bovenste kantelfrequentie (Hz). sample_freq (float): Samplefrequentie van het signaal (Hz). orde (int): Orde van het filter. Returns: tuple: (b, a) filtercoëfficiënten. """ nyquist_freq = 0.5 * sample_freq laag_norm = laag / nyquist_freq hoog_norm = hoog / nyquist_freq b, a = butter(orde, [laag_norm, hoog_norm], btype='band') return b, a def pas_banddoorlaatfilter_toe(data, sample_freq, laag=0.5, hoog=40.0): """ Past een nul-fase banddoorlaatfilter toe op de data met behulp van forwards-backwards filtering (filtfilt). Dit elimineert fasevervorming. Parameters: data (np.array): Het invoersignaal (bv. uw 10.000 punten ECG). sample_freq (float): Samplefrequentie (Hz). laag (float): Onderste kantelfrequentie (Hz). hoog (float): Bovenste kantelfrequentie (Hz). Returns: np.array: Het gefilterde signaal. """ b, a = ontwerp_banddoorlaatfilter(laag, hoog, sample_freq) gefilterd_signaal = filtfilt(b, a, data) return gefilterd_signaal # --- GEBRUIKSAANWIJZING --- # sample_freq = 500 # Vervang dit door uw werkelijke samplefrequentie # ecg_ruisvrij = pas_banddoorlaatfilter_toe(uw_ecg_data, sample_freq) ``` ### 2. Ruisonderdrukking (Gebaseerd op Wavelet-denoising) Wavelet-denoising is uitstekend geschikt voor niet-stationaire signalen zoals ECG's. Het verwijdert ruis effectief terwijl scherpe pieken (R-peken) behouden blijven. ```python import numpy as np import pywt def verwijder_ruis_wavelet(data, wavelet='db4', niveau=3): """ Verwijder ruis uit een signaal met behulp van wavelet-denoising (drempelwaarden). Parameters: data (np.array): Het ruizige invoersignaal. wavelet (str): Type wavelet om te gebruiken (e.g., 'db4', 'sym6'). niveau (int): Decompositieniveau voor de wavelet transformatie. Returns: np.array: Het signaal met onderdrukte ruis. """ # Voer de Wavelet Transform uit coeffs = pywt.wavedec(data, wavelet, level=niveau) # Schat de ruis (sigma) met behulp van de median absolute deviation (MAD) op de fijnste detailcoëfficiënten # Dit is een robuustere schatter dan de standaarddeviatie voor dit doel. sigma = np.median(np.abs(coeffs[-1])) / 0.6745 drempel = sigma * np.sqrt(2 * np.log(len(data))) # Universele drempel # Pas drempelwaardentoepassing toe op alle detailcoëfficiënten nieuwe_coeffs = list(coeffs) for i in range(1, len(nieuwe_coeffs)): nieuwe_coeffs[i] = pywt.threshold(nieuwe_coeffs[i], drempel, mode='soft') # Reconstructie van het signaal met de gedenoisede coëfficiënten gereconstrueerd_signaal = pywt.waverec(nieuwe_coeffs, wavelet) # Waverec kan soms 1-2 samples langer teruggeven door padding. Trim naar originele lengte. return gereconstrueerd_signaal[:len(data)] # --- GEBRUIKSAANWIJZING --- # ecg_ultra_rustig = verwijder_ruis_wavelet(uw_ecg_data) ``` ### Geïntegreerde Verwerkingspijplijn Voor het beste resultaat past u eerst het banddoorlaatfilter toe en daarna de wavelet-denoising. ```python # Veronderstelde parameters (PAS DIT AAN OP BASIS VAN UW DATA) sample_freq = 500 # Voorbeeld: 500 Hz samplefrequentie # Stap 1: Verwijder grote delen ruis met het banddoorlaatfilter ecg_gefiltreerd = pas_banddoorlaatfilter_toe(uw_ecg_data, sample_freq, laag=0.5, hoog=40.0) # Stap 2: Verfijn het resultaat en verwijder resterende ruis ecg_finaal = verwijder_ruis_wavelet(ecg_gefiltreerd, wavelet='db4', niveau=4) # Plot de resultaten (gebruik matplotlib) import matplotlib.pyplot as plt plt.figure(figsize=(12, 8)) plt.subplot(3, 1, 1) plt.plot(uw_ecg_data) plt.title("Origineel Rizig ECG Signaal") plt.subplot(3, 1, 2) plt.plot(ecg_gefiltreerd) plt.title("Na Banddoorlaatfilter (0.5 - 40 Hz)") plt.subplot(3, 1, 3) plt.plot(ecg_finaal) plt.title("Na Wavelet Ruisonderdrukking (Finaal Resultaat)") plt.tight_layout() plt.show() ``` ### Belangrijke Opmerkingen: 1. **Samplefrequentie (`sample_freq`)**: Dit is de meest cruciale parameter. U **moet** de werkelijke samplefrequentie van uw ECG-signaal weten en invoeren. Als u deze niet weet, kunt u deze niet correct filteren. 2. **Filterorden**: Een hogere filterorde (bv., 6) geeft een steilere kantel, maar kan numerieke instabiliteit introduceren. De keuze voor orde 4 is een goede balans. `filtfilt` compenseert hiervoor grotendeels door de fasevervorming ongedaan te maken. 3. **Wavelet-parameters**: Experimenteer met verschillende wavelets (`'sym6'`, `'coif3'`) en niveaus (`niveau=4` of `5`). Hogere niveaus verwijderen meer ruis maar riskeren het vervagen van echte signaalkenmerken. 4. **Stabiliteit**: Het gebruik van `scipy.signal.filtfilt` (dubbel filteren) zorgt voor een nul-fase respons, wat essentieel is om de timing van ECG-pieken niet te verschuiven. De wavelet-transformatie is van nature numeriek stabiel. Deze aanpak biedt een professionele basis voor de verwerking van uw ECG-signaal.