Experiência 2: Processamento e Caracterização de Sinais

Experiência 2: Processamento e Caracterização de Sinais Biomédicos

Objetivo

Capacitar os estudantes na aplicação de técnicas de processamento digital de sinais (DSP) em dados fisiológicos reais. A experiência foca na extração de características relevantes, filtragem de ruído e implementação de algoritmos de detecção para sinais biomédicos, preparando os dados para análise clínica.

Objetivos de Aprendizagem

  • Aplicar técnicas fundamentais de processamento digital de sinais
  • Implementar filtros digitais para remoção de artefactos
  • Extrair características temporais e espectrais de sinais biomédicos
  • Desenvolver algoritmos de detecção de eventos fisiológicos
  • Validar a qualidade e precisão dos algoritmos implementados
  • Compreender limitações e trade-offs em DSP para aplicações médicas

Resultados de Aprendizagem

Ao completar esta experiência, os estudantes serão capazes de:

  • Filtrar eficazmente ruído de sinais ECG, PPG e outros biomédicos
  • Implementar algoritmos de detecção de picos R em ECG (Pan-Tompkins)
  • Calcular variabilidade da frequência cardíaca (HRV)
  • Extrair features do domínio tempo e frequência
  • Realizar análise espectral com FFT e espectrogramas
  • Avaliar qualidade de sinal através de métricas objetivas

Exercício Prático Detalhado

Fase 1: Pré-processamento e Filtragem (45 min)

Objetivos específicos:

  • Implementar filtros passa-banda para ECG (0.5-40 Hz)
  • Remover artefactos de movimento em sinais PPG
  • Aplicar técnicas de normalização e detrending

Tarefa prática:

import numpy as np
import scipy.signal as signal
import matplotlib.pyplot as plt
from scipy import stats

def preprocess_ecg(ecg_signal, fs=1000):
    """
    Pré-processamento completo de sinal ECG
    """
    # 1. Filtro passa-alta (0.5 Hz) - remove baseline wandering
    sos_high = signal.butter(4, 0.5, btype='high', fs=fs, output='sos')
    ecg_filtered = signal.sosfilt(sos_high, ecg_signal)

    # 2. Filtro passa-baixa (40 Hz) - remove ruído alta frequência
    sos_low = signal.butter(4, 40, btype='low', fs=fs, output='sos')
    ecg_filtered = signal.sosfilt(sos_low, ecg_filtered)

    # 3. Filtro notch (50 Hz) - remove interferência da rede elétrica
    sos_notch = signal.iirnotch(50, 30, fs)
    ecg_clean = signal.sosfilt(sos_notch, ecg_filtered)

    return ecg_clean

# Carregar dados da Experiência 1
ecg_data = load_sensor_data('esp32_ecg_data.json')
ecg_clean = preprocess_ecg(ecg_data['ecg'], fs=100)

Exercícios:

  1. Comparar espectro antes/depois da filtragem
  2. Implementar filtro adaptativo para remoção de artefactos
  3. Avaliar SNR (Signal-to-Noise Ratio) pré e pós-processamento

Fase 2: Detecção de Eventos Fisiológicos (60 min)

Algoritmo Pan-Tompkins para detecção QRS

Implementação do algoritmo clássico para detecção de complexos QRS em ECG:

def pan_tompkins_detector(ecg, fs=1000):
    """
    Implementação do algoritmo Pan-Tompkins para detecção QRS
    """
    # 1. Filtro passa-banda (5-15 Hz)
    sos = signal.butter(4, [5, 15], btype='band', fs=fs, output='sos')
    filtered = signal.sosfilt(sos, ecg)

    # 2. Diferenciação
    diff = np.diff(filtered)

    # 3. Elevação ao quadrado
    squared = diff ** 2

    # 4. Integração por janela móvel
    window_size = int(0.15 * fs)  # 150ms
    integrated = np.convolve(squared, np.ones(window_size)/window_size, mode='same')

    # 5. Detecção de picos adaptativos
    peaks, properties = signal.find_peaks(
        integrated,
        height=np.mean(integrated) * 0.3,
        distance=int(0.2 * fs)  # Mínimo 200ms entre picos
    )

    return peaks, integrated

