Preprocessing.ipynb

import os
# Suppress MediaPipe/Abseil C++ logging noise (Levels: 0 = INFO, 1 = WARNING, 2 = ERROR, 3 = FATAL)
os.environ['GLOG_minloglevel'] = '2'
os.environ['ABSL_MIN_LOG_LEVEL'] = '2'

import cv2
import numpy as np
import pandas as pd
from pathlib import Path
from glob import glob
import scipy.signal
import mediapipe as mp
from concurrent.futures import ThreadPoolExecutor, as_completed

# ==================== DIRECTORY CONFIGURATION ====================
RAW_VIDEO_DIR   = "/home/cristic/data/Bgeorge/mcd_rppg/snapshots/929fb19c5ff2b5c8ed64a7c3a123744346674e88/video/"
PPG_SYNC_DIR    = "/home/cristic/data/Bgeorge/mcd_rppg/snapshots/929fb19c5ff2b5c8ed64a7c3a123744346674e88/ppg_sync/"
CALE_CSV        = "/home/cristic/rppg_project/data/raw/mcd_rppg/db.csv"

# OUTPUT_BASE     = "/home/cristic/rppg_project/data/processed/"
# FACES_DIR       = os.path.join(OUTPUT_BASE, "faces")
# LANDMARKS_DIR   = os.path.join(OUTPUT_BASE, "landmarks")
# ROI_DIR         = os.path.join(OUTPUT_BASE, "roi")
# Output Directories
OUTPUT_BASE     = "/home/cristic/RppG_mediapipe_preprocessed_full_dataset3/"
FACES_DIR       = os.path.join(OUTPUT_BASE, "faces")
LANDMARKS_DIR   = os.path.join(OUTPUT_BASE, "landmarks")
ROI_DIR         = os.path.join(OUTPUT_BASE, "roi")

WINDOW_FRAMES   = 450
VIDEO_FS        = 29.9  # Set to match your video stream profile
NUM_WORKERS     = 40  

# ==================== ORIGINAL REPO UTILITIES ====================
def filter_signal(signal_arr, rate, freq, mode='high', order=4):
    hb_n_freq = freq / (rate / 2)
    b, a = scipy.signal.butter(order, hb_n_freq, mode)
    filtered = scipy.signal.filtfilt(b, a, signal_arr)
    return filtered.astype(signal_arr.dtype)

def bandpass_filter(signal_arr, rate, low_freq=0.5, high_freq=3.5, order=4):
    signal_arr = filter_signal(signal_arr, rate, high_freq, mode='low',  order=order)
    signal_arr = filter_signal(signal_arr, rate, low_freq,  mode='high', order=order)
    return signal_arr

def _next_power_of_2(x):
    return 1 if x == 0 else 2 ** (x - 1).bit_length()

def calculate_fft_hr(ppg_signal, fs=29.9, low_pass=0.5, high_pass=3.5):
    ppg_signal = np.expand_dims(ppg_signal, 0)
    N = _next_power_of_2(ppg_signal.shape[1])
    f_ppg, pxx_ppg = scipy.signal.periodogram(ppg_signal, fs=fs, nfft=N, detrend=False)
    fmask_ppg = np.argwhere((f_ppg >= low_pass) & (f_ppg <= high_pass))
    mask_ppg = np.take(f_ppg, fmask_ppg)
    mask_pxx = np.take(pxx_ppg, fmask_ppg)
    fft_hr = np.take(mask_ppg, np.argmax(mask_pxx, 0))[0] * 60
    return fft_hr

# def get_roi_regions(frame, landmarks, h, w):
#     return np.zeros((8, 32, 32, 3), dtype=np.uint8)
def get_roi_regions(frame, landmarks, h, w):
    """
    Extracts 8 distinct facial tissue patches using specific MediaPipe landmark indices.
    Crops them from the frame, resizes each to 32x32 pixels, and stacks them.
    """
    roi_patches = np.zeros((8, 32, 32, 3), dtype=np.uint8)
    
    # 8 Key groups of landmark IDs corresponding to strong vascular regions
    # (Cheeks, forehead segments, nose bridge, chin)
    roi_landmark_groups = [
        [70, 71, 139, 156],   # 0: Left Forehead
        [300, 301, 368, 383], # 1: Right Forehead
        [117, 118, 101, 50],   # 2: Left Upper Cheek
        [346, 347, 330, 280], # 3: Right Upper Cheek
        [205, 206, 207, 187], # 4: Left Lower Cheek / Jaw area
        [425, 426, 427, 411], # 5: Right Lower Cheek / Jaw area
        [6, 197, 195, 5],     # 6: Nose Bridge
        [199, 200, 18, 42]     # 7: Chin / Lower Lip area
    ]
    
    for idx, group in enumerate(roi_landmark_groups):
        try:
            # 1. Gather all pixel coordinates for the current landmark group
            pts = []
            for lm_idx in group:
                lm = landmarks[lm_idx]
                pt_x = int(lm.x * w)
                pt_y = int(lm.y * h)
                pts.append([pt_x, pt_y])
            
            pts = np.array(pts)
            
            # 2. Compute a tight bounding box around those landmarks
            xmin, ymin = np.min(pts, axis=0)
            xmax, ymax = np.max(pts, axis=0)
            
            # 3. Add dynamic safety margins to make the crop useful
            box_w = xmax - xmin
            box_h = ymax - ymin
            margin_x = int(box_w * 0.1)
            margin_y = int(box_h * 0.1)
            
            xmin = max(0, xmin - margin_x)
            ymin = max(0, ymin - margin_y)
            xmax = min(w, xmax + margin_x)
            ymax = min(h, ymax + margin_y)
            
            # 4. Extract and resize slice if it forms a valid spatial patch
            if (xmax - xmin) > 4 and (ymax - ymin) > 4:
                crop = frame[ymin:ymax, xmin:xmax]
                roi_patches[idx] = cv2.resize(crop, (32, 32))
            else:
                # Fallback to zero placeholder if crop fails bounds
                pass
                
        except Exception:
            # Catch exceptions for edge-of-frame tracking failures gracefully
            pass
            
    return roi_patches
