Eulerian Video Magnification

class EVMProcessor:
    """
    Processor for Eulerian Video Magnification (EVM) with optimized configuration.
    
    Performs single-pass dual-band processing:
    - Builds Laplacian pyramids once
    - Applies two separate temporal filters (HR and RR frequency bands)
    - Amplifies each band with its corresponding alpha factor
    - Extracts both heart rate (HR) and respiratory rate (RR) temporal signals
    """
    
    def __init__(self, levels=LEVELS_RPI, alpha_hr=ALPHA_HR, alpha_rr=ALPHA_RR):
        self.levels = levels
        self.alpha_hr = alpha_hr  # Default: 30
        self.alpha_rr = alpha_rr  # Default: 50

def build_gaussian_pyramid(frame, levels=LEVELS_RPI):
    pyramid = []
    current = frame.astype(np.float32)
    pyramid.append(current)
    
    for _ in range(levels):
        current = cv2.pyrDown(current)  # Gaussian blur + 2x downsample
        pyramid.append(current)
    
    return pyramid

def build_laplacian_pyramid(gaussian_pyramid):
    laplacian_pyramid = []
    
    for i in range(len(gaussian_pyramid) - 1):
        size = (gaussian_pyramid[i].shape[1], gaussian_pyramid[i].shape[0])
        expanded = cv2.pyrUp(gaussian_pyramid[i + 1], dstsize=size)
        laplacian = cv2.subtract(gaussian_pyramid[i], expanded)
        laplacian_pyramid.append(laplacian)
    
    # Last level is the same as Gaussian
    laplacian_pyramid.append(gaussian_pyramid[-1])
    
    return laplacian_pyramid

def extract_pyramid_level(pyramid_stack, level):
    """
    Extract specific level from all pyramids and normalize dimensions.
    
    Returns:
        np.ndarray: Tensor (T x H x W x C) of specified pyramid level
    """
    level_frames = []
    
    for pyr in pyramid_stack:
        if level < len(pyr):
            level_frames.append(pyr[level])
        else:
            level_frames.append(pyr[-1])  # Fallback to last level
    
    # Determine target shape (most common shape)
    shapes = [frame.shape for frame in level_frames]
    target_shape = most_common(shapes)
    
    # Resize frames to target shape if needed
    level_resized = []
    for frame in level_frames:
        if frame.shape != target_shape:
            frame = cv2.resize(frame, (target_shape[1], target_shape[0]))
        level_resized.append(frame)
    
    return np.array(level_resized, dtype=np.float32)

ALPHA_HR = 30  # Amplification factor for heart rate band

ALPHA_RR = 50  # Amplification factor for respiratory rate band

# Typical memory footprint for 30 frames @ 320x240 resolution:
frames = 30 × 320 × 240 × 3 bytes = 6.9 MB (input)
pyramids = frames × (1 + 0.25 + 0.0625 + ...) ≈ 9.2 MB
level_3 = 30 × 40 × 30 × 3 × 4 bytes = 432 KB
level_2 = 30 × 80 × 60 × 3 × 4 bytes = 1.7 MB

from src.evm.evm_manager import process_video_evm_vital_signs

# Process video frames
video_frames = [...]  # List of BGR frames from ROI

results = process_video_evm_vital_signs(video_frames, verbose=True)

if results['heart_rate']:
    print(f"Heart Rate: {results['heart_rate']:.1f} BPM")

if results['respiratory_rate']:
    print(f"Respiratory Rate: {results['respiratory_rate']:.1f} RPM")