Signal Analysis

from src.evm.signal_analysis import extract_temporal_signal

signal = extract_temporal_signal(video_tensor, use_green_channel=True)

signal = []
for frame in video_tensor:
    if use_green_channel and frame.ndim == 3:
        mean_val = np.mean(frame[:, :, 1])  # Green channel (index 1 in BGR)
    else:
        mean_val = np.mean(frame)
    signal.append(mean_val)

return np.array(signal)

from src.evm.signal_analysis import preprocess_signal

processed = preprocess_signal(signal)

# Remove linear trend
signal_detrended = sp_signal.detrend(signal)

# Normalize
signal_std = np.std(signal_detrended)
signal_normalized = signal_detrended / signal_std

from src.evm.signal_analysis import apply_hamming_window

windowed = apply_hamming_window(signal)

from src.evm.signal_analysis import calculate_power_spectrum

fft_freq, power_spectrum = calculate_power_spectrum(signal, fps=30)

# Compute FFT
fft_vals = np.fft.fft(signal)
fft_freq = np.fft.fftfreq(len(signal), d=1.0/fps)

# Power spectrum
power_spectrum = np.abs(fft_vals) ** 2

from src.evm.signal_analysis import find_dominant_frequency

frequency_bpm = find_dominant_frequency(
    fft_freq=fft_freq,
    power_spectrum=power_spectrum,
    lowcut_hz=0.8,
    highcut_hz=3.0,
    min_bpm=40,
    max_bpm=250
)

# Mask frequency range
freq_mask = (fft_freq >= lowcut_hz) & (fft_freq <= highcut_hz)
masked_power = power_spectrum[freq_mask]
masked_freqs = fft_freq[freq_mask]

# Find peak
dominant_freq_hz = masked_freqs[np.argmax(masked_power)]

# Convert to BPM
frequency_bpm = abs(dominant_freq_hz * 60.0)

# Validate range
if frequency_bpm < min_bpm or frequency_bpm > max_bpm:
    return None

from src.evm.signal_analysis import calculate_frequency_fft

heart_rate = calculate_frequency_fft(
    temporal_signal=hr_signal,
    fps=30,
    lowcut_hz=0.83,
    highcut_hz=3.0,
    min_bpm=40,
    max_bpm=250
)

def calculate_frequency_fft(temporal_signal, fps, lowcut_hz, highcut_hz, 
                           min_bpm, max_bpm):
    # Step 1: Preprocessing
    signal_processed = preprocess_signal(temporal_signal)
    if signal_processed is None:
        return None
    
    # Step 2: Hamming window
    signal_windowed = apply_hamming_window(signal_processed)
    
    # Step 3: FFT
    fft_freq, power_spectrum = calculate_power_spectrum(signal_windowed, fps)
    
    # Step 4: Find dominant frequency
    frequency_bpm = find_dominant_frequency(
        fft_freq, power_spectrum, lowcut_hz, highcut_hz, min_bpm, max_bpm
    )
    
    return frequency_bpm

import numpy as np
from src.evm.evm_core import EVMProcessor
from src.evm.signal_analysis import calculate_frequency_fft
from src.config import (
    FPS, LOW_HEART, HIGH_HEART, MIN_HEART_BPM, MAX_HEART_BPM
)

# Process video with EVM
video_frames = [...]  # 200 BGR frames
processor = EVMProcessor()
hr_signal, rr_signal = processor.process_dual_band(video_frames)

print(f"HR signal shape: {hr_signal.shape}")  # (200,)
print(f"HR signal range: {hr_signal.min():.2f} to {hr_signal.max():.2f}")

# Calculate heart rate using FFT
heart_rate = calculate_frequency_fft(
    temporal_signal=hr_signal,
    fps=FPS,                    # 30
    lowcut_hz=LOW_HEART,        # 0.83 Hz
    highcut_hz=HIGH_HEART,      # 3.0 Hz
    min_bpm=MIN_HEART_BPM,      # 40 BPM
    max_bpm=MAX_HEART_BPM       # 250 BPM
)

if heart_rate:
    print(f"Detected Heart Rate: {heart_rate:.1f} BPM")
else:
    print("Heart rate detection failed")

from src.config import (
    LOW_RESP, HIGH_RESP, MIN_RESP_BPM, MAX_RESP_BPM
)

# Use RR signal from dual-band processing
respiratory_rate = calculate_frequency_fft(
    temporal_signal=rr_signal,
    fps=FPS,                    # 30
    lowcut_hz=LOW_RESP,         # 0.18 Hz
    highcut_hz=HIGH_RESP,       # 0.5 Hz
    min_bpm=MIN_RESP_BPM,       # 8 RPM
    max_bpm=MAX_RESP_BPM        # 35 RPM
)

if respiratory_rate:
    print(f"Detected Respiratory Rate: {respiratory_rate:.1f} RPM")
else:
    print("Respiratory rate detection failed")

frequency_bpm = frequency_hz * 60.0