def calculate_hrv_metrics(rr_intervals):
    """
    Calcula métricas de variabilidade da frequência cardíaca
    """
    rr_ms = rr_intervals * 1000  # Converter para ms

    metrics = {
        'mean_rr': np.mean(rr_ms),
        'sdnn': np.std(rr_ms),  # Desvio padrão dos intervalos RR
        'rmssd': np.sqrt(np.mean(np.diff(rr_ms) ** 2)),  # Root mean square of successive differences
        'pnn50': np.sum(np.abs(np.diff(rr_ms)) > 50) / len(rr_ms) * 100,  # % intervalos >50ms diferentes
        'heart_rate': 60000 / np.mean(rr_ms)  # BPM médio
    }

    return metrics

Exercícios práticos:

  1. Implementar detector de picos R em dados reais
  2. Calcular BPM instantâneo e médio
  3. Extrair métricas HRV completas
  4. Comparar com dispositivos comerciais (validação)

Fase 3: Análise Espectral Avançada (45 min)

Transformada de Fourier e Análise de Frequência

def spectral_analysis(signal_data, fs):
    """
    Análise espectral completa de sinais biomédicos
    """
    # 1. FFT
    freqs = np.fft.fftfreq(len(signal_data), 1/fs)
    fft_magnitude = np.abs(np.fft.fft(signal_data))

    # 2. Densidade espectral de potência (PSD)
    freqs_psd, psd = signal.welch(signal_data, fs, nperseg=1024)

    # 3. Espectrograma (análise tempo-frequência)
    freqs_spec, times_spec, Sxx = signal.spectrogram(
        signal_data, fs, nperseg=256, noverlap=128
    )

    # 4. Características espectrais
    features = extract_spectral_features(freqs_psd, psd)

    return {
        'freqs': freqs_psd,
        'psd': psd,
        'spectrogram': (freqs_spec, times_spec, Sxx),
        'features': features
    }

def extract_spectral_features(freqs, psd):
    """
    Extrai características espectrais para classificação
    """
    # Bandas de frequência para HRV
    vlf_band = (0.003, 0.04)  # Very Low Frequency
    lf_band = (0.04, 0.15)    # Low Frequency
    hf_band = (0.15, 0.4)     # High Frequency

    # Potência em cada banda
    vlf_power = integrate_band(freqs, psd, vlf_band)
    lf_power = integrate_band(freqs, psd, lf_band)
    hf_power = integrate_band(freqs, psd, hf_band)

    features = {
        'vlf_power': vlf_power,
        'lf_power': lf_power,
        'hf_power': hf_power,
        'lf_hf_ratio': lf_power / hf_power if hf_power > 0 else 0,
        'total_power': vlf_power + lf_power + hf_power,
        'peak_frequency': freqs[np.argmax(psd)],
        'spectral_entropy': calculate_spectral_entropy(psd)
    }

    return features

Exercícios avançados:

  1. Análise HRV no domínio da frequência
  2. Detecção de arritmias através de características espectrais
  3. Análise de coerência entre sinais ECG e respiração
  4. Implementar wavelet transform para análise tempo-frequência

Fase 4: Validação e Controlo de Qualidade (30 min)

Métricas de Qualidade de Sinal

def signal_quality_assessment(signal_data, fs):
    """
    Avalia qualidade do sinal através de múltiplas métricas
    """
    quality_metrics = {
        'snr': calculate_snr(signal_data),
        'baseline_drift': measure_baseline_drift(signal_data),
        'artifact_percentage': detect_artifacts(signal_data, fs),
        'signal_variance': np.var(signal_data),
        'kurtosis': stats.kurtosis(signal_data),
        'skewness': stats.skew(signal_data)
    }

    # Score global de qualidade (0-100)
    quality_score = compute_quality_score(quality_metrics)

    return quality_metrics, quality_score

def validate_algorithm_performance(detected_peaks, ground_truth_peaks, tolerance_ms=50):
    """
    Valida performance do algoritmo de detecção contra ground truth
    """
    # Calcular métricas de performance
    tp, fp, fn = match_detections(detected_peaks, ground_truth_peaks, tolerance_ms)

    metrics = {
        'sensitivity': tp / (tp + fn) if (tp + fn) > 0 else 0,
        'ppv': tp / (tp + fp) if (tp + fp) > 0 else 0,  # Positive Predictive Value
        'f1_score': 2 * tp / (2 * tp + fp + fn) if (2 * tp + fp + fn) > 0 else 0,
        'detection_error_rate': (fp + fn) / len(ground_truth_peaks)
    }

    return metrics

Recursos Necessários

Software e Bibliotecas

  • Python 3.8+ com ambiente científico completo
  • Bibliotecas principais:
    • NumPy, SciPy (processamento de sinais)
    • Matplotlib, Seaborn (visualização)
    • Pandas (manipulação de dados)
    • scikit-learn (machine learning básico)
    • pyEDFlib (leitura de ficheiros EDF)
    • heartpy (análise HRV especializada)

Datasets de Treino

  • MIT-BIH Arrhythmia Database (ECG anotado)
  • Dados da Experiência 1 (Arduino/ESP32)
  • MIMIC III Waveform Database (sinais de UCI)
  • Datasets sintéticos com ruído controlado

Hardware de Apoio

  • Computadores com Python configurado
  • Jupyter Notebook ou Google Colab
  • Dispositivos de referência para validação (oxímetro, ECG de 12 derivações)

Tutoriais de Apoio

Metodologias de Ensino

Sessão Teórica (30 min)

  • Fundamentos DSP: Amostragem, Nyquist, aliasing
  • Tipos de ruído em sinais biomédicos
  • Algoritmos clássicos: Pan-Tompkins, Hamilton, Christov
  • Métricas de avaliação em aplicações médicas

Sessão Prática (150 min)

  1. Exploração de dados (30 min): Visualização e caracterização inicial
  2. Implementação de filtros (45 min): Hands-on com diferentes técnicas
  3. Detecção de eventos (45 min): Implementação algoritmos
  4. Validação e otimização (30 min): Teste com dados reais

Trabalho Autónomo (90 min)

  • Otimizar parâmetros dos algoritmos
  • Implementar métricas adicionais de HRV
  • Comparar diferentes algoritmos de detecção
  • Preparar dataset limpo para Experiência 3

Avaliação

Critérios de Avaliação (100 pontos)

  • Implementação de filtros (25 pts): Funcionalidade e adequação
  • Algoritmo de detecção (30 pts): Precisão e robustez
  • Análise espectral (20 pts): Interpretação correta dos resultados
  • Validação (15 pts): Uso adequado de métricas de performance
  • Relatório técnico (10 pts): Discussão crítica dos resultados

Entregáveis

  1. Notebook Jupyter com código comentado e resultados
  2. Dataset processado para use nas experiências seguintes
  3. Relatório de validação (máx. 4 páginas) comparando algoritmos
  4. Função Python reutilizável para processamento de novos dados

Extensões Avançadas

Machine Learning para Detecção

  • Random Forest para classificação de batimentos ECG
  • Deep Learning com CNNs para detecção automática
  • Clustering de batimentos para detecção de arritmias
  • Transfer learning com modelos pré-treinados

Processamento em Tempo Real

  • Implementação de filtros causais
  • Algoritmos de baixa latência
  • Otimização para microcontroladores
  • Integração com ESP32 da Experiência 1

Aplicações Clínicas Específicas

  • Detecção de fibrilhação auricular em PPG
  • Análise de stress através de HRV
  • Monitorização de arritmias contínua
  • Avaliação de fitness cardiovascular

Integração com Pipeline

Input da Experiência 1

  • Dados brutos de sensores Arduino/ESP32
  • Metadados de aquisição (sampling rate, calibração)
  • Timestamps para sincronização multi-sensor

Output para Experiência 3

  • Sinais limpos prontos para armazenamento
  • Características extraídas (BPM, HRV, qualidade)
  • Metadados de processamento (filtros aplicados, parâmetros)
  • Formato estruturado compatível com REDCap/HL7 FHIR

Preparação para Experiências Seguintes

  • APIs de processamento para integração em tempo real
  • Modelos treinados para deploy em produção
  • Benchmarks de performance para otimização de sistemas