# ==================== CORE PROCESSING WORKER ====================
def process_single_video(task_args):
    video_path, ppg_path, meta_dict, base_name = task_args
    
    BaseOptions = mp.tasks.BaseOptions
    FaceLandmarker = mp.tasks.vision.FaceLandmarker
    FaceLandmarkerOptions = mp.tasks.vision.FaceLandmarkerOptions
    VisionRunningMode = mp.tasks.vision.RunningMode
    
    model_path = "/home/cristic/face_landmarker.task"
    if not os.path.exists(model_path):
        return False, f"[{base_name}] Model missing at: {model_path}"

    options = FaceLandmarkerOptions(
        base_options=BaseOptions(model_asset_path=model_path),
        running_mode=VisionRunningMode.IMAGE,
        num_faces=1
    )
    
    try:
        with FaceLandmarker.create_from_options(options) as landmarker:
            # 1. Parse frame bounds
            cap = cv2.VideoCapture(video_path)
            if not cap.isOpened():
                return False, f"[{base_name}] Failed to open stream."
            
            w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
            h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
            
            total_frames = 0
            while cap.grab():
                total_frames += 1
            cap.release()
            
            if total_frames < WINDOW_FRAMES:
                return False, f"[{base_name}] Skipped: Frame count ({total_frames}) under window."

            # 2. Extract and match original repository 1D PPG wave rules
            try:
                raw_matrix = np.loadtxt(ppg_path, dtype=np.float32)
                
                # Enforce strict 1D selection of Column 1 (the physiological wave channel)
                if raw_matrix.ndim > 1:
                    raw_ppg_wave = raw_matrix[:, 1].copy()
                else:
                    raw_ppg_wave = raw_matrix.copy()
                    
                # Fix the artifact spike at Index-0 to prevent filter distortion
                if len(raw_ppg_wave) > 1:
                    raw_ppg_wave[0] = raw_ppg_wave[1]
                    
            except Exception as e:
                return False, f"[{base_name}] Matrix parse fail: {e}"

            # 3. Chunk Processing
            cap = cv2.VideoCapture(video_path)
            num_chunks = total_frames // WINDOW_FRAMES
            
            for chunk_idx in range(num_chunks):
                faces_buf = []
                landmarks_buf = []
                roi_slices_buf = []
                
                start_f = chunk_idx * WINDOW_FRAMES
                end_f = start_f + WINDOW_FRAMES
                
                # Slice target wave segment
                ppg_chunk = raw_ppg_wave[start_f:min(end_f, len(raw_ppg_wave))].copy()
                if len(ppg_chunk) < WINDOW_FRAMES:
                    ppg_chunk = np.pad(ppg_chunk, (0, WINDOW_FRAMES - len(ppg_chunk)), mode='edge')
                
                # Apply Repository filtering and standardization sequence
                ppg_chunk = bandpass_filter(ppg_chunk, rate=VIDEO_FS, low_freq=0.5, high_freq=3.5, order=4)
                ppg_chunk -= ppg_chunk.mean()
                ppg_chunk /= (ppg_chunk.std() + 1e-9)
                
                # Compute HR via padded original repo FFT logic
                calculated_hr = int(np.round(calculate_fft_hr(ppg_chunk, fs=VIDEO_FS)))
                
                for _ in range(WINDOW_FRAMES):
                    ret, frame = cap.read()
                    if not ret:
                        break
                        
                    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                    mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_frame)
                    detection_result = landmarker.detect(mp_image)
                    
                    if detection_result.face_landmarks:
                        landmarks = detection_result.face_landmarks[0]
                        coords = np.array([[lm.x * w, lm.y * h] for lm in landmarks], dtype=np.float32)
                        all_pts = np.array([[int(lm.x * w), int(lm.y * h)] for lm in landmarks])
                        xmin, ymin = np.clip(np.min(all_pts, axis=0), 0, [w, h])
                        xmax, ymax = np.clip(np.max(all_pts, axis=0), 0, [w, h])
                        
                        if (xmax - xmin) > 0 and (ymax - ymin) > 0:
                            face_crop = cv2.resize(frame[ymin:ymax, xmin:xmax], (128, 128))
                        else:
                            face_crop = np.zeros((128, 128, 3), dtype=np.uint8)
                        roi_regions = get_roi_regions(frame, landmarks, h, w)
                    else:
                        coords = landmarks_buf[-1] if landmarks_buf else np.zeros((478, 2), dtype=np.float32)
                        face_crop = faces_buf[-1] if faces_buf else np.zeros((128, 128, 3), dtype=np.uint8)
                        roi_regions = roi_slices_buf[-1] if roi_slices_buf else np.zeros((8, 32, 32, 3), dtype=np.uint8)
                        
                    faces_buf.append(face_crop)
                    landmarks_buf.append(coords)
                    roi_slices_buf.append(roi_regions)
                
                if len(faces_buf) < WINDOW_FRAMES:
                    break 
                    
                chunk_name = f"{base_name}_chunk{chunk_idx}"
                
                np.save(os.path.join(FACES_DIR, f"{chunk_name}_faces.npy"), np.array(faces_buf))
                np.save(os.path.join(LANDMARKS_DIR, f"{chunk_name}_landmarks.npy"), np.array(landmarks_buf))
                
                np.savez_compressed(
                    os.path.join(ROI_DIR, f"{chunk_name}.npz"),
                    roi=np.array(roi_slices_buf),
                    ppg=ppg_chunk.astype('float32'),  # Normalized continuous waveform array matching repo layout
                    hr=calculated_hr,                 # The strict integer FFT tracking parameter
                    subject_id=str(meta_dict.get('patient_id', meta_dict.get('id', ''))),
                    age=float(meta_dict.get('age', 0)),
                    sex=str(meta_dict.get('sex', '')),
                    bmi=float(meta_dict.get('bmi', 0)),
                    systolic=float(meta_dict.get('upper_ap', 0)),
                    diastolic=float(meta_dict.get('lower_ap', 0)),
                    spo2=float(meta_dict.get('saturation', 0)),
                    temperature=float(meta_dict.get('temperature', 0))
                )
                
            cap.release()
            return True, f"[{base_name}] Completed into {num_chunks} chunks."
            
    except Exception as e:
        return False, f"[{base_name}] Process Exception: {str(e)}"

def main():
    os.makedirs(FACES_DIR, exist_ok=True)
    os.makedirs(LANDMARKS_DIR, exist_ok=True)
    os.makedirs(ROI_DIR, exist_ok=True)
    
    print("[*] Indexing raw data assets...")
    video_files = sorted(glob(os.path.join(RAW_VIDEO_DIR, "*.avi")) + glob(os.path.join(RAW_VIDEO_DIR, "*.mp4")))
    
    if not os.path.exists(CALE_CSV):
        print(f"[!] Metadata index CSV missing at: {CALE_CSV}")
        return
        
    df_meta = pd.read_csv(CALE_CSV)
    task_queue = []
    
    for v_path in video_files:
        b_name = Path(v_path).stem
        p_path = os.path.join(PPG_SYNC_DIR, f"{b_name}.txt")
        if not os.path.exists(p_path):
            continue
            
        matching_rows = df_meta[df_meta['video'].str.contains(b_name, na=False)]
        meta_dict = matching_rows.iloc[0].to_dict() if not matching_rows.empty else {}
        task_queue.append((v_path, p_path, meta_dict, b_name))
        
    print(f"[+] Total verified matches ready to execute: {len(task_queue)}")
    print(f"[*] Instantiating ThreadPoolExecutor pipeline using {NUM_WORKERS} concurrent execution instances...")
    
    success_count = 0
    with ThreadPoolExecutor(max_workers=NUM_WORKERS) as executor:
        futures = {executor.submit(process_single_video, task): task for task in task_queue}
        
        for idx, future in enumerate(as_completed(futures)):
            success, message = future.result()
            if success:
                success_count += 1
            else:
                print(f"[!] Alert: {message}")
                
            if idx % 50 == 0:
                print(f"Progress checkpoint: {idx}/{len(task_queue)} tracks processed...")
                
    print("\n" + "="*50)
    print(f" PREPROCESSING ARCHITECTURE INGESTION DONE!")
    print(f" Successfully complete targets: {success_count} / {len(task_queue)}")
    print("="*50)

if __name__ == "__main__":
    